UVALive 6495 Probability Paradox AC自动机+高斯消元-优快云博客

题目大意：两个人又两个等长但不同的字符串，现在在一张纸上随机的写字母T和字母H，指导纸上写的字符串包含了某个人的串，如果包含了第一个人的串，那么第一个就获胜，如果是第二个人的串，则第二个人获胜。

好久没做AC自动机了，感觉都生疏了。这题其实不是很难的，关键是第一眼可能被分式吓到了。我们不妨用两人的串构造AC自动机，然后用dp[i]表示当前状态为AC自动机上的i，第一个人获胜的概率。

如样例1“TT HH”构造的AC自动机可以是下图，节点上的数字表示节点标号，我们就用这个标号表示AC自动机上的状态。

我们很容易得到dp方程

dp[0] = 0.5*dp[1] + 0.5*dp[3]
dp[1] = 0.5*dp[2] + 0.5*dp[3]
dp[2] = 1
dp[3] = 0.5*dp[1] + 0.5*dp[4]
dp[4] = 0

我们可以解得dp[0] = 0.5。

其实这个还有个需要注意的细节问题：是否有非标记节点（即根到这个点的路径，表示的是最开始的那两个串）能通过fail指针到达模式串？但是由于两串相同长度，不会有这种情况。

因为直接转移似乎很麻烦，我们采用gauss消元，而这个因为是分式，则计算的时候不是用double，而是用两个long long（结构体）表示一个分数。

//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<cctype>
#include<string>
#include<algorithm>
#include<iostream>
#include<ctime>
#include<map>
#include<set>
using namespace std;
#define MP(x,y) make_pair((x),(y))
#define PB(x) push_back(x)
typedef long long LL;
//typedef unsigned __int64 ULL;
/* ****************** */
const LL INF=1LL<<60;
const double INFF=1e100;
const double eps=1e-8;
const int mod=1000000007;
const int NN=100005;
const int MM=1000010;
/* ****************** */

char ss[15];
const int k_size=2;
const int LEN=12;
struct Tire_Tree
{
    int fail;
    int p;//0,1,-1
    int next[k_size];
    void init()
    {
        p=-1;
        fail=-1;
        memset(next,-1,sizeof(next));
    }
}tire[2*LEN];
int tire_cnt;
int tire_q[2*LEN];
int dui[2*LEN];

LL gcd(LL a,LL b)
{
    if(b==0)return a;
    return gcd(b,a%b);
}
struct Fraction
{
    LL a,b;

    Fraction(LL x=1,LL y=1):a(x),b(y){};
    Fraction(const Fraction &tt):a(tt.a),b(tt.b){};

    void init()
    {
        LL g=gcd(a,b);
        a/=g;
        b/=g;
        if(a==0)b=1;
    }

    double val()
    {
        return (a+0.0)/b;
    }

    bool operator<(const Fraction &tt)const
    {
        return a*tt.b < tt.a*b;
    }
    bool operator>(const Fraction &tt)const
    {
        return a*tt.b > tt.a*b;
    }
    bool operator==(const Fraction &tt)const
    {
        return a*tt.b == tt.a*b;
    }
    bool operator!=(const Fraction &tt)const
    {
        return (a*tt.b) != (tt.a*b);
    }
    bool operator<=(const Fraction &tt)const
    {
        return a*tt.b <= tt.a*b;
    }
    bool operator>=(const Fraction &tt)const
    {
        return a*tt.b >= tt.a*b;
    }

    Fraction operator+(const Fraction &tt)const
    {
        Fraction temp;
        temp.a = a*tt.b + tt.a*b;
        temp.b = b*tt.b;
        temp.init();
        return temp;
    }
    Fraction operator-(const Fraction &tt)const
    {
        Fraction temp;
        temp.a = a*tt.b - tt.a*b;
        temp.b = b*tt.b;
        temp.init();
        return temp;
    }
    Fraction operator*(const Fraction &tt)const
    {
        Fraction temp;
        temp.a = a*tt.a;
        temp.b = b*tt.b;
        temp.init();
        return temp;
    }
    //如果是除以0，这这个分式变为 ?/0
    Fraction operator/(const Fraction &tt)const
    {
        Fraction temp;
        temp.a = a*tt.b;
        temp.b = b*tt.a;
        temp.init();
        return temp;
    }
};

void tire_insert(char *str,int le,int root)
{
    int i,x,p=root;
    for(i=0;str[i];i++)
    {
        if(str[i]=='T')
            x=0;
        else
            x=1;
        if(tire[p].next[x]==-1)
        {
            tire_cnt++;
            tire[tire_cnt].init();
            tire[p].next[x]=tire_cnt;
        }
        p=tire[p].next[x];
    }
    tire[p].p=le;
}
void init_fail(int root)
{
    int head,tail,i,fa,p=root;

    head=1;
    tail=0;
    tire[root].fail=root;
    for(i=0;i<k_size;i++)
    {
        if(tire[p].next[i]!=-1)
        {
            tire_q[++tail]=tire[p].next[i];
            tire[ tire_q[tail] ].fail=root;
        }
        else
            tire[p].next[i]=root;
    }

    while(head<=tail)
    {
        p=tire_q[head++];
        fa=tire[p].fail;

        for(i=0;i<k_size;i++)
        {
            if(tire[p].next[i]!=-1)
            {
                tire_q[++tail]=tire[p].next[i];
                tire[ tire_q[tail] ].fail=tire[fa].next[i];
            }
            else
                tire[p].next[i]=tire[fa].next[i];
        }
    }
}


Fraction gss[2*LEN][2*LEN+1];
Fraction gss_ans[2*LEN];
//行列编号都从0开始，包含系数列，矩阵大小为n*m
//此函数保证只有1个解才能用
void gauss(int n,int m)
{
    int i,j,k,pca;
    Fraction temp,temp1;
    for(i=0;i<n;i++)
    {
        pca=i;
        for(j=i+1;j<n;j++)
        {
            if( fabs( gss[j][i].val() ) > fabs( gss[pca][i].val() ))
                pca=j;
        }
        if(pca!=i)
        {
            for(j=i;j<m;j++)
            {
                swap(gss[i][j],gss[pca][j]);
            }
        }
        //如果此位已经是0，则答案是无限个解或无解？应该是吧
        if( gss[i][i] != Fraction(0,1) )
        {
            for(j=i+1;j<n;j++)
            {
                temp = gss[j][i]/gss[i][i];
                gss[j][i] = Fraction(0,1);
                for(k=i+1;k<m;k++)
                {
                    temp1 = gss[i][k]*temp;
                    gss[j][k] = gss[j][k] - temp1;
                }
            }
        }
    }
    //因为是唯一解，所以这么写
    for(i=m-2;i>=0;i--)
    {
        gss_ans[i]=gss[i][m-1];
        for(j=i+1;j<m-1;j++)
        {
            temp = gss_ans[j]*gss[i][j];
            gss_ans[i] = gss_ans[i] - temp;
        }
        gss_ans[i] = gss_ans[i]/gss[i][i];
    }
}

int main()
{
    int i,j,tire_root;
    int n,m,tol;
    int y,z;
    while(1)
    {
        scanf("%s",ss);
        if(strcmp(ss,"$")==0)break;

        tire_root=tire_cnt=0;
        tire[0].init();
        tire_insert(ss,1,tire_root);
        scanf("%s",ss);
        tire_insert(ss,0,tire_root);
        init_fail(tire_root);

        n=tire_cnt+1;
        m=tire_cnt;
        tol=0;
        for(i=0;i<=tire_cnt;i++)
        {
            if(tire[i].p==-1)
            {
                dui[i]=tol++;
            }
        }
        for(i=0;i<n;i++)
            for(j=0;j<m;j++)
            {
                gss[i][j] = Fraction(0,1);
            }
        for(i=0;i<=tire_cnt;i++)
        {
            if(tire[i].p!=-1)continue;

            y=tire[i].next[0];
            z=tire[i].next[1];

            gss[i][ dui[i] ] = gss[i][ dui[i] ]+Fraction(1,1);

            if(tire[y].p==-1)
            {
                gss[i][ dui[y] ] = gss[i][ dui[y] ]+Fraction(-1,2);
            }
            else if(tire[y].p==1)
            {
                gss[i][m-1] = gss[i][m-1] + Fraction(1,2);
            }

            if(tire[z].p==-1)
            {
                gss[i][ dui[z] ] = gss[i][ dui[z] ]+Fraction(-1,2);
            }
            else if(tire[z].p==1)
            {
                gss[i][m-1] = gss[i][m-1] + Fraction(1,2);
            }
        }

        gauss(n,m);

        printf("%lld/%lld\n",gss_ans[dui[0]].a,gss_ans[dui[0]].b);
    }
    return 0;
}