201. Non Absorbing DFA

题意好难看懂的说。。。

　　有限状态自动机DFA是这么一个有序组<Σ, U, s, T, phi>；Σ代表输入字符集，表示此自动机的工作范围；U代表所有的状态集合；s是初始状态；T是最终状态；phi代表转移函数，定义为phi : U × Σ → U。

　　利用DFA进行字符串识别是要你做这么一件事情：The input of the automation is the string α over Σ. Initially the automation is in state s. Each step it reads the first character c of the input string and changes its state to phi(u, c) where u is the current state. After that the first character of the input string is removed and the step repeats. If when its input string is empty the automation is in the terminal state, it is said that it accepts the initial string α, in the other case it rejects it.

　　然后无聊的出题人给他加入了一个，b的东西：Nonabsorbing Edges，直译不吸收边。Define function χ : U × Σ → {0, 1}. When making a transition from some state u with some character c, the leading character is removed from the input string only if χ(u, c) = 0. If χ(u, c) = 1, the input string is kept intact and next transition is performed with the new state and the same character.

　　称这样的DFA为NADFA。

　　NADFA接受字符串的条件是：such automation accepts some string α if after a number of steps it transits to the terminal state and the input string becomes empty.

　　输入：第一行是字符集Σ。下来一行是k，表示状态数量。下一行第一个数字S代表初始状态，第二个数字L代表结束状态的数量，然后是L个数字，代表结束状态的编号。然后是一个k * |Σ|的矩阵，代表函数phi。然后再是一个同样大小的矩阵，代表函数X。最后是N。

　　题目就是要你求能被此，b形式下的DFA（NADFA）接受的长度为N的字符串数量。

---

竟然是ASC#2的A题！！！
然后发现SGU200~2**都是ASC的原题。。不忍直视了。。以我的智商看来SGU都刷不了了。。
不过SGU200题说到做到，决不放弃！BZOJ用来专门练一些算法。

怎么搞？？

DP是很显然的。用f[i][j]表示匹配到第i位时处在状态j的字符串数量。由于不可吸收边的存在，可以使用记忆化搜索预处理出状态的直接转移。

要用到高精度。。。压位大法好。。。

//{HEADS
#define FILE_IN_OUT
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <bitset>
#include <complex>
#include <string>
#define REP(i, j) for (int i = 1; i <= j; ++i)
#define REPI(i, j, k) for (int i = j; i <= k; ++i)
#define REPD(i, j) for (int i = j; 0 < i; --i)
#define STLR(i, con) for (int i = 0, sz = con.size(); i < sz; ++i)
#define STLRD(i, con) for (int i = con.size() - 1; 0 <= i; --i)
#define CLR(s) memset(s, 0, sizeof s)
#define SET(s, v) memset(s, v, sizeof s)
#define mp make_pair
#define pb push_back
#define PL(k, n) for (int i = 1; i <= n; ++i) { cout << k[i] << ' '; } cout << endl
#define PS(k) STLR(i, k) { cout << k[i] << ' '; } cout << endl
using namespace std;
void FILE_INIT(string FILE_NAME) {
#ifdef FILE_IN_OUT
#ifndef ONLINE_JUDGE 
    freopen((FILE_NAME + ".in").c_str(), "r", stdin);
    freopen((FILE_NAME + ".out").c_str(), "w", stdout);
#endif
#endif
}
typedef long long LL;
typedef double DB;
typedef pair<int, int> i_pair;
const int INF = 0x3f3f3f3f;
//}

const int maxn = 1000 + 10;
const int maxl = 100 + 10;
const int maxm = 60 + 5;
const int maxc = 27;
const int base = 1000000000;

char sigma[maxc];
int Snum, Size, S, k, L, n;
int teminal_state[maxn], phi[maxn][maxc], chi[maxn][maxc], trans[maxn][maxc];

struct big_int {
    int d[maxl];
    int len;
    big_int() {
        CLR(d);
        len = 1;
    }
    big_int &operator += (const big_int &a) {
        len = max(len, a.len);
        REP(i, len) {
            d[i] += a.d[i];
            if(base < d[i]) {
                d[i + 1] += d[i] / base;
                d[i] %= base;
            }
        }
        for(; 0 < d[1 + len]; ++len);
        return *this;
    }
    void print() {
        printf("%d", d[len]);
        for(int i = len - 1; 0 < i; --i) {
            printf("%09d", d[i]);
        }
        puts("");
    }
}f[maxn][maxm];

void dfs(int u, int c) {
    if(chi[u][c] == 0) {
        trans[u][c] = u;
    }
    if(trans[u][c]) {
        return;
    }
    trans[u][c] = -1;
    dfs(phi[u][c], c);
    trans[u][c] = trans[phi[u][c]][c];
}

int main() {
    FILE_INIT("201");

    scanf("%s", sigma);
    Size = strlen(sigma);
    scanf("%d", &k);
    scanf("%d %d", &S, &L);
    REP(i, L) {
        scanf("%d", &teminal_state[i]);
    }
    REP(i, k) {
        REP(j, Size) {
            scanf("%d", &phi[i][j]);
        }
    }
    REP(i, k) {
        REP(j, Size) {
            scanf("%d", &chi[i][j]);
        }
    }
    scanf("%d", &n);
    REP(i, k) {
        REP(j, Size) {
            if(!trans[i][j]) {
                dfs(i, j);
            }
        }
    }
    f[S][0].d[1] = 1;
    REPI(i, 0, n - 1) {
        REP(j, k) {
            REP(c, Size) {
                if(trans[j][c] > 0) {
                    f[phi[trans[j][c]][c]][i + 1] += f[j][i];
                }
            }
        }
    }
    big_int ans;
    REP(i, L) {
        ans += f[teminal_state[i]][n];
    }
    ans.print();

    return 0;
}