bzoj2553 禁忌

题意：给定n个禁忌串。由字母表中的前alp的字母组成长度为len的字符串中，定义某个字符串的伤害为存在的一种分割方法使得其中禁忌串的数量的最大值（同一个禁忌串出现两次就算两次）。问期望伤害？

n<=5,禁忌串长度<=15.len<=1e9.

标程：

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
typedef long double ld;
const int N=80;
int n,len,alp,ed,tag[N],son[N][26],sc,fail[N];
ld p; queue<int> q; char s[N];
struct node{ld g[N][N];}A;
node operator * (node A,node B)
{
    node c;
    for (int i=0;i<=ed;i++)//注意端点是从0到ed!
      for (int j=0;j<=ed;j++)
      {
          c.g[i][j]=0;  
        for (int k=0;k<=ed;k++)
          c.g[i][j]+=A.g[i][k]*B.g[k][j];
      }
    return c;
}
node ksm(node x,int y)
{
   node res=x;y--;//技巧，避免繁冗的初始化 
   while (y){if (y&1) res=res*x; x=x*x; y>>=1;}
   return res;
}
void ins(char *s)
{
    int now=0,sl=strlen(s);
    for (int i=0,c;i<sl;now=son[now][c],i++)
       if (!son[now][c=s[i]-'a']) son[now][c]=++sc;
    tag[now]=1;
}
void build()
{
    for (int i=0;i<alp;i++) if (son[0][i]) fail[son[0][i]]=0,q.push(son[0][i]);
    while (!q.empty())
    {
        int now=q.front();q.pop();
        for (int i=0,y;i<alp;i++)
          if (y=son[now][i]) q.push(y),
            fail[y]=son[fail[now]][i],tag[y]|=tag[fail[y]];
          else son[now][i]=son[fail[now]][i];
    }
}
int main()
{
    scanf("%d%d%d",&n,&len,&alp);
    for (int i=1;i<=n;i++) scanf("%s",s),ins(s);
    build();ed=sc+1;p=1.0/alp;
    for (int i=0;i<=sc;i++)
      for (int j=0;j<alp;j++)
        if (tag[son[i][j]]) A.g[i][0]+=p,A.g[i][ed]+=p;else A.g[i][son[i][j]]+=p;
    A.g[ed][ed]=1;
    printf("%.10lf
",(double)ksm(A,len).g[0][ed]);
    return 0;
}

易错点：1.注意AC自动机的节点数为sc，而不是n。矩阵转移的循环范围要注意。

2.技巧：矩阵快速幂的时候可以先把res设为x，进行y-1次的幂操作，避免单位矩阵初始化。

3.被卡精度。使用long double，输出时需要转double输出。

题解：AC自动机+矩阵快速幂优化dp

沿用梁大大的思路：15*5的串规模肯定是AC自动机。步长1e9就别想着枚举了，矩阵快速幂优化dp。

这道题是分割方案，贪心来看，就是每次匹配到一个串，就返回起点重新来。这样就避免了串统计重叠。

将所有禁忌串扔进AC自动机，并在禁忌节点打上标记（别往状压方向去想）。

处理出A矩阵,A[i][j]表示从AC自动机上的i节点到j节点可以一步走到，权值设置成1/alp。如果下一个转移到禁忌串了，就跳到根，否则就往儿子走。为了方便统计答案，我们另设一个用来统计的终止节点T。跳到根的时候同时也跳往T。注意T到T的概率（权值）设为1。就是待在原地不再转移。A^len的[0][T]即是答案。

看上去特别喵~对于一个串，它的伤害最大为k的分割方案中，每一个串都会在T终止一次，所以会被统计入k条权值为(1/alp)^len的路径，恰是这个串的伤害期望。