hdu-6644 11 Dimensions

题目链接

11 Dimensions

Problem Description

11 Dimensions is a cute contestant being talented in math. One day, 11 Dimensions came across a problem but didn't manage to solve it. Today you are taking training here, so 11 Dimensions turns to you for help.

You are given a decimal integer S with n bits s1s2…sn(0≤si≤9), but some bits can not be recognized now(replaced by "?''). The only thing you know is that Sis a multiple of a given integer m.

There may be many possible values of the original S, please write a program to find the k-th smallest value among them. Note that you need to answer q queries efficiently.

Input

The first line of the input contains an integer T(1≤T≤10000), denoting the number of test cases.

In each test case, there are three integers n,m,q(1≤n≤50000,2≤m≤20,1≤q≤100000) in the first line, denoting the length of S, the parameter m, and the number of queries.

In the second line, there is a string s of length n, denoting the given decimal integer S. It is guaranteed that si is either an integer within [0,9] or ``?'', and s1 is always an integer within [1,9].

For the next q lines, each line contains an integer ki(1≤ki≤1018), denoting each query.

It is guaranteed that ∑n≤500000 and ∑q≤10^6.

Output

For each query, print a single line containing an integer, denoting the value of S. If the answer exists, print Smod(10^9+7) instead, otherwise print ``-1''.

Sample Input

1

5 5 5

2??3?

1

2

3

100

10000

Sample Output

20030

20035

20130

24935

-1

题意

给一个长度为n的数字，某些位丢失变成了'?'，让你给这些问号填上数字，使得整个数字是m的倍数，且是所有方案中第K小的方案，最后输出整个数字取模1e9+7

题解

对于一个数字\(123??21?\)可以拆成两部分\(12300210\)和\(??00?\)，先把\(12300210\)对m取模，假设结果为a，那么要让原数字整除m，问题就变成使 \(??00? \mod m = m-a\)

设\(dp[i][j]\)表示倒数i个问号已经填好，取模m结果为j的方案数，输出答案时只要逐位枚举？就行了，但是查询量太大，问号个数也很大，逐位枚举会超时，实际上只要枚举最后二三十个问号，前面的问号全部填0，因为b个问号可以填的方案数是\(10^b\)，假设这\(10^b\)个方案数取模m的结果是均匀的，也就是说取模m为\([1,m-1]\)的方案数大致都在\(\frac{10^b}{m}\)左右，k只有\(10^{18}，m只有20\)，b取30就肯定足以把结果涵盖进去了。

代码

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int mx = 50005;
const int mod = 1e9+7;
const ll INF = 1LL<<61;
char str[mx];
int pos[mx];
ll dp[mx][20];
ll pm[mx], pmod[mx];
int pow_mod(ll a, ll b, ll c) {
    ll ans = 1;
    while (b > 0) {
        if (b & 1) ans = ans * a % c;
        a = a * a % c;
        b /= 2;
    }
    return ans;
}

int main() {
    int T;
    scanf("%d", &T);

    while(T--) {
        int n, m, q, cnt = 0;
        scanf("%d%d%d", &n, &m, &q);
        scanf("%s", str+1);
        int len = std::strlen(str+1);
        int ans_mod = 0;
        ll ans = 0;
        for (int i = 1; i <= len; i++) {
            ans_mod = ans_mod * 10;
            ans = ans * 10;
            if (str[i] != '?') {
                ans_mod = ans_mod + (str[i] - '0');
                ans = ans + (str[i] - '0');
            }
            ans_mod %= m;
            ans %= mod;
        }
        for (int i = len; i >= 1; i--)
            if (str[i] == '?') pos[++cnt] = len-i;

        for (int i = 1; i <= cnt; i++) {
            pm[i] = pow_mod(10, pos[i], m);
            pmod[i] = pow_mod(10, pos[i], mod);
        }

        ans_mod = (m-ans_mod) % m;

        for (int i = 1; i <= cnt; i++) memset(dp[i], 0, sizeof(dp[i]));

        dp[0][0] = 1;
        for (int i = 1; i <= cnt; i++) {
            for (int j = 0; j <= 9; j++) {
                int tmp = j * pm[i] % m;
                for (int k = 0; k < m; k++) {
                    dp[i][(tmp+k)%m] += dp[i-1][k];
                    if (dp[i][(tmp+k)%m] > INF) dp[i][(tmp+k)%m] = INF;
                }
            }
        }

        ll tmp = ans;
        while (q--) {
            ll k;
            scanf("%lld", &k);
            if (dp[cnt][ans_mod] < k) {
                puts("-1");
                continue;
            }

            int now_mod = ans_mod, next_mod;
            ans = tmp;

            for (int i = min(cnt, 30); i >= 1; i--) {

                for (int j = 0; j <= 9; j++) {
                    int next_mod = (now_mod - (j*pm[i]%m) + m) % m;
                    if (dp[i-1][next_mod] < k) {
                        k -= dp[i-1][next_mod];
                    } else {
                        ans += j * pmod[i] % mod;
                        ans %= mod;
                        now_mod = next_mod;
                        break;
                    }
                }
            }

            printf("%lld\n", ans % mod);
        }

    }
    return 0;
}