ZOJ 3494

超级神奇有趣题。

AC自动机+数位DP。其实，数位DP在处理含有某些数字时特别不好处理，应该把它倒转为求不含有。这道题把数位DP+AC自动机结合起来，实在是很巧妙，把数字变为串来处理，强大！

要使用AC自动机来处理数位DP，首先就是要确定哪些状态由当前状态开始是不可以到达的，有哪些是可以到达的。这是显而易见的，因为既然是数位DP，必定涉及到数字的问题，每改变一个数字就会到达自动机上的一个状态，确定哪些状态可达或不可达是很有必要的。这就要求要构建trie图了。

其次就是DFS了，在进行DFS深搜前，要确定当前状态变更一个数字后的状态是否可达，再进行转移。

在这题，要处理前导0的问题，因为0000（十进制）里，其实只代表一个0，但可能会出现禁止状态（如二进制连续五个0违法，但四个0不违法）。

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #define LL long long
 using namespace std;
 const LL MOD=;
 const int root=;
 int trie[][],tot,bit[];
 int next[][],fail[];
 bool tag[];
 char str[];
 LL dp[][];
 int que[],head,tail;

 void clr(int now){
     trie[now][]=trie[now][]=-;
 }

 void insert(){
     int p=root,i=,len=strlen(str);
     while(i++<len){
         if(trie[p][str[i-]-'']==-){
             trie[p][str[i-]-'']=++tot;
             clr(tot);
         }
         p=trie[p][str[i-]-''];
     }
     tag[p]=true;
 }

 void build_ac(){
     head=tail=;
     que[tail++]=root;
     while(head!=tail){
         int tmp=que[head++];
         int p=-;
         for(int i=;i<;i++){
             if(trie[tmp][i]!=-){
                 if(tmp==root) fail[trie[tmp][i]]=root;
                 else{
                     p=fail[tmp];
                     while(p!=-){
                         if(trie[p][i]!=-){
                             fail[trie[tmp][i]]=trie[p][i];
                             break;
                         }
                         p=fail[p];
                     }
                     if(p==-) fail[trie[tmp][i]]=root;
                 }
                 if(tag[fail[trie[tmp][i]]]) tag[trie[tmp][i]]=tag[fail[trie[tmp][i]]];
                 que[tail++]=trie[tmp][i];
             }
             else{
                 if(tmp==root) trie[tmp][i]=root;
                 else{
                     p=fail[tmp];
                     while(p!=-){
                         if(trie[p][i]!=-){
                             trie[tmp][i]=trie[p][i];
                             break;
                         }
                         p=fail[p];
                     }
                     if(p==-) trie[tmp][i]=root;
                 }
             }
         }
     }
 }

 void interval(){
     int len=strlen(str)-;
     char tmp;
     for(int i=len;i>=len-i;i--){
         tmp=str[i];
         str[i]=str[len-i];
         str[len-i]=tmp;
     }
 }

 int cal_next(int p,int j){
     if(tag[p]) return -;
     for(int k=;k>=;k--){
         p=trie[p][(j>>k)&];
         if(tag[p]) return -;
     }
     return p;
 }

 void Calculation(){
     for(int i=;i<=tot;i++){
         for(int j=;j<=;j++){
             next[i][j]=cal_next(i,j);
         }
     }
 }

 LL dfs(int len,int j,bool limit,bool z){
     if(len==-) return 1LL;
     if(!limit&&dp[len][j]!=-) return dp[len][j];
     int up=limit?bit[len]:;
     LL ans=;
     if(z&&len>){
         ans+=dfs(len-,j,limit&&up==,true);
     }
     else{
         if(next[j][]!=-&&!tag[next[j][]])
         ans+=dfs(len-,next[j][],limit&&up==,false);
     }
     for(int i=;i<=up;i++){
         if(next[j][i]!=-&&!tag[next[j][i]]){
             ans+=dfs(len-,next[j][i],limit&&i==up,false);
         }
     }
     ans%=MOD;
     if(!limit) dp[len][j]=ans;
     return ans;
 }

 LL slove(){
     int len=strlen(str);
     len--;
     for(int i=len;i>=;i--)
     bit[i]=str[i]-'';
     return dfs(len,,true,true);
 }

 int main(){
     int T,n,len;
     scanf("%d",&T);
     while(T--){
         memset(tag,false,sizeof(tag));
         memset(dp,-,sizeof(dp));
         memset(fail,-,sizeof(fail));
         scanf("%d",&n);
         tot=;
         clr(root);
         for(int i=;i<n;i++){
             scanf("%s",str);
     //        cout<<str<<endl;
             insert();
         }
         build_ac();
         Calculation();
         scanf("%s",str);
     //    cout<<str<<endl;
         len=strlen(str);
         interval();
     //    cout<<str<<endl;
         for(int i=;i<len;i++){
             if(str[i]=='')
             str[i]='';
             else {
                 str[i]--;
                 break;
             }
         }
         if(str[len-]==''&&len!=) str[len-]='\0';
         LL ans1=slove();
         scanf("%s",str);
         interval();
 //        memset(dp,-1,sizeof(dp));
         LL ans2=slove();
         printf("%lld\n",((ans2-ans1)%MOD+MOD)%MOD);
     }
     return ;
 }