[BZOJ2553] [BeiJing2011]禁忌-AC自动机-概率

[BZOJ2553] [BeiJing2011]禁忌

Description

Magic Land上的人们总是提起那个传说：他们的祖先John在那个东方岛屿帮助Koishi与其姐姐Satori最终战平。而后，Koishi恢复了读心的能力……

如今，在John已经成为传说的时代，再次造访那座岛屿的人们却发现Koishi遇到了新麻烦。
这次她遇到了Flandre Scarlet——她拥有可以使用禁忌魔法而不会受到伤害的能力。
为了说明什么是禁忌魔法及其伤害，引入以下概念：

1．字母集A上的每个非空字符串对应了一个魔法。
其中A是包含了前alphabet个小写字母的集合。

2．有一个集合T，包含了N个字母集A上的字符串T中的每一串称为一个禁忌串（Taboo string）

3．一个魔法，或等价地，其对应的串s因为包含禁忌而对使用者造成的伤害按以下方式确定：

 把s分割成若干段，考虑其中是禁忌串的段的数目，不同的分割可能会有不同的数目，其最大值就是这个伤害。

由于拥有了读心的能力，Koishi总是随机地使用Flandre Scarlet的魔法，可以确定的是，她的魔法正好对应字母集A上所有长度为len的串。

但是，Flandre Scarlet所使用的一些魔法是带有禁忌的，由于其自身特性，她可以使用禁忌魔法而不受到伤害，而Koishi就不同了。可怜的Koishi每一次使用对方的魔法都面临着受到禁忌伤害的威胁。

你现在需要计算的是如果Koishi使用对方的每一个魔法的概率是均等的，那么每一次随机使用魔法所受到的禁忌伤害的期望值是多少。

Input

第一行包含三个正整数N、len、alphabet。
接下来N行，每行包含一个串Ti，表示禁忌串。

Output

一个非负实数，表示所受到禁忌伤害的期望值。

Sample Input

2 4 2
aa
abb

Sample Output

0.75

【样例1解释】

一共有2^4 = 16种不同的魔法。

需要注意的是“aabb”的禁忌伤害是1而不是2。

HINT

100%的数据中N ≤ 5，len ≤109，1 ≤ alphabet ≤ 26。

在所有数据中，有不少于40%的数据中：N = 1。

数据保证每个串Ti的长度不超过15，并且不是空串。

数据保证每个Ti均仅含有前alphabet个小写字母。

数据保证集合T中没有相同的元素，即对任意不同的i和j，有Ti≠Tj。

【评分方法】

对于每一组数据，如果没有得到正确的输出（TLE、MLE、RTE、输出格式错误等）得0分。

否则：设你的输出是YourAns，标准输出是StdAns：

记MaxEPS = max(1.0 , StdAns)×10-6

如果|YourAns – StdAns| ≤ MaxEPS则得10分，否则得0分。

即：你的答案需要保证相对误差或绝对误差不超过10-6。

---

发福利啦发福利啦~~o((≧▽≦o)
这是我们题面中的两位主人公芙兰和恋恋~

---

福利发完了，回到正题：

字符串匹配自然是用AC自动机了~
题意大致是说，求长度为len的所有串的最大伤害的期望值。
期望值显然用DP做啊~
所以考虑用f[i][j]表示从自动机上i节点走向j节点的概率。
那么答案就是所有禁忌串被走到的概率~

实现细节：
bfs处理DP。
用一个新节点v(不存在于自动机上)来表示禁忌串的结尾，如果在自动机上走到一个禁忌串结尾，则同时在根节点和v上加上对应概率，代表回到根节点和统计答案。
最后自乘len次，用矩阵快速幂优化即可~

/**************************************************************
    Problem: 2553
    User:
    Language: C++
    Result: Accepted
    Time:56 ms
    Memory:1932 kb
****************************************************************/

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>

using namespace std;

const int N=100;

inline int read()
{
    int x=0;
    char ch=getchar();
    while(ch<'0' || '9'<ch)ch=getchar();
    while('0'<=ch && ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    return x;
}

int n,alpha,len;
bool vis[N];

struct Matrix
{
    long double a[N][N];

    inline void init()
    {
        for(int i=0;i<N;i++)
            for(int j=0;j<N;j++)
                a[i][j]=0.0;
    }

    friend Matrix operator *(Matrix koishi,Matrix satori)
    {
        Matrix tmp;
        tmp.init();
        for(int i=0;i<=n;i++)
            for(int j=0;j<=n;j++)
                for(int k=0;k<=n;k++)
                    tmp.a[i][j]+=koishi.a[i][k]*satori.a[k][j];
        return tmp;
    }
}f,ans;

struct AC_Automaton
{
    int next[N][26],fail[N];
    int pool,l,r,q[N];
    bool end[N];

    AC_Automaton()
    {
        pool=0;
        memset(next,0,sizeof(next));
    }

    void add(char *s)
    {
        int len=strlen(s);
        int now=0;
        for(int i=0;i<len;i++)
        {
            if(!next[now][s[i]-'a'])
                next[now][s[i]-'a']=++pool;
            now=next[now][s[i]-'a'];
        }
        end[now]=1;
    }

    void getfail()
    {
        q[r=1]=0;l=0;
        fail[0]=-1;

        while(l!=r)
        {
            int u=q[++l];
            for(int i=0;i<alpha;i++)
            {
                if(next[u][i])
                {
                    q[++r]=next[u][i];
                    fail[next[u][i]]= u==0?0:next[fail[u]][i];
                }
                else
                    next[u][i]= u==0?0:next[fail[u]][i];
            }
            end[u]|=end[fail[u]];
        }
    }

    void build()
    {
        q[r=1]=0;l=0;
        vis[0]=1;
        long double base=1.0/(double)alpha;

        int u;
        while(l!=r)
        {
            u=q[++l];
            for(int i=0;i<alpha;i++)
            {
                if(!vis[next[u][i]])
                {
                    vis[next[u][i]]=1;
                    q[++r]=next[u][i];
                }

                if(end[next[u][i]])
                {
                    f.a[u][n]+=base;
                    f.a[u][0]+=base;
                }
                else
                    f.a[u][next[u][i]]+=base;
            }
        }
    }
}koishi;

int main()
{
    n=read();len=read();
    alpha=read();

    char s[N];
    for(int i=1;i<=n;i++)
    {
        scanf("%s",s);
        koishi.add(s);
    }

    n=koishi.pool+1;
    koishi.getfail();
    koishi.build();

    for(int i=0;i<=n;i++)ans.a[i][i]=1;
    f.a[n][n]=1;

    while(len)
    {
        if(len&1)
            ans=f*ans;
        f=f*f;
        len>>=1;
    }

    printf("%.7f\n",(double)ans.a[0][n]);

    return 0;
}