[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+;
 const int N=,D=;
 char s[N],l[D],r[D];
 int n,d;
 class AhoCorasickAutomaton {
     private:
         static const int SIGMA_SIZE=;
         struct Node {
             Node *ch[SIGMA_SIZE],*fail;
             bool isEnd;
             int id;
             Node(const int i) {
                 memset(ch,,sizeof ch);
                 fail=NULL;
                 isEnd=false;
                 id=i;
             }
         };
         Node *root;
         std::vector<Node*> v;
         int idx(const char ch) {
             return ch-'';
         }
         int f[][N*D>>],g[][N*D>>];
         //第一维表示与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=;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=;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=;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=;i<v.size();i++) {
                 Node *p=v[i];
                 for(int i=;i<SIGMA_SIZE;i++) {
                     if(p->ch[i]->isEnd) {
                         p->ch[i]=end;
                     }
                 }
             }
             for(int i=;i<SIGMA_SIZE;i++) {
                 end->ch[i]=end;
             }
             v.push_back(end);
         }
         int dp() {
             g[][]=;
             int to[];
             for(int i=;i<d;i++) {
                 for(int i=;i<;i++) {
                     for(unsigned j=;j<v.size();j++) {
                         f[i][j]=;
                     }
                 }
                 for(int j=;j<;j++) {
                     int st=(j&)?:idx(l[i]),en=(j>)?:idx(r[i]);//确定当前数位数字的上下界
                     for(int i=st;i<=en;i++) to[i]=0b11;//默认是在l和r之间
                     if(~j&) to[st]&=0b10;//如果比l小
                     if(j<) to[en]&=0b01;//如果比r大
                     //用&是因为有可能st=en
                     for(unsigned k=;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=;
             for(int i=;i<;i++) {
                 ret=(ret+g[i][v.size()-])%mod;
             }
             return ret;
         }
 };
 AhoCorasickAutomaton acam;
 int main() {
     scanf("%s%s%s",s,l,r);
     n=strlen(s),d=strlen(l);
     for(int i=;i<=n-d/;i++) {
         acam.insert(&s[i],d/);
     }
     acam.getFail();
     printf("%d\n",acam.dp());
     return ;
 }