SGU 201 Non Absorbing DFA

解题思路：

这题用记忆化搜索就可以过，只是题意比较难理解。学过编译原理的一定知道DFA（确定性有穷自动机）是什么，没学过简单说一下，给定开始状态和结束状态，以及状态转移函数phi,以及是否去掉首字母的标记，跟其他自动机一样，字符串被接受即从开始状态开始，根据首字母来进行状态转移，如果字符串为空的时候刚好在结束状态则该句子可接受。

那么根据自动机的性质，从开始状态记忆化搜索就可以，要注意的是答案可能有26^60种，因此要用大数，还有转移的时候可能出现环，需要处理一下。

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<map>
#include<string>
#include<queue>
#include<vector>
#include<list>
//#pragma comment(linker,"/STACK:1024000000,1024000000")
using namespace std;
#define INF 0x3f3f3f3f
struct BigInt
{
    const static int mod = 10000;
    int a[60],len;
    BigInt()
    {
        memset(a,0,sizeof(a));
        len = 1;
    }
    BigInt(int v)
    {
        memset(a,0,sizeof(a));
        len = 0;
        do
        {
            a[len++] = v%mod;
            v /= mod;
        }
        while(v);
    }
    BigInt operator +(const BigInt &b)const
    {
        BigInt res;
        res.len = max(len,b.len);
        for(int i = 0; i <= res.len; i++)
            res.a[i] = 0;
        for(int i = 0; i < res.len; i++)
        {
            res.a[i] += ((i < len)?a[i]:0)+((i < b.len)?b.a[i]:0);
            res.a[i+1] += res.a[i]/mod;
            res.a[i] %= mod;
        }
        if(res.a[res.len] > 0)res.len++;
        return res;
    }
    BigInt operator *(const BigInt &b)const
    {
        BigInt res;
        for(int i = 0; i < len; i++)
        {
            int up = 0;
            for(int j = 0; j < b.len; j++)
            {
                int temp = a[i]*b.a[j] + res.a[i+j] + up;
                res.a[i+j] = temp%mod;
                up = temp/mod;
            }
            if(up != 0)
                res.a[i + b.len] = up;
        }
        res.len = len + b.len;
        while(res.a[res.len - 1] == 0 &&res.len > 1)res.len--;
        return res;
    }
    void output()
    {
        printf("%d",a[len-1]);
        for(int i = len-2; i >=0 ; i--)
            printf("%04d",a[i]);
        printf("\n");
    }
};
BigInt dp[1005][65];
int vis[1005][65];
char str[50];
int k,len;
int s,is[1005];
int phi[1005][30];
int fx[1005][30];
int n;
int nex[1005][65];
int flag[1005][65];
int find(int x,int y)
{
    if(flag[x][y]) return 0;
    if(!fx[x][y]) return phi[x][y];
    if(nex[x][y]!=-1) return nex[x][y];
    flag[x][y]=1;
    nex[x][y]=find(phi[x][y],y);
    flag[x][y]=0;
    return nex[x][y];
}
BigInt dfs(int x,int y)
{
    if(y==0)
    {
        if(is[x]) return dp[x][y]=BigInt(1);
        else return dp[x][y]=BigInt(0);
    }
    if(dp[x][y].len!=-1) return dp[x][y];
    BigInt res=BigInt(0);
        for(int i=1;i<=len;i++)
        {
            int to=find(x,i);
            if(to==0) continue;
            if(!vis[to][y-1]&&to) {vis[to][y-1]=1;res=res+dfs(to,y-1);vis[to][y-1]=0;}
        }

    return dp[x][y]=res;
}
int main()
{
    while(cin>>str)
    {
        len=strlen(str);
        memset(vis,0,sizeof vis);
        memset(is,0,sizeof is);
        memset(nex,-1,sizeof nex);
        memset(flag,0,sizeof flag);
        for(int i=0;i<1005;i++)
            for(int j=0;j<65;j++)
            dp[i][j].len=-1;
        int m;int x;
        scanf("%d%d%d",&k,&s,&m);
        for(int i=1;i<=m;i++) {scanf("%d",&x);is[x]=1;}
        for(int i=1;i<=k;i++)
            for(int j=1;j<=len;j++)
            scanf("%d",&phi[i][j]);
        for(int i=1;i<=k;i++)
            for(int j=1;j<=len;j++)
            scanf("%d",&fx[i][j]);
        scanf("%d",&n);
        vis[s][n]=1;
        BigInt res=dfs(s,n);
        res.output();
    }
    return 0;
}