poj3341

AC自动机，用40^4 * 50 * 10的空间进行dp。

最大的难点在于hash。

hash一个数列f，数列中的每一位都有一个上限g，即f[i]<=g[i]。

那么可以将该数列hash为这样一个整数，这个整数的每一个位的进制都不同，第i位的进制是g[i] + 1，即第i位满g[i]+1则可进位。（当然由于g[i]是该位的上限，所以永远不可能进位）

用p[i]表示(g[0]+1)*(g[1]+1)*...*(g[i - 1]+1)。那么最终f被hash的结果是p[0]*f[0]+p[1]*f[1]+...。

#include <cstdio>
#include <algorithm>
#include <queue>
#include <map>
#include <cstring>
using namespace std;

#define D(x) 

const int MAX_LEN = 50;
const int MAX_N = 55;
const int MAX_NODE_NUM = 12 * MAX_N;
const int MAX_CHILD_NUM = 4;

//1.init() 2.insert() 3.build() 4.query()
struct Trie
{
    int next[MAX_NODE_NUM][MAX_CHILD_NUM];
    int fail[MAX_NODE_NUM];
    int count[MAX_NODE_NUM];
    int node_cnt;
    bool vis[MAX_NODE_NUM]; //set it to false
    int root;

    void init()
    {
        node_cnt = 0;
        root = newnode();
        memset(vis, 0, sizeof(vis));
    }

    int newnode()
    {
        for (int i = 0; i < MAX_CHILD_NUM; i++)
            next[node_cnt][i] = -1;
        count[node_cnt++] = 0;
        return node_cnt - 1;
    }

    int get_id(char a)
    {
        if (a == ‘A‘)
            return 0;
        if (a == ‘C‘)
            return 1;
        if (a == ‘T‘)
            return 2;
        return 3;
    }

    void insert(char buf[])
    {
        int now = root;
        for (int i = 0; buf[i]; i++)
        {
            int id = get_id(buf[i]);
            if (next[now][id] == -1)
                next[now][id] = newnode();
            now = next[now][id];
        }
        count[now]++;
    }

    void build()
    {
        queue<int>Q;
        fail[root] = root;
        for (int i = 0; i < MAX_CHILD_NUM; i++)
            if (next[root][i] == -1)
                next[root][i] = root;
            else
            {
                fail[next[root][i]] = root;
                Q.push(next[root][i]);
            }
        while (!Q.empty())
        {
            int now = Q.front();
            Q.pop();
            for (int i = 0; i < MAX_CHILD_NUM; i++)
                if (next[now][i] == -1)
                    next[now][i] = next[fail[now]][i];
                else
                {
                    fail[next[now][i]]=next[fail[now]][i];
                    count[next[now][i]] += count[fail[next[now][i]]];
                    Q.push(next[now][i]);
                }
        }
    }

    int query(char buf[])
    {
        int now = root;
        int res = 0;

        memset(vis, 0, sizeof(vis));
        for (int i = 0; buf[i]; i++)
        {
            now = next[now][get_id(buf[i])];
            int temp = now;
            while (temp != root && !vis[temp])
            {
                res += count[temp];
                 // optimization: prevent from searching this fail chain again.
                //also prevent matching again.
                vis[temp] = true;
                temp = fail[temp];
            }
        }
        return res;
    }

    void debug()
    {
        for(int i = 0;i < node_cnt;i++)
        {
            printf("id = %3d,fail = %3d,end = %3d,chi = [",i,fail[i],count[i]);
            for(int j = 0;j < MAX_CHILD_NUM;j++)
                printf("%2d",next[i][j]);
            printf("]\n");
        }
    }
}ac;

char st[MAX_LEN];
int n;
int num[4];
int num2[4];
int dp[15000][505];

int myhash(int f[])
{
    int ret = 0;
    for (int i = 0; i < 4; i++)
    {
        ret += f[i] * num[i];
    }
    return ret;
}

int work()
{
    int temp[4] = {0};
    for (int i = 0; st[i]; i++)
    {
        temp[ac.get_id(st[i])]++;
    }
    num[3] = 1;
    for (int i = 2; i >= 0; i--)
    {
        num[i] = (temp[i + 1] + 1) * num[i + 1];
    }
    memset(dp, -1, sizeof(dp));
    int f[4];
    int g[4];
    int ret = 0;
    for (f[0] = 0; f[0] <= temp[0]; f[0]++)
        for (f[1] = 0; f[1] <= temp[1]; f[1]++)
            for (f[2] = 0; f[2] <= temp[2]; f[2]++)
                for (f[3] = 0; f[3] <= temp[3]; f[3]++)
                {
                    for (int u = 0; u < ac.node_cnt; u++)
                    {
                        int h = myhash(f);
                        for (int j = 0; j < 4; j++)
                        {
                            g[j] = f[j];
                        }
                        int temp2 = 0;
                        for (int j = 0; j < 4; j++)
                        {
                            g[j]--;
                            int h2 = myhash(g);
                            int v = ac.next[u][j];
                            if (g[j] >= 0)
                            {
                                temp2 = max(temp2, dp[h2][v]);
                                D(printf("\t\t\t%d %d %d %d %d %d %d\n", g[0], g[1], g[2], g[3], v, temp2, h2));
                            }
                            g[j]++;
                        }
                        dp[h][u] = temp2 + ac.count[u];
                        ret = max(ret, dp[h][u]);
                        D(printf("%d %d %d %d %d %d %d\n", f[0], f[1], f[2], f[3], u, dp[h][u], h));
                    }
                }
    return dp[myhash(temp)][ac.root];
}

int main()
{
    int t = 0;
    while (scanf("%d", &n), n)
    {
        ac.init();
        for (int i = 0; i < n; i++)
        {
            scanf("%s", st);
            ac.insert(st);
        }
        ac.build();
        scanf("%s", st);
        printf("Case %d: %d\n", ++t, work());
    }
    return 0;
}