HDU 6086 AC自动机+状压dp

题意：

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6086
给出m个单词，要构造出长度为2*L的包含这全部m个单词的字符串，并且保证这个字符串非对称，其中字符只包括0和1，问一共有多少种构造方法。

---

思路：

本题是hdu2825的拓展，建议先做2825，博客链接：http://blog.csdn.net/bahuia/article/details/77149003
在2825的基础上，本题增加了非对称的性质，很显然，只要确定了一半，另一半就固定了。比赛的时候想到了只构造右半边，要将子串枚举断点对折来看，但是当时想的是从中间到两边的dp，每次直接将对折的两半字符串都加到ac自动机中，本以为这样就可以处理经过中轴线的子串，但是这样有问题，因为如011，拆成0和11，如果将11放入ac自动机中，那么不能保证11一定是在字符串中间的（右半边最左边），有可能存在xxx11xxx这样的情况。然后觉得可能在单词结点上处理在某些情况下dp到这个结点才算找到这个单词，但是每个子串的长度都不一样，没有想到怎么处理。
赛后看了别人的思路，其实与之前说的都差不多，但是只是在dp的时候在L-1的时候才计算那些经过中轴线的字符串，想了很久很久，不明白为什么可以这样处理，最后终于弄懂了。

对这题来说，首先要分成一半来考虑，这里不妨考虑左半部分长度为L的字符串的构造。那么所有单词一共有三种情况，要么出现在考虑的左半部分，或者出现在右半部分，或者左右各有一部分（经过中轴线），只出现在左边和右边的很好处理，只要将单词串和单词串翻转取反加入ac自动机dp即可。
对于经过中轴线的单词，比如: 011分割成0和11，（注意这里不能分成01和1，因为这样就对称了。）补齐之后是00 | 11，也就是说只要左半部分出现了00，就代表构造的2 * L的字符串中已经出现了0011。关键是这里00和11在构造出来的字符串中一定要连在一起，其实也就是构造的左半部分的结尾，因此，只要在dp到长度为L的时候才可以考虑这些经过中轴线的字符串。
这样只要在ac自动机中设置两个单词结点标记end1和end2，end1表示不经过中轴线的结点，end2表示经过中轴线的单词结点。dp的时候特判一下进行状态转移即可。

比赛的时候思路是从中间向两边dp，正解的思路是从两边向中间dp，在最后的时刻特殊处理中轴线单词就行了，仔细想想为什么前者不行，后者就可以处理，个人认为可能是因为ac自动机的结点表示是一种结尾信息，也就是到达这个点的表示的信息，因此不好处理从起点开始的性质，因此需要将问题转化为到达的性质才可以。

ps：用BC官方题解的暴力枚举思路写的代码一直T到姥姥家。（应该是我太菜了）

---

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MAXNODE = 2500;
const int SIGMA_SIZE = 2;
const LL MOD = 998244353;

struct ACauto {
    int next[MAXNODE][SIGMA_SIZE], fail[MAXNODE], end1[MAXNODE], end2[MAXNODE];
    int root,sz;

    int newnode() {
        for (int i = 0; i < SIGMA_SIZE; i++)
            next[sz][i] = -1;
        end1[sz] = 0;
        end2[sz++] = 0;
        return sz - 1;
    }

    void init() {
        sz = 0;
        root = newnode();
    }

    void insert1(char *buf, int id) {
        int len = strlen(buf);
        int now = root;
        for (int i = 0; i < len; i++) {
            if (next[now][buf[i] - '0'] == -1)
                next[now][buf[i] - '0'] = newnode();
            now = next[now][buf[i] - '0'];
        }
        end1[now] |= (1 << id);
    }

    void insert2(char *buf, int id) {
        int len = strlen(buf);
        int now = root;
        for (int i = 0; i < len; i++) {
            if (next[now][buf[i] - '0'] == -1)
                next[now][buf[i] - '0'] = newnode();
            now = next[now][buf[i] - '0'];
        }
        end2[now] |= (1 << id);
    }

    void build() {
        queue <int> Q;
        fail[root] = root;
        for (int i = 0; i < SIGMA_SIZE; 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();
            end1[now] |= end1[fail[now]];
            end2[now] |= end2[fail[now]];
            for (int i = 0; i < SIGMA_SIZE; i++) {
                if (next[now][i] == -1)
                    next[now][i] = next[fail[now]][i];
                else {
                    fail[next[now][i]] = next[fail[now]][i];
                    Q.push(next[now][i]);
                }
            }
        }
    }

} ac;

int n, L;
char s[30], t[30], str[60];
LL dp[2][2500][(1 << 6) + 10];

int main() {
    //freopen("in.txt", "r", stdin);
    int T;
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &n, &L);
        ac.init();
        for (int i = 0; i < n; i++) {
            scanf("%s", s);
            ac.insert1(s, i);
            //cout << i << endl;
           // cout << s << endl;
            int len = strlen(s);
            for (int j = 0; j < len; j++)
                t[j] = s[len - 1 - j] == '0' ? '1' : '0';
            t[len] = '\0';
            ac.insert1(t, i);
            //cout << t << endl;
            for (int j = 0; j < len - 1; j++) {
                string s1 = "", s2 = "";
                for (int k = j; k >= 0; k--) s1 += s[k];
                for (int k = j + 1; k < len; k++) s2 += s[k];
                //cout << " : " << s1 << "  " << s2 << endl;
                bool flag = true;
                for (int k = 0; k < (int)s1.length() && k < (int)s2.length(); k++) {
                    if (s1[k] == s2[k]) {
                        flag = false;
                        break;
                    }
                }
                if (!flag) continue;
                reverse(s1.begin(), s1.end());
                //cout << " -- " << s1 << endl;
                for (int k = (j + 1) * 2; k < len; k++) {
                    s1 = (s[k] == '0' ? '1' : '0') + s1;
                }
                //cout << s1 << endl;
                strcpy(str, s1.c_str());
                ac.insert2(str, i);
            }
        }
        ac.build();
        memset(dp, 0, sizeof(dp));
        dp[0][0][0] = 1;
        for (int i = 0; i < L; i++) {
            for (int j = 0; j < ac.sz; j++) {
                for (int S = 0; S < (1 << n); S++) {
                    if (dp[i % 2][j][S] <= 0) continue;
                    for (int k = 0; k < SIGMA_SIZE; k++) {
                        int ni = i + 1, nj = ac.next[j][k], nS = S | ac.end1[nj];
                        if (i == L - 1) nS |= ac.end2[nj];
                        dp[ni % 2][nj][nS] = (dp[ni % 2][nj][nS] + dp[i % 2][j][S]) % MOD;
                    }
                    dp[i % 2][j][S] = 0;
                }
            }
        }
        LL ans = 0;
        for (int i = 0; i < ac.sz; i++) {
            ans = (ans + dp[L % 2][i][(1 << n) - 1]) % MOD;
        }
        printf("%I64d\n", ans);
    }
    return 0;
}