洛谷P4112 最短不公共子串

题意：

下面，给两个小写字母串A，B，请你计算：

(1) A的一个最短的子串，它不是B的子串

(2) A的一个最短的子串，它不是B的子序列

(3) A的一个最短的子序列，它不是B的子串

(4) A的一个最短的子序列，它不是B的子序列

解：这是什么四合一毒瘤题......

先上正解：

第一问对B建后缀自动机，枚举A的每个前缀，在B上跑。

第二问枚举A中子串的开始位置，B中贪心匹配。O(n²)。

后两问分别建出B的后缀自动机和序列自动机，然后DP，用f[i][j]表示考虑A的前i个字符，在自动机上走到节点j至少需要几步。答案是f[n][null]

转移就是看节点j有没有A[i + 1]的出边，更新。

好的，接下来上我的SB解法......

第一问，广义后缀自动机裸题。

第二问，我们只需要找出A中的一个子串，它向前/后添加一个字符时在B中无法继续匹配即可。

对A建后缀自动机。

由于这样后缀自动机一个节点的多个子串是逐渐在前面添加字符，所以考虑从后往前找子串，在B中也从后往前匹配。

每个节点有一个posA表示该节点代表的的串的结尾在A中的位置，还有一个pos表示该节点代表的最长串在在B中从后向前贪心匹配到的最右距离。

在fail树上DFS。每个点继承它父亲的pos并一个一个贪心匹配直到这个点代表的最长串完成匹配。如果失配了就更新答案。否则就记录pos，向下DFS。

第三问，首先可以得知，如果A中的每一个字符都在B中出现过，那么符合条件的A一定是B的一个子串加上一个B中没有的转移。

于是建出B的后缀自动机。

我们用pos[x]表示节点x所表示的最短子串在A中从前往后贪心匹配到的最短距离。为什么是最短呢？因为我们要越短越好 + 越靠左越好。因为这个节点的每个子串加上一个不存在的转移都会合法，所以短比长优。而靠左的更可能在A中找到B不存在的转移。

而不存在一个非最短子串的最靠左距离会左于最短子串。

于是我们分析了一大通之后发现，只要按照拓扑序更新pos，取最小值就行了。

在每个节点的pos[x]+1开始向右扫A，如果没有转移就更新答案。否则更新下一个节点的pos。

第四问实在是想不出来了，就跑去看题解，学习了一波序列自动机，用了正解写的。

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

const int N = 8010;

struct Edge {
    int nex, v;
}edge[N << 1]; int top;

int tr[N * 2][26], fail[N], len[N], tot, cnt[N], bin[N], topo[N], last;
int e[N], n, m;
char A[N], B[N];

inline void add(int x, int y) {
    top++;
    edge[top].v = y;
    edge[top].nex = e[x];
    e[x] = top;
    return;
}

inline void insert(char c) {
    int f = c - 'a';
    int p = last, np = ++tot;
    last = np;
    len[np] = len[p] + 1;
    while(p && !tr[p][f]) {
        tr[p][f] = np;
        p = fail[p];
    }
    if(!p) {
        fail[np] = 1;
    }
    else {
        int Q = tr[p][f];
        if(len[Q] == len[p] + 1) {
            fail[np] = Q;
        }
        else {
            int nQ = ++tot;
            len[nQ] = len[p] + 1;
            fail[nQ] = fail[Q];
            fail[Q] = fail[np] = nQ;
            memcpy(tr[nQ], tr[Q], sizeof(tr[Q]));
            while(tr[p][f] == Q) {
                tr[p][f] = nQ;
                p = fail[p];
            }
        }
    }
    return;
}

inline void clear() {
    memset(tr, 0, sizeof(tr));
    memset(fail, 0, sizeof(fail));
    memset(e, 0, sizeof(e));
    memset(len, 0, sizeof(len));
    memset(bin, 0, sizeof(bin));
    memset(topo, 0, sizeof(topo));
    memset(cnt, 0, sizeof(cnt));
    last = tot = top = 0;
    return;
}

namespace t1 {
    bool vis[N];
    inline int split(int p, int f) {
        int Q = tr[p][f], nQ = ++tot;
        len[nQ] = len[p] + 1;
        fail[nQ] = fail[Q];
        fail[Q] = nQ;
        memcpy(tr[nQ], tr[Q], sizeof(tr[Q]));
        while(tr[p][f] == Q) {
            tr[p][f] = nQ;
            p = fail[p];
        }
        return nQ;
    }
    inline int insert(char c, int p) {
        int f = c - 'a';
        if(tr[p][f]) {
            int Q = tr[p][f];
            if(len[Q] == len[p] + 1) {
                return Q;
            }
            return split(p, f);
        }
        int np = ++tot;
        len[np] = len[p] + 1;
        while(p && !tr[p][f]) {
            tr[p][f] = np;
            p = fail[p];
        }
        if(!p) {
            fail[np] = 1;
        }
        else {
            int Q = tr[p][f];
            if(len[Q] == len[p] + 1) {
                fail[np] = Q;
            }
            else {
                fail[np] = split(p, f);
            }
        }
        return np;
    }
    void DFS(int x) {
        if(vis[x] || !x) {
            return;
        }
        vis[x] = 1;
        DFS(fail[x]);
        return;
    }
    inline void solve() {
        int last = 1;
        tot = 1;
        for(int i = 0; i < n; i++) {
            last = insert(A[i], last);
        }
        last = 1;
        for(int i = 0; i < m; i++) {
            last = insert(B[i], last);
        }
        // SAM over
        int p = 1;
        for(int i = 0; i < m; i++) {
            p = tr[p][B[i] - 'a'];
            DFS(p);
        }
        int ans = n + m;
        for(int i = 2; i <= tot; i++) {
            if(!vis[i]) {
                ans = std::min(ans, len[fail[i]] + 1);
            }
        }
        printf("%d
", (ans != n + m) ? ans : -1);
        return;
    }
}

namespace t2 {
    // pos[i] Node i's last position in B
    int pos[N], posA[N], ans;
    std::queue<int> Q;
    void DFS(int x) {
        //printf("x = %d posA[x] = %d 
", x, posA[x]);
        int p = pos[fail[x]] - 1;
        for(int i = posA[x] - len[fail[x]]; i >= posA[x] - len[x] + 1; i--) {
            //printf(" > i = %d 
", i);
            while(p >= 0 && B[p] != A[i]) {
                //printf(" > > p = %d 
", p);
                p--;
            }
            //printf(" > > p = %d 
", p);
            if(p < 0) {
                ans = std::min(ans, posA[x] - i + 1);
                return;
            }
            else {
                pos[x] = p;
                p--;
            }
        }
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            DFS(y);
        }
        return;
    }
    inline void solve() {
        clear();
        last = tot = 1;
        for(int i = 0; i < n; i++) {
            int t = tot;
            insert(A[i]);
            for(int j = t + 1; j <= tot; j++) {
                posA[j] = i;
            }
        }
        ans = n + m;
        for(int i = 2; i <= tot; i++) {
            add(fail[i], i);
            //printf("add %d %d 
", fail[i], i);
        }
        pos[1] = m;
        DFS(1);
        printf("%d
", ans != n + m ? ans : -1);
        return;
    }
}

namespace t3 {
    int pos[N], ans;
    inline void solve() {
        for(int i = 0; i < m; i++) {
            bin[B[i]]++;
        }
        for(int i = 0; i < n; i++) {
            if(!bin[A[i]]) {
                printf("1
");
                return;
            }
        }
        clear();
        tot = last = 1;
        for(int i = 0; i < m; i++) {
            insert(B[i]);
        }
        for(int i = 1; i <= tot; i++) {
            bin[len[i]]++;
        }
        for(int i = 1; i <= tot; i++) {
            bin[i] += bin[i - 1];
        }
        for(int i = 1; i <= tot; i++) {
            topo[bin[len[i]]--] = i;
        }
        //
        memset(pos, 0x3f, sizeof(pos));
        ans = n + m;
        pos[1] = -1;
        for(int a = 1; a <= tot; a++) {
            int x = topo[a];
            for(int i = pos[x] + 1; i < n; i++) {
                int f = A[i] - 'a';
                if(!tr[x][f]) {
                    ans = std::min(ans, len[fail[x]] + 2);
                }
                else {
                    pos[tr[x][f]] = std::min(pos[tr[x][f]], i);
                }
            }
        }
        printf("%d
", ans != n + m ? ans : -1);
        return;
    }
}

namespace t4 {
    int nex[N][26], last[26], f[2010][2010];
    inline void exmin(int &a, int b) {
        a > b ? a = b : 0;
        return;
    }
    inline void solve() {
        clear();
        memset(f, 0x3f, sizeof(f));
        for(int i = 0; i < 26; i++) {
            last[i] = m + 2;
        }
        for(int i = m - 1; i >= 0; i--) {
            for(int j = 0; j < 26; j++) {
                nex[i + 2][j] = last[j];
            }
            last[B[i] - 'a'] = i + 2;
        }
        for(int j = 0; j < 26; j++) {
            nex[1][j] = last[j];
        }
        f[0][1] = 0;
        for(int i = 0; i < n; i++) {
            for(int j = 1; j <= m + 2; j++) {
                exmin(f[i + 1][j], f[i][j]);
                int k = A[i] - 'a';
                //printf("i %d j %d  nex[j][k] %d 
", i, j, nex[j][k]);
                // tr[j][f]
                if(!nex[j][k]) {
                    continue;
                }
                exmin(f[i + 1][nex[j][k]], f[i][j] + 1);
                //printf("f %d %d -> f %d %d : %d 
", i, j, i + 1, nex[j][k], f[i][j] + 1);
            }
        }
        printf("%d
", f[n][m + 2] == f[n][m + 3] ? -1 : f[n][m + 2]);
        return;
    }
}

int main() {
    scanf("%s%s", A, B);
    n = strlen(A);
    m = strlen(B);
    t1::solve();
    t2::solve();
    t3::solve();
    t4::solve();

    return 0;
}

附：序列自动机。

对于长为n的序列，序列自动机有n + 1个节点，分别表示这n个位置和起点。每个节点都有字符集个转移边，指向该字符在它之后第一次出现的位置。fail指针指向上一个它出现的位置。

能够识别所有的子序列。