[CodeForces-585F]Digits of Number Pi

题目大意：
　　给你一个数字串s，一个序列范围l和r，（l和r的数字位数为d）求l到r中有多少个数，满足它的长度为d/2的子串，能够在s中被匹配。

思路：
　　首先将s中每一个长度为d/2的子串插入后缀自动机。
　　然后数位DP。
　　f[i][j]中第一维表示当前树与l和r的关系，包含四个状态，用二进制表示，每一位对应与l和r的不同关系。
　　第二维表示当前状态下每个结点匹配到的数的个数。
　　每一个数位的状态由上一个数位转移而来，我们用两个DP数组f和g滚动实现。
　　用o表示当前枚举的数字，用to表示数字所对应的第一维的状态，则转移方程为f[to[o]][p]=sum(f[j][par[p]])
　　然而一开始写AC自动机用的是指针，然后又是各种不方便，所以又用vector很粗糙地实现了结点的遍历。故常数巨大。 

#pragma GCC optimize("O3") 
#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
const int mod=1e9+7;
const int N=1001,D=51;
char s[N],l[D],r[D];
int n,d;
class AhoCorasickAutomaton {
    private:
        static const int SIGMA_SIZE=10;
        struct Node {
            Node *ch[SIGMA_SIZE],*fail;
            bool isEnd;
            int id;
            Node(const int i) {
                memset(ch,0,sizeof ch);
                fail=NULL;
                isEnd=false;
                id=i;
            }
        };
        Node *root;
        std::vector<Node*> v; 
        int idx(const char ch) {
            return ch-'0';
        }
        int f[4][N*D>>1],g[4][N*D>>1];
        //第一维表示与l和r的关系
    public:
        AhoCorasickAutomaton() {
            root=new Node(v.size());
            v.push_back(root);
        }
        void insert(char s[],const int len) {
            Node *p=root;
            for(int i=0;i<len;i++) {
                const int w=idx(s[i]);
                if(!p->ch[w]) {
                    p->ch[w]=new Node(v.size());
                    v.push_back(p->ch[w]);
                }
                p=p->ch[w];
            }
            p->isEnd=true;
        }
        void getFail() {
            std::queue<Node*> q;
            root->fail=root;
            for(int i=0;i<SIGMA_SIZE;i++) {
                if(root->ch[i]) {
                    root->ch[i]->fail=root;
                    q.push(root->ch[i]);
                } else {
                    root->ch[i]=root;
                }
            }
            while(!q.empty()) {
                Node *p=q.front();
                q.pop();
                for(int i=0;i<SIGMA_SIZE;i++) {
                    if(p->ch[i]) {
                        p->ch[i]->fail=p->fail->ch[i];
                        q.push(p->ch[i]);
                    } else {
                        p->ch[i]=p->fail->ch[i];
                    }
                }
            }
            Node *end=new Node(v.size());
            for(unsigned i=0;i<v.size();i++) {
                Node *p=v[i];
                for(int i=0;i<SIGMA_SIZE;i++) {
                    if(p->ch[i]->isEnd) {
                        p->ch[i]=end;
                    }
                }
            }
            for(int i=0;i<SIGMA_SIZE;i++) {
                end->ch[i]=end;
            }
            v.push_back(end);
        }
        int dp() {
            g[0][0]=1;
            int to[10];
            for(int i=0;i<d;i++) {
                for(int i=0;i<4;i++) {
                    for(unsigned j=0;j<v.size();j++) {
                        f[i][j]=0;
                    }
                }
                for(int j=0;j<4;j++) {
                    int st=(j&1)?0:idx(l[i]),en=(j>1)?9:idx(r[i]);//确定当前数位数字的上下界 
                    for(int i=st;i<=en;i++) to[i]=0b11;//默认是在l和r之间 
                    if(~j&1) to[st]&=0b10;//如果比l小 
                    if(j<2) to[en]&=0b01;//如果比r大
                    //用&是因为有可能st=en 
                    for(unsigned k=0;k<v.size();k++) {
                        if(!g[j][k]) continue;
                        for(int o=st;o<=en;o++) {//在当前数位的范围寻找子结点 
                            (f[to[o]][v[k]->ch[o]->id]+=g[j][k])%=mod;
                        }
                    }
                }
                std::swap(f,g);
            }
            int ret=0;
            for(int i=0;i<4;i++) {
                ret=(ret+g[i][v.size()-1])%mod;
            }
            return ret;
        }
};
AhoCorasickAutomaton acam;
int main() {
    scanf("%s%s%s",s,l,r);
    n=strlen(s),d=strlen(l);
    for(int i=0;i<=n-d/2;i++) {
        acam.insert(&s[i],d/2);
    }
    acam.getFail();
    printf("%d\n",acam.dp());
    return 0;
}