bzoj1195

AC自动机+状压dp

多串匹配要想ac自动机

dp[i][S]表示在i状态选中S

转移就用bfs，每个点通过fail收集信息，不要忘记通过fail传递

昨天搞不明白为什么自动机每次只可以转移儿子，不可以转移fail，问了问大概知道因为儿子是最长的后缀，包含的信息最多，包含了其他fail的信息，就相当于收集了其他fail的东西，就不用走了，但是一定要收集，这跟kmp很像，kmp就是走最大的后缀，这里也是，这样就可以保证不遗补漏同时加速

字典序最大在bfs时已经保证了，感觉比较显然，每次先拓展字典序最小的字符，bfs又求最短路，正好保证了字典序最小

#include<bits/stdc++.h>
using namespace std;
const int N = ;
int n;
char s[N];
namespace ac_automation
{
    int cnt, root, tot;
    int id[N];
    struct DP {
        short d, c;
        short pre[];
        DP () { d = -; }
    } dp[N][ << ];
    struct node {
        int fail;
        int ch[];
    } t[N];
    void ins(char *s)
    {
        int len = strlen(s), now = root;
        for(int i = ; i < len; ++i)
        {
            int c = s[i] - 'A';
            if(!t[now].ch[c]) t[now].ch[c] = ++tot;
            now = t[now].ch[c];
        }
        id[now] |=  << (cnt++);
    }
    void construct_fail()
    {
        queue<int> q;
        for(int i = ; i < ; ++i) if(t[root].ch[i]) q.push(t[root].ch[i]);
        while(!q.empty())
        {
            int u = q.front();
            q.pop();
            for(int i = ; i < ; ++i)
            {
                int &v = t[u].ch[i];
                if(!v) v = t[t[u].fail].ch[i];
                else
                {
                    t[v].fail = t[t[u].fail].ch[i];
                    id[v] |= id[t[v].fail];
                    q.push(v);
                }
            }
        }
    }
    void print(int u, int S)
    {
        if(u == root && S == ) return;
        print(dp[u][S].pre[], dp[u][S].pre[]);
        printf("%c", (char)(dp[u][S].c + 'A'));
    }
    void solve()
    {
        int a = , b = , mn = 0x3f3f3f3f;
        queue<int> q;
        q.push();
        q.push();
        dp[][].d = ;
        while(!q.empty())
        {
            int u = q.front(); q.pop();
            int S = q.front(); q.pop();
            if(S == ( << n) - )
            {
                if(dp[u][S].d < mn)
                {
                    a = u;
                    b = S;
                    mn = dp[u][S].d;
                }
                continue;
            }
            for(int i = ; i < ; ++i) if(t[u].ch[i])
            {
                int v = t[u].ch[i];
                dp[v][S | id[v]].c = i;
                if(dp[v][S | id[v]].d == -)
                {
                    dp[v][S | id[v]].d = dp[u][S].d + ;
                    dp[v][S | id[v]].pre[] = u;
                    dp[v][S | id[v]].pre[] = S;
                    q.push(v);
                    q.push(S | id[v]);
                }
            }
        }
        print(a, b);
    }
}
int main()
{
    scanf("%d", &n);
    for(int i = ; i <= n; ++i)
    {
        scanf("%s", s);
        ac_automation :: ins(s);
    }
    ac_automation :: construct_fail();
    ac_automation :: solve();
    return ;
}