Match:Censored!(AC自动机+DP+高精度)(POJ 1625)

　　　　　　　　　　　　

　　　　　　　　　　　　　　　　  Censored!

　　题目大意：给定一些字符，将这些字符组成一个固定长度的字符串，但是字符串不能包含一些禁词，问你有多少种组合方式。

　　这是一道好题，既然出现了“一些”禁词，那么这题肯定和AC自动机有点关系了，对于这一题来说，因为我们需要的是求出在N^M种状态除去包含禁词的状态数，枚举肯定是不现实的了，我们唯一能做的只能是DP，但是怎么DP呢？只能是通过AC自动机来想了，由此我们来看一下trie树，我们知道trie树是可以表示不同字符串前后缀的转移关系的，但是这一题并不是要我们求出字串中是否有禁词，而是要我们求出除了禁词的其他组合方式，那么我们可不可以通过trie树直接看出来呢？答案是可以的，但是我们要改进一下。

　　如果我们把trie树中的Next数组补齐，比如在ACGT中含有禁词ACC，C，我们可以构建如下图的一个trie树

　　　　　　　　　　　　　　　　

　　

　　我们可以看到这棵trie树补齐了一般trie树不存在的边，其实就是把不存在的对应k子节点指向当前节点的fail节点的k节点，这样我们就可以找到所有元素转移的状态关系了，得到了这个东西，那么我们就可以用DP来把状态转移全部搞出来了，组成一个m长度的单词，只要我们不从失败状态（禁词的结尾）转出或者转入就OK了。

　　这样一开DP就很容易理解了，状态转移方程dp[i+1][转移状态]=dp[i][trie树上某个节点]+dp[i+1][转移状态]（转移状态是指的是其他节点转移过来的情况），那么怎么标定非法情况呢？我们不仅要把单词结尾标记为非法状态，如果当前位置fail指针的指向的k位置也为单词结尾，那么当前位置的指向的k位置也必须标记为非法状态，因为我们不能从这个节点转出（也就意味着这个单词是包含着另一个单词的）。

　　

#include <iostream>
#include <algorithm>
#include <functional>
#define MAX 130

using namespace std;

static int sum_node, Hash_Table[MAX];
static char str[200];

struct node
{
    int if_end,num;//注意end位置不仅是标记单词的结束，而且还表示了是否能状态转移
    node *fail, *Next[MAX];
}Mem_Pool[MAX], *Trie_Node[MAX], *Queue[MAX * 2];
struct BigInterget
{
    int A[25];
    enum { MOD = 10000 };
    BigInterget()//构析函数用于初始化大数，A[0]表示大数的长度
    {    
        memset(A, 0, sizeof(A)); 
        A[0] = 1; 
    }
    void set(int x)//用于设定一个32位的整数
    { 
        memset(A, 0, sizeof(A));
        A[0] = 1; A[1] = x; 
    }
    void print(void)
    {
        printf("%d", A[A[0]]);
        for (int i = A[0] - 1; i > 0; i--)
        {
            if (A[i] == 0){ printf("0000"); continue; }
            for (int k = 10; k*A[i] < MOD; k *= 10)
                printf("0");
            printf("%d", A[i]);
        }
        printf("\n");
    }
    int& operator [] (int pos) { return A[pos]; }
    const int& operator [] (int pos) const { return A[pos]; }

    BigInterget operator + (const BigInterget &B)
    {
        BigInterget C;
        C[0] = max(A[0], B[0]);
        for (int i = 1; i <= C[0]; i++)
            C[i] += A[i] + B[i], C[i + 1] += C[i] / MOD, C[i] %= MOD;
        if (C[C[0] + 1] > 0)C[0]++;//进位
        return C;
    }
};
static BigInterget dp[52][MAX];

struct node *create_new_node(void);
void put_letter_to_hash(const int);
void Insert(struct node *);
void build_ac_automation(struct node *);

int main(void)
{
    int Word_Length, Forbidden_Word_Sum, Letter_Type_Sum;
    while (~scanf("%d%d%d", &Letter_Type_Sum, &Word_Length, &Forbidden_Word_Sum))
    {
        sum_node = 0;
        memset(Hash_Table, 0, sizeof(Hash_Table));
        node *root = create_new_node();
        put_letter_to_hash(Letter_Type_Sum);

        for (int i = 0; i < Forbidden_Word_Sum; i++)
            Insert(root);
        build_ac_automation(root);
        
        for (int i = 0; i <= Word_Length; i++)
            for (int j = 0; j < sum_node; j++)
                dp[i][j] = BigInterget();
        dp[0][0].set(1);

        for (int i = 0; i < Word_Length; i++)
            for (int j = 0; j < sum_node; j++)
            {
                if (Mem_Pool[j].if_end)//不能从非法状态中转入
                    continue;
                for (int k = 0; k < Letter_Type_Sum; k++)
                {
                    if (Mem_Pool[j].Next[k]->if_end)//不能从非法状态中转出
                        continue;
                    int id = Mem_Pool[j].Next[k]->num;
                    dp[i + 1][id] = dp[i][j] + dp[i + 1][id];
                }
            }
        BigInterget ans = BigInterget();
        for (int i = 0; i < sum_node; i++)
            ans = ans + dp[Word_Length][i];
        ans.print();
    }
    return EXIT_SUCCESS;
}

struct node *create_new_node(void)
{
    node *tmp = &Mem_Pool[sum_node];
    tmp->fail = NULL;
    tmp->if_end = 0;
    tmp->num = sum_node++;
    memset(tmp->Next, NULL, sizeof(struct node*)*MAX);
    return tmp;
}

void put_letter_to_hash(const int Letter_Type_Sum)
{
    getchar();//去掉回车换行
    gets(str);

    for (int i = 0; i < Letter_Type_Sum; i++)
        Hash_Table[str[i]] = i;
}

void Insert(struct node *root)
{
    gets(str);
    struct node *tmp_ptr = root;

    for (int i = 0; str[i] != '\0'; i++)
    {
        int id = Hash_Table[str[i]];
        if (tmp_ptr->Next[id] == NULL)
            tmp_ptr->Next[id] = create_new_node();
        tmp_ptr = tmp_ptr->Next[id];
    }
    tmp_ptr->if_end = 1;
}

void build_ac_automation(struct node *root)
{
    int head = 0, tail = 0;
    node *out = NULL;
    root->fail = NULL;
    Queue[tail++] = root;
    
    while (head != tail)
    {
        out = Queue[head++];
        for (int i = 0; i < MAX; i++)
            if (out->Next[i] != NULL)
            {
                if (out == root)
                    out->Next[i]->fail = root;
                else
                {
                    out->Next[i]->fail = out->fail->Next[i];
                    //如果还找到在其他地方找到和他一样的元素，那么我们就把失败指针指向这个元素,同时要设定合法状态
                    out->Next[i]->if_end = out->fail->Next[i]->if_end ? 1 : out->Next[i]->if_end;
                }
                Queue[tail++] = out->Next[i];
            }
            else
            {
                if (out == root) out->Next[i] = root;
                else out->Next[i] = out->fail->Next[i];
            }
    }
}

　　另外这个题要用到大数加法，在网上找了个很好的模板，以后就用这个了

　　

　　参考：http://blog.csdn.net/AndyTeen/article/details/45668121

　　　　　http://blog.csdn.net/scut_pein/article/details/22204681

　　　　　http://www.cnblogs.com/laiba2004/p/4004417.html