uva 11468 Substring

题意：给你 k 个模板串，然后给你一些字符的出现概率，然后给你一个长度 l ，问你这些字符组成的长度为 l 的字符串不包含任何一个模板串的概率。

思路：AC自动机+概论DP

首先用K个模板构造好AC自动机。题目上说长L的新串的子串不包含任何一个K串，其实就是说在构造好的树中，从根往下走L步都不包含K个模板。此题用match标记是否为K模板串。

状态转移方程代码中注释了。

 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<cstdio>
 #include<map>
 #include<string>
 using namespace std;
 
 const int SIGMA_SIZE = ;
 const int MAXNODE = ; // 结点总数
 const int MAXS =  + ; // 模板个数
 
 int idx[], n;
 double prob[SIGMA_SIZE];
 
 struct AhoCorasickAutomata
 {
     int ch[MAXNODE][SIGMA_SIZE];
     int f[MAXNODE];    // fail函数
     int match[MAXNODE];  // 是否包含某一个字符串
     int sz;            // 结点总数
 
     void init()
     {
         sz = ;
         memset(ch[], , sizeof(ch[]));
     }
 
     // 插入字符串
     void insert(char *s)
     {
         int u = , n = strlen(s);
         for(int i = ; i < n; i++)
         {
             int c = idx[s[i]];
             if(!ch[u][c])
             {
                 memset(ch[sz], , sizeof(ch[sz]));
                 match[sz] = ;
                 ch[u][c] = sz++;
             }
             u = ch[u][c];
         }
         match[u] = ;
     }
 
     // 计算fail函数
     void getFail()
     {
         queue<int> q;
         f[] = ;
         // 初始化队列
         for(int c = ; c < SIGMA_SIZE; c++)
         {
             int u = ch[][c];
             if(u)
             {
                 f[u] = ;
                 q.push(u);
             }
         }
         // 按BFS顺序计算fail
         while(!q.empty())
         {
             int r = q.front();
             q.pop();
             for(int c = ; c < SIGMA_SIZE; c++)
             {
                 int u = ch[r][c];
                 if(!u)
                 {
                     ch[r][c] = ch[f[r]][c];
                     continue;
                 }
                 q.push(u);
                 int v = f[r];
                 while(v && !ch[v][c]) v = f[v];
                 f[u] = ch[v][c];
                 match[u] |= match[f[u]];
             }
         }
     }
 };
 
 AhoCorasickAutomata ac;
 
 double d[MAXNODE][];
 int vis[MAXNODE][];
 
 double getProb(int u, int L)//d[u][L]=prob[u]*d[v][L-1]状态转方程 v为u的儿子可以走节点
 {
     if(!L) return 1.0;
     if(vis[u][L])
         return d[u][L];
     vis[u][L] = ;
     d[u][L]=0.0;
     for(int i = ; i < n; i++)
         if(!ac.match[ac.ch[u][i]])
             d[u][L] += prob[i] * getProb(ac.ch[u][i], L-);
     return d[u][L];
 }
 
 char s[][];
 
 int main()
 {
     int T;
     scanf("%d", &T);
     for(int kase = ; kase <= T; kase++)
     {
         int k, L;
         scanf("%d", &k);
         for(int i = ; i < k; i++) scanf("%s", s[i]);
         scanf("%d", &n);
         for(int i = ; i < n; i++)
         {
             char ch[];
             scanf("%s%lf", ch, &prob[i]);
             idx[ch[]] = i;
         }
         ac.init();
         for(int i = ; i < k; i++) ac.insert(s[i]);
         ac.getFail();
         scanf("%d", &L);
         memset(vis, , sizeof(vis));
         memset(d,,sizeof(d));
         printf("Case #%d: %.6lf\n", kase, getProb(, L));
     }
     return ;
 }