Wireless Password - HDU 2825（ac自动机+状态压缩）

题目大意：有个人想破解他邻居的密码，他邻居告诉了一些关于这个密码的信息，并且给他一个单词集合，他用这些信息判断一下最少有多少种密码。

1->, 所有的密码都是有小写字母组成。

2->，密码的长度是 n （1<= n <=25）。

3->，密码至少包含 k 种字符集里面的单词。

 

比如，给集合｛"she", "he"｝，单词长度是3，最少包含两个单词的密码,很明显只能是“she”（题目表述的不清楚）。

 

分析：因为要统计记录到达每个点时候经过多少种不同的单词，所以需要用一种方法来保存这些信息，开一个数组来判重貌似是个很容易想到的办法，不过考虑时间复杂度的问题，建议还是不要这么干，因为字符集合的数量很少，只有10，所以我们可以使用状态压缩来保存这些信息，而且转移状态时候也很方便操作，不过有点需要注意，一定要把遍历子节点放在最内层循环，这样再遍历每一种状态的时候发先有0的情况可以continue一下，否则超时超的哇哇的.......

 

代码如下：

==========================================================================

#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
 
const int MAXN = ;
const int MaxSon = ;
const int Mod = ;
const int oo = 1e9+;
 
struct Ac_Trie
{
    int next[MAXN][MaxSon];
    int Fail[MAXN], End[MAXN];
    int cnt, root;
 
    int newnode()
    {
        for(int i=; i<MaxSon; i++)
            next[cnt][i] = -;
        Fail[cnt] = End[cnt] = false;
 
        return cnt++;
    }
    void InIt()
    {
        cnt = ;
        root = newnode();
    }
 
    void Insert(char s[], int t)
    {
        int now = root;
 
        for(int i=; s[i]; i++)
        {
            int k = s[i]-'a';
 
            if(next[now][k] == -)
                next[now][k] = newnode();
            now = next[now][k];
        }
 
        End[now] = <<t;
    }
    void GetFial()
    {
        queue<int>Q;
        int now = root;
 
        for(int i=; i<MaxSon; i++)
        {
            if(next[now][i] == -)
                next[now][i] = root;
            else
            {
                Fail[next[now][i]] = root;
                Q.push(next[now][i]);
            }
        }
 
        while(Q.size())
        {
            now = Q.front();
            Q.pop();
 
            for(int i=; i<MaxSon; i++)
            {
                if(next[now][i] == -)
                    next[now][i] = next[Fail[now]][i];
                else
                {
                    Fail[next[now][i]] = next[Fail[now]][i];
                    Q.push(next[now][i]);
                }
            }
 
            End[now] |= End[Fail[now]];
        }
    }
};
Ac_Trie ac;
 
int Find(int i)
{
    int k=;
 
    while(i)
    {
        if(i % )
            k++;
        i /= ;
    }
 
    return k;
}
 
int main()
{
    int N, M, K;
 
    int sum[] ={};
 
    for(int i=; i<; i++)
        sum[i] = Find(i);
 
    while(scanf("%d%d%d", &N, &M, &K), N+M+K)
    {
        char s[MAXN];
        ac.InIt();
 
        for(int i=; i<M; i++)
        {
            scanf("%s", s);
            ac.Insert(s, i);
        }
 
        ac.GetFial();
 
        int dp[][MAXN][] = {}, op=, Len = <<M;
        dp[][][] = ;
 
        while(N--)
        {
            memset(dp[op], , sizeof(dp[op]));
 
            for(int i=; i<ac.cnt; i++)
            for(int k=; k<Len; k++)
            {///把k放中间优化一下...否则超时
                if(dp[op^][i][k] == )
                    continue;
 
                for(int j=; j<MaxSon; j++)
                {
                    (dp[op][ac.next[i][j]][k|ac.End[i]] += dp[op^][i][k])%=Mod;
                }
            }
 
            op ^= ;
        }
 
        int ans = ;
 
        for(int i=; i<ac.cnt; i++)
        for(int j=; j<Len; j++)
        {
            if(sum[j] >= K || sum[ac.End[i]|j] >= K)
            {
                ans += dp[op^][i][j];
                ans %= Mod;
            }
        }
 
        printf("%d\n", ans);
    }
 
    return ;
}