hdu 3689 Infinite monkey theorem

Infinite monkey theorem

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
http://acm.hdu.edu.cn/showproblem.php?pid=3689

Problem 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.

 

Sample Input

4 10

w 0.25

o 0.25

r 0.25

d 0.25

word

2 10

a 1.0

b 0.0

abc

2 100

a 0.312345

b 0.687655

abab

0 0

 

Sample Output

2.73%

0.00%

98.54%

 

字符串均从0开始

dp[i][j]表示生成到第i个字符，匹配到第j个字符的概率

到 表示准备匹配，还没有匹配

对字符串做kmp

nxt 表示生成第i个字符为k后，由原匹配位置j转移到新的匹配位置nxt

dp[i+1][nxt]+=dp[i][j]*p[k]

 

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
double p[];
char ch[],s[];
int f[];
double dp[][];
int main()
{
    int n,m,len,j;
    while(scanf("%d%d\n",&n,&m)!=EOF)
    {
        if(!n) return ;
        for(int i=;i<=n;i++)
         scanf("%c %lf\n",&ch[i],&p[i]);
        scanf("%s",s);
        len=strlen(s);
        for(int i=;i<len;i++)
        {
            j=f[i];
            while(j&&s[j]!=s[i]) j=f[j];
            f[i+]= s[j]==s[i] ? j+ : ;

        }
        int nxt;
        memset(dp,,sizeof(dp));
        dp[][]=;
        for(int i=;i<m;i++)
         for(int j=;j<len;j++)
          for(int k=;k<=n;k++)
          {
              nxt=j;
              while(nxt&&s[nxt]!=ch[k]) nxt=f[nxt];
              if(s[nxt]==ch[k]) nxt++;
              dp[i+][nxt]+=dp[i][j]*p[k];
          }
        double ans=;
        for(int i=;i<=m;i++) ans+=dp[i][len];
        printf("%.2lf%%\n",ans*);
    }
}