BZOJ 4032 [HEOI2015]最短不公共子串

后缀自动机+序列自动机

（1）枚举A的子串，在B的SAM上跑一下看是不是B的子串即可。$O(n^2)$

（2）枚举A的子串，在B的序列自动机上跑一下看是不是B的子序列即可。$O(n^2)$

（3）对于一个答案序列s[l…r]，一定有s[l…r-1]和s[l+1…r]都是B的子串。考虑枚举B的子串并同时在B的SAM上跑，再枚举下一个字母，如果这新串不是B的子串，即B的SAM上无转移，且是A的子序列就可以统计答案。$O(26n^2)$，目测是可以用双指针扫描优化到$O(n^2)$的，但是懒得搞。

（4）记 $f[i][j]$ 表示A,B的序列自动机分别在i，j节点上，需要的最短长度，枚举下一个字母，看是不是在A的序列自动机上有转移，在B的序列自动机上无转移即可。$O(26n^2)$。

#include<cstdio>
#include<cstring>
#include<iostream>
#define N 2005
#define S 27
#define cmin(u,v) ((u)>(v)?(u)=(v):0)
#define pr(_i) cout<<#_i<<" = "<<_i<<endl
using namespace std;
namespace runzhe2000
{
    const int INF = 1<<29;
    char A[N], B[N];
    int nA, nB, nextA[N][S], nextB[N][S];
    struct SAM
    {
        SAM *next[S], *fail;
        int len;
    }mem[N<<2], *tot, *null, *rA, *rB, *last;
    SAM* newSAM(int len = 0)
    {
        SAM *p = ++tot;
        *p = *null; p->len = len;
        return p;
    }
    void init()
    {
        null = tot = mem;
        for(int i = 0; i < S; i++) null->next[i] = null;
        null->fail = null; null->len = 0;
        rA = newSAM(), rB = newSAM();
    }
    SAM* extend(SAM *last, int v, SAM *r)
    {
        SAM *np = newSAM(last->len + 1), *p = last;
        for(; p!= null && p->next[v] == null; p = p->fail) p->next[v] = np;
        if(p == null) np->fail = r;
        else
        {
            SAM *q = p->next[v];
            if(q->len == p->len + 1) np->fail = q;
            else
            {
                SAM *nq = newSAM(); *nq = *q; nq->len = p->len + 1;
                np->fail = q->fail = nq;
                for(; p->next[v] == q; p = p->fail) p->next[v] = nq;
            }
        }
        return np;
    }

    int work1()
    {
        int ans = INF;
        for(int i = 1; i <= nA; i++)
        {
            SAM *p = rB;
            for(int j = i; j <= nA; j++)
            {
                p = p->next[A[j] - 'a'];
                if(p == null)
                {
                    cmin(ans, j-i+1);
                    break;
                }
            }
        }
        return ans == INF ? -1 : ans;
    }
    int work2()
    {
        int ans = INF;
        for(int i = 1; i <= nA; i++)
        {
            int p = 0;
            for(int j = i; j <= nA; j++)
            {
                p = nextB[p][A[j] - 'a'];
                if(!p)
                {
                    cmin(ans, j-i+1);
                    break;
                }
            }
        }
        return ans == INF ? -1 : ans;
    }
    int work3()
    {
        int ans = INF;
        if(strcmp(A+1,B+1) == 0) return -1;
        for(int i = 1; i <= nA; i++) if(nextA[0][A[i] - 'a'] && !nextB[0][A[i] - 'a']) return 1;
        for(int i = 1; i <= nB; i++)
        {
            int p = 0; SAM *q = rB;
            for(int j = i; j <= nB; j++)
            {
                p = nextA[p][B[j] - 'a'];
                q = q->next[B[j] - 'a'];
                if(!p) break;
                for(int k = 0; k < S; k++)
                {
                    if(q->next[k] == null && nextA[p][k])
                    {
                        cmin(ans, j-i+2);
                        goto end;
                    }
                }
            }
            end:;
        }
        return ans == INF ? -1 : ans;
    }
    int f[N][N];
    int work4()
    {
        memset(f, 63, sizeof(f));
        f[0][0] = 0; int ans = INF;
        for(int i = 0; i < nA; i++)
        {
            for(int j = 0; j <= nB; j++) if(f[i][j] < INF)
            {
                for(int k = 0; k < S; k++)
                {
                    if(nextA[i][k] && nextB[j][k])
                        cmin(f[nextA[i][k]][nextB[j][k]], f[i][j] + 1);
                    else if(nextA[i][k] && !nextB[j][k]) 
                        cmin(ans, f[i][j] + 1);
                }
            }
        }
        return ans == INF ? -1 : ans;
    }
    void main()
    {
        scanf("%s%s",A+1,B+1); init(); 
        nA = strlen(A+1), nB = strlen(B+1);
        last = rA; for(int i = 1; i <= nA; i++) last = extend(last, A[i] - 'a', rA);
        last = rB; for(int i = 1; i <= nB; i++) last = extend(last, B[i] - 'a', rB);
        for(int i = nA - 1; i >= 0; i--) {memcpy(nextA[i], nextA[i+1], sizeof(nextA[i])); nextA[i][A[i+1] - 'a'] = i+1;}
        for(int i = nB - 1; i >= 0; i--) {memcpy(nextB[i], nextB[i+1], sizeof(nextB[i])); nextB[i][B[i+1] - 'a'] = i+1;}     
        printf("%d\n%d\n%d\n%d\n",work1(),work2(),work3(),work4()); 
    }
}
int main()
{
    runzhe2000::main();
}