杭州现场J题_Infinite monkey theorem

构造一个DFA，  对于样例：

2 100

a 0.312345

b 0.687655

abab

即：

    (b)

-----------

 |       /

 |      /

 |    /

//  /

           (a)      (b)         (a)         (b)                       

NULL----->a---->ab---->aba---->abab(ACC,成功状态)

/ /           //   /         /             /                                                  

 |            / (a) /         /     (a)   /                     

 |           -----------------/----------

 |                                   /

 |              (b)                  /

 --------------------------------       

（这幅图画的不错么？= =！）                         

然后就是DP了， 枚举敲击数i，敲了i个键处于的状态j,按键k,计算出在j这个状态按k会转移到的状态next_t

DP方程:dp[i+1][next_t]+=p[k]*dp[i][j];(dp[i][j]表示敲了i个键后处于j状态的概率)

写的时候脑残的自动机漏了一句话调了n久= =！

然后又用KMP的子串自匹配加状态映射又构造了个DFA，速度竟然比AC自动机慢，不过这题状态这么小怎么都不可能超时的，本来还想写一个暴力构自动机的，实在是没心情遂作罢，顺便还复习了下KMP，还A了道题= =！

PS：计算下标什么的最讨厌了= =！

AC自动机版:

/*
TRIE结构，在使用前必须调用初始化init()!!!
主要调用Ins,ser,返回值都是TRIE中的下标;del,返回有无字符串(删除成功否)
*/
#include<stdio.h>
#include<iostream>
#include<memory.h>
#include<queue>
using namespace std;
const int CTNUM = 26;  //储存字母的数目
const int STRNUM = 15000; //节点数目，绝对不能少于给定的字符串数目，一般给大点
const int MINCHAR='a';  //大小写分辨，如果混用或者不连续的话需要有对应的hash函数
struct TRIE
{
 int son[CTNUM];
 int count;
 int father;
}trie[STRNUM];
int fail[STRNUM];
int TNUM=1;
queue<int> q;
int n;
#define INT_MAX 10000000
int map[300][300];
void init()
{
 memset(&trie[0],0,sizeof(TRIE));
 memset(&trie[1],0,sizeof(TRIE));
 TNUM=2;
}
int Ins(char *str,int len)
{
 int i;
 int cur=1;
 for(i=0;i<len;i++)
 {
  if( !trie[cur].son[str[i]-MINCHAR] )
  {
   memset( &trie[TNUM],0,sizeof(TRIE) );
   trie[TNUM].father=cur;
   cur=trie[cur].son[str[i]-MINCHAR]=TNUM++;
  }
  else cur=trie[cur].son[str[i]-MINCHAR];
 }
 trie[cur].count++;
 return cur;
}
void calc_fail()
{
 int i,k,p;
 fail[0]=0;
 fail[1]=0;
 memset(fail,0,sizeof(fail));
 while(!q.empty()) q.pop();
 q.push(1);
 while(!q.empty())
 {
  i=q.front();
  q.pop();
  for(k='a'-MINCHAR;k<='z'-MINCHAR;k++)
  if (trie[i].son[k]!=0)
  {
                  int p=fail[i];
      while(p!=0&&trie[p].son[k]==0)
       p=fail[p];
      if (!p) fail[trie[i].son[k]]=1;
      else
      fail[trie[i].son[k]]=trie[p].son[k];
   q.push(trie[i].son[k]);
  }
 }
}
double p[300],dp[1005][50],ans;
char s[300];
int main()
{
 int n,m,i,j,x,k,next_t,t;
 while(scanf("%d %d",&n,&m)!=EOF)
 {
  if (n==0&&m==0) break;
  memset(p,0,sizeof(p));
      for(i=1;i<=n;i++)
   {
    scanf("%s",s);
       scanf("%lf",&p[s[0]-MINCHAR]);
   }
      scanf("%s",s);
   init();
   Ins(s,strlen(s));
   calc_fail();  
   ans=0;
   memset(dp,0,sizeof(dp));
   dp[0][1]=1;
   for(i=0;i<=m-1;i++)
  for(j=0;j<=TNUM-2;j++)
    for(k='a'-MINCHAR;k<='z'-MINCHAR;k++)
     {
       t=j;
     while(t!=0&&trie[t].son[k]==0)
      t=fail[t];
     if (t==0) next_t=1;
     else
     next_t=trie[t].son[k];
      dp[i+1][next_t]+=p[k]*dp[i][j];
     }
  for(i=1;i<=m;i++)
   ans+=dp[i][TNUM-1];
  printf("%.2lf%%/n",ans*100);
 }

}

KMP版：

#include<stdio.h>
#include<iostream>
#include<memory.h>
#include<queue>
using namespace std;
const int MINCHAR='a';        //大小写分辨，如果混用或者不连续的话需要有对应的hash函数
int n;
int map[300][300];
int next[100];
void get_next(char *s)
{
    int i,j,l;
 memset(next,0,sizeof(next));
    l=strlen(s);
    i=-1;next[0]=-1;j=-1;
    for(i=1;i<=l-1;i++)
 {
  while(s[j+1]!=s[i]&&j!=-1) j=next[j];
  if (s[j+1]==s[i]) j++;
  next[i]=j;
 }
}
double p[300],dp[1005][50],ans;
char s[300];
void calc_map()
{
    int i,j,l,t,next_t;
    memset(map,0,sizeof(map));
    l=strlen(s);
    for(i=0;i<=l-1;i++)
     for(j='a';j<='z';j++)
    {
     t=i-1;
              while(s[t+1]!=j&&t!=-1) t=next[t];
     if (s[t+1]==j) t++;
     map[i][j-MINCHAR]=t+1;
    }
}
void calc_dp(int m)
{
    int i,j,k,l;
    memset(dp,0,sizeof(dp));
    dp[0][0]=1;
    l=strlen(s);
    for(i=0;i<=m-1;i++)
        for(j=0;j<=l-1;j++)
           for(k='a'-MINCHAR;k<='z'-MINCHAR;k++)
               dp[i+1][map[j][k]]+=p[k]*dp[i][j];
}
int main()
{
    int n,m,i,j,x,k;
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        if (n==0&&m==0) break;
        memset(p,0,sizeof(p));
      for(i=1;i<=n;i++)
      {
          scanf("%s",s);
          scanf("%lf",&p[s[0]-MINCHAR]);
      }
      scanf("%s",s);
      get_next(s);
      calc_map();
      memset(dp,0,sizeof(dp));
      dp[0][1]=1;
      ans=0;
     calc_dp(m);
     for(i=1;i<=m;i++)
         ans+=dp[i][strlen(s)];
     printf("%.2lf%%/n",ans*100);
    }

}