bzoj 3530[Sdoi2014]数数

3530: [Sdoi2014]数数

Time Limit: 10 Sec  Memory Limit: 512 MB

Description

我们称一个正整数N是幸运数，当且仅当它的十进制表示中不包含数字串集合S中任意一个元素作为其子串。例如当S=(22，333，0233)时，233是幸运数，2333、20233、3223不是幸运数。
    给定N和S，计算不大于N的幸运数个数。

Input

    输入的第一行包含整数N。
    接下来一行一个整数M，表示S中元素的数量。
    接下来M行，每行一个数字串，表示S中的一个元素。

Output

    输出一行一个整数，表示答案模109+7的值。

Sample Input

20
3
2
3
14

Sample Output

14

HINT

 下表中l表示N的长度，L表示S中所有串长度之和。

1 < =l < =1200 , 1 < =M < =100 ,1 < =L < =1500

对于这类问题，我们可以用 AC自动机套dp 来解决

因为对于位数比N少的，有前导零不好处理，所以我们分开讨论

如果位数比N少，就和N的大小没有关系，我们可以直接转移

g[i][j] 表示 当前是第 i 位 并且 走到 AC自动机上的 j 节点的方案数

转移方程就是  g[i + 1][nxt[j]] += g[i][j] (!judge[nxt[j]]);

ANS = sum(g[i][j]) （i = 1 ~ N - 1, j = 0 ~ tot）;

对于 位数和N相同的类似操作， 只需要加一维 表示前缀是否和N相同  0 表示不同， 1 表示相同

如果是 0 的话后面就随便加， 1 再判断一下 ， 和数位dp 思想很像

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue> 
#include <algorithm>
#define LL long long

using namespace std; 
 
queue<int> q;

LL ans = 0;

int N, M;
int ln;
char s[2000]; 
LL g[1300][1600];
LL f[2][1300][1600]; // 1 有限制， 0 表示无限制 
int tot = 0;
LL mod = 1e9 + 7;

inline LL read()
{
    LL x = 0, w = 1; char ch = 0;
    while(ch < '0' || ch > '9') {
        if(ch == '-') {
            w = -1;
        }
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * w;
}

const int MAXN = 1e6 + 10;

int d[MAXN];

struct trie {
    int str[15];
    int fail;
    int num;
    int judge;
    void init()
    {
        memset(str, 0, sizeof str);
        fail = 0;
        judge = 0;
    }
} t[MAXN];

void insert(int root, int k)
{
    for(int i = 1; i <= k; i++) {
        int nxt = s[i] - '0';
        if(t[root].str[nxt] == 0) {
            t[root].str[nxt] = ++tot;
            t[tot].init();
            t[tot].num = nxt; 
        }
        root = t[root].str[nxt];
    }
    t[root].judge = 1;
}

void getfail()
{
    for(int i = 0; i <= 9; i++) {
        if(t[0].str[i]) {
            q.push(t[0].str[i]);
        }
    }
    while(!q.empty()) {
        int tt = q.front();
        q.pop();
        for(int j = 0; j <= 9; j++) {
            if(t[tt].str[j]) {
                int f = t[tt].fail;
                while(t[f].str[j] == 0) {
                    if(f == 0) {
                        break;
                    }
                    f = t[f].fail;
                }
                t[t[tt].str[j]].fail = t[f].str[j];
                q.push(t[tt].str[j]);
            }
        }
    }
}

int main()
{
    scanf("%s", s + 1);
    ln = strlen(s + 1);
    for(int i = 1; i <= ln; i++) {
        d[i] = s[i] - '0';
    }
    M = read();
    for(int i = 1; i <= M; i++) {
        scanf("%s", s + 1);
        int len = strlen(s + 1);
        insert(0, len);
    }
    getfail();
    g[0][0] = 1;
    for(int i = 0; i < ln; i++) {
        for(int j = 0; j <= tot; j++) {
            for(int k = 0; k <= 9; k++) {
                if(i == 0 && k == 0) {
                    continue;
                }
                int nxt = t[j].str[k];
                int cnt = j;
                while(nxt == 0) {
                    if(cnt == 0) {
                        break;
                    }
                    cnt = t[cnt].fail;
                    nxt = t[cnt].str[k];
                }
                if(!t[nxt].judge) {
                    g[i + 1][nxt] = (g[i + 1][nxt] + g[i][j]) % mod;
                }
            }
        }
    }
    f[1][0][0] = 1;
    for(int i = 0; i < ln; i++) {
        for(int j = 0; j <= tot; j++) {
            for(int k = 0; k <= 9; k++) {
                if(i == 0 && k == 0) {
                    continue;
                }
                int nxt = t[j].str[k];
                int cnt = j;
                while(nxt == 0) {
                    if(cnt == 0) {
                        break;
                    }
                    cnt = t[cnt].fail;
                    nxt = t[cnt].str[k];
                }
                if(!t[nxt].judge) {
                    if(k < d[i + 1]) {
                        f[0][i + 1][nxt] = (f[0][i + 1][nxt] + f[1][i][j] + f[0][i][j]) % mod;
                    } else if(k == d[i + 1]) {
                        f[0][i + 1][nxt] = (f[0][i + 1][nxt] + f[0][i][j]) % mod;
                        f[1][i + 1][nxt] = (f[1][i + 1][nxt] + f[1][i][j]) % mod;
                    } else {
                        f[0][i + 1][nxt] = (f[0][i + 1][nxt] + f[0][i][j]) % mod;
                    }
                }
            }
        }
    }
    for(int i = 1; i < ln; i++) {
        for(int j = 0; j <= tot; j++) {
            ans = (ans + g[i][j]) % mod; 
        }
    }
    /*for(int i = 1; i <= ln; i++) {
        for(int j = 0; j <= tot; j++) {
            cout<<t[j].num<<" "<<f[0][i][j]<<" "<<f[1][i][j]<<endl;
        }
        cout<<endl<<endl;
    }*/
    for(int j = 0; j <= tot; j++) {
        ans = (ans + f[0][ln][j] + f[1][ln][j]) % mod;
    }
    printf("%lld
", ans);
}



/*

20
3
2
3
14

*/