[LOJ6061] 「2017 山东一轮集训 Day5」字符串（后缀自动机）

题意

• 给你$n$个字符串，按顺序从每个字符串中选出一个子串（可以为空）拼接起来，求可以拼接出多少种本质不同的串（$\sum |S|\le 10^6$ )

我们首先对于每个字符串都建出SAM，我们知道SAM的每个节点都包含了母串中的一些子串，那么我们考虑每个字符串的SAM中选出一个节点串起来的方案数就是我们想要的答案。

但是这样可能会算重，假设有两个串$ab,b$，那么第一个字符串选出$ab$第二个字符串选出空集和第一个字符串选出$a$与第二个字符串选出$b$就冲突了，其实要避免这种冲突也很简单，我们倒着DP，设$dp(i,j)$为目前从后往前的串到了状态$i$，首字符是$j$的方案数，那么假设状态$k$有$j$这条转移边，那么就不把$dp(i,j)$累加上来，形象理解就是能不把一个子串分在两个状态里就一定不分，那么这种串就只会被在一个状态里算一次了。

那么只要统计SAM中每个节点有多少个以字符C开头的串就好了，这个东西拓扑排序一下就可以了，复杂度$O(\sum 26|S|)$。

#include <queue>
#include <cstdio>
#include <cstring>

using namespace std;

const int maxn = 2e6 + 10;
const int mod = 1e9 + 7;

int add(int x, int y) { return (x += y) < mod ? x : x - mod; }

int mul(int x, int y) { return x * (long long)y % mod; }

struct Suffix_Automaton {
    int trans[maxn][26], len[maxn], link[maxn], root, lst, cnt;

    void extend(int to) {
        int p = lst, now = lst = ++cnt;
        len[now] = len[p] + 1;
        for (; p && !trans[p][to]; p = link[p]) trans[p][to] = now;
        if (!p)
            link[now] = root;
        else {
            int x = trans[p][to], y;
            if (len[x] == len[p] + 1)
                link[now] = x;
            else {
                len[y = ++cnt] = len[p] + 1, link[y] = link[x];
                memcpy(trans[y], trans[x], sizeof(trans[y]));
                for (; p && trans[p][to] == x; p = link[p]) trans[p][to] = y;
                link[now] = link[x] = y;
            }
        }
    }

} SAM;

char s[maxn];

int rt[maxn], de[maxn], dp[maxn][26], vis[maxn][26], n, m;

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i = -~i) {
        scanf("%s", s), m = strlen(s);
        rt[i] = SAM.root = SAM.lst = ++SAM.cnt;
        for (int j = 0; j < m; j = -~j) SAM.extend(s[j] - 'a');
        queue<int> q;
        for (int j = rt[i]; j <= SAM.cnt; j = -~j)
            for (int k = 0, v; k < 26; k = -~k)
                if (v = SAM.trans[j][k]) {
                    if (j == rt[i])
                        dp[v][k] = 1;
                    de[v] = -~de[v];
                }
        for (q.push(rt[i]); !q.empty(); q.pop()) {
            int u = q.front();
            for (int j = 0, v; j < 26; j = -~j)
                if (v = SAM.trans[u][j]) {
                    for (int k = 0; k < 26; k = -~k) dp[v][k] = add(dp[v][k], dp[u][k]);
                    if (!--de[v])
                        q.push(v);
                }
        }
    }
    rt[n + 1] = SAM.cnt + 1;
    long long sum[26], res;
    for (int i = n - 1; ~i; --i) {
        memset(sum, 0, 208);
        for (int j = rt[i + 1]; j < rt[i + 2]; j = -~j)
            for (int k = 0; k < 26; k = -~k) sum[k] += dp[j][k];
        for (int k = 0; k < 26; k = -~k) sum[k] %= mod;
        if (!i) {
            res = 1;
            for (int j = 0; j < 26; j = -~j) res += sum[j];
            printf("%d\n", res % mod);
            break;
        }
        for (int k = 0; k < 26; k = -~k)
            if (!SAM.trans[rt[i]][k])
                dp[rt[i]][k] = add(dp[rt[i]][k], sum[k]);
        for (int j = rt[i] + 1; j < rt[i + 1]; j = -~j) {
            res = 1;
            for (int k = 0; k < 26; k = -~k)
                if (!SAM.trans[j][k])
                    res += sum[k];
            res %= mod;
            for (int k = 0; k < 26; k = -~k) dp[j][k] = mul(dp[j][k], res);
        }
    }

    return 0;
}