HDU 3689 Infinite monkey theorem（DP+trie+自动机）（2010 Asia Hangzhou Regional Contest）

Description

Could you imaging a monkey writing computer programs? Surely monkeys are smart among animals. But their limited intelligence is no match for our human beings. However, there is a theorem about monkeys, and it states that monkeys can write everything if given enough time. The theorem is called “Infinite monkey theorem”. It states that a monkey hitting keys at random on a typewriter keyboard for an infinite amount of time will almost surely type any given text, which of course includes the programs you are about to write (All computer programs can be represented as text, right?). It’s very easy to prove this theorem. A little calculation will show you that if the monkey types for an infinite length of time the probability that the output contains a given text will approach 100%. However, the time used is too long to be physically reasonable. The monkey will not be able to produce any useful programs even if it types until the death of the universe. To verify this and ensure that our human beings are not replaceable by monkeys, you are to calculate the probability that a monkey will get things right.

 

Input

There will be several test cases. Each test case begins with a line containing two integers n and m separated by a whitespace (2<=n<=26, 1<=m<=1000). n is the number of keys on the typewriter and the monkey will hit these keys m times. Thus the typewriter will finally produce an output of m characters. The following n lines describe keys on the typewriter. Each line has a lower case letter and a real number separated by a whitespace. The letter indicates what the typewriter will produce if the monkey hits that key and the real number indicates the probability that the monkey will hit this key. Two hits of the monkey are independent of each other (Two different hits have the same probability for a same key), and sum of all the probabilities for each key is ensured to be 1. The last line of the test case contains a word composed of lower case letters. The length of the word will be less than or equal to 10. The input will end with a line of two zeros separated by a whitespace. This line should not be processed.

 

Output

For each test case, output one line containing the probability that the given word will appear in the typewriter’s output. The output should be in percentage format and numbers should be rounded to two digits after the decimal point.

题目大意：有n个字母，每个字母有一个敲击概率，敲m次，问敲m次之后的串包含给出子串的概率是多少。

思路：对子串建立一个trie树，建一个自动机（像我这种懒得想的人会先建出一个AC自动机），得出每个点走一步到达的位置。然后DP，dp[m][x]为第m步走到第x个点的概率，最后把dp[m][x]加起来，再拿1-sum就是答案了。

PS：其实我觉得直接KMP也可以……反正给出的串很短……

代码（0MS）：

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <queue>
 using namespace std;

 struct Node {
     Node *go[], *fail;
     int id;
     Node(int i = ) {
         id = i;
         memset(go, , sizeof(go));
         fail = ;
     }
 };

 void build(Node *root, char *str) {
     Node *p = root;
     for(int i = ; str[i]; ++i) {
         int index = str[i] - 'a';
         if(!p->go[index]) p->go[index] = new Node(i + );
         p = p->go[index];
     }
 }

 void makeFail(Node *root) {
     queue<Node*> que; que.push(root);
     while(!que.empty()) {
         Node *tmp = que.front(); que.pop();
         for(int i = ; i < ; ++i) {
             if(!tmp->go[i]) continue;
             if(tmp == root) tmp->go[i]->fail = root;
             else {
                 Node *p = tmp->fail;
                 while(p) {
                     if(p->go[i]) {
                         tmp->go[i]->fail = p->go[i];
                         break;
                     }
                     p = p->fail;
                 }
                 if(!p) tmp->go[i]->fail = root;
             }
             que.push(tmp->go[i]);
         }
     }
     root->fail = root;
 }

 void makeGo(Node *root, char *str) {
     Node *tmp = root;
     for(int i = ; i < ; ++i)
         if(i != str[] - 'a') root->go[i] = root;
     for(int i = ; str[i]; ++i) {
         int index = str[i] - 'a';
         tmp = tmp->go[index];
         for(int j = ; j < ; ++j) {
             Node *p = tmp;
             while(true) {
                 if(p->go[j]) {
                     tmp->go[j] = p->go[j];
                     break;
                 }
                 p = p->fail;
                 if(p == root) break;
             }
             if(p == root) tmp->go[j] = root->go[j];
         }
     }
 }

 int n, m;
 char s[];
 double dp[][];
 double pro[];

 double solve(Node *root) {
     int cur = , len = strlen(s);
     dp[cur][] = ;
     for(int i = ; i <= len; ++i) dp[cur][i] = ;
     for(int t = ; t < m; ++t) {
         for(int i = ; i <= len; ++i) dp[cur ^ ][i] = ;
         for(int i = ; i < ; ++i)
             dp[cur ^ ][root->go[i]->id] += pro[i] * dp[cur][];
         Node *tmp = root;
         for(int i = ; i < len - ; ++i) {
             int index = s[i] - 'a';
             tmp = tmp->go[index];
             for(int j = ; j < ; ++j)
                 dp[cur ^ ][tmp->go[j]->id] += pro[j] * dp[cur][i + ];
         }
         cur ^= ;
         //for(int i = 0; i <= len; ++i) printf("%.6f ", dp[cur][i]); printf("\n");
     }
     double ret = ;
     for(int i = ; i < len; ++i) {
         ret += dp[cur][i];
     }
     return  - ret;
 }

 int main() {
     while(scanf("%d%d", &n, &m) != EOF) {
         if(n ==  && m == ) break;
         char c; double x;
         for(int i = ; i < ; ++i) pro[i] = ;
         for(int i = ; i < n; ++i)
             scanf(" %c%lf", &c, &x), pro[c - 'a'] = x;
         scanf("%s", s);
         Node *root = new Node;
         build(root, s);
         makeFail(root);
         makeGo(root, s);
         printf("%.2f%%\n", solve(root) * );
     }
 }