bzoj4032 [HEOI2015]最短不公共子串（字符串dp+SAM）

题目链接

分析：
字符串dp四合一
比较神的一道题，一开始只会搞第一问
然而发现自己的方法不是很靠谱

First.A子串≠B子串

实际上就是求两个串的最长公共子串
f[i][j]f[i][j]表示A序列第ii位与B序列第jj位匹配，得到的最长公共子串
f[i][j]=f[i−1][j−1]+1(A[i]=B[j])f[i][j]=f[i−1][j−1]+1(A[i]=B[j])
答案就是所有的最长公共子串中的最小值+1

其中有一点要注意：

if (a!=i) ans=min(ans,a+1);

aa记录的最长公共子串长度

为什么a!=ia!=i的时候，才能更新答案呢？

因为a==ia==i，就说明AA序列1−i1−i位都能够匹配上，
那么得到的答案可能值a+1a+1就有可能没有意义了
（有可能A和B序列完全相等，正确答案应该是-1）

Second.A子串≠B子序列

贪心（真是book思议）
枚举序列A的匹配起点，贪心的匹配B序列
我们也可以用dp完成
f[i][j]f[i][j]表示A序列第ii位与B序列第jj位匹配
转移的时候只有一点小变化：
f[i][j]=f[i−1][j−1]+1(A[i]=B[j])f[i][j]=f[i−1][j−1]+1(A[i]=B[j])
f[i][j]=f[i][j−1](A[i]!=B[j])f[i][j]=f[i][j−1](A[i]!=B[j])

为什么不相等的时候要这么转移呢？
我们枚举的ii的A的子串起始点
子串一定是连续的，因此要保证ii一定要得到匹配，所以ii不能动

还是注意：

if (a!=i) ans=min(ans,a+1);

Third.A子序列≠B子串

用B串建立SAMSAM
设计状态：l[i]l[i]表示用SAMSAM中的结点ii匹配A序列能够得到的最短长度
我们枚举A的每一位ii和SAMSAM中的每一个结点jj
如果有ch[j][i]ch[j][i]这个结点，说明能够匹配的上，因此l[ch[j][i]]=min(l[j]+1)l[ch[j][i]]=min(l[j]+1)
最后答案就是min(l[i]+1)min(l[i]+1)

Fourth.A子序列≠B子序列

和第三问差不多
但是因为两者都是子序列，所以我们需要预先处理一个数组cc
c[i][j]c[i][j]表示B序列中第ii位之前字符jj的最近位置

我们还是利用贪心的思想
l[i]l[i]表示匹配到字符串B第ii位的最短长度
枚举A的每一位ii，倒序枚举B的每一位jj（注意我们构造cc数组的意义）
如果有c[j][A[i]]c[j][A[i]]这个结点，说明jj之前有一个位置能够与A[i]A[i]匹配，因此：l[c[j][A[i]]=min(l[j]+1)l[c[j][A[i]]=min(l[j]+1)

tip

天大的坑：if (a!=i) ans=min(ans,a+1);

看到dalao们都跪吉利添动力，所以也来一发

#include
#include
#include

using namespace std;

const int INF=1e9;
const int N=4005;
int dis[N],ch[N][26],fa[N],last=1,root=1,sz=1,len;
int f[2003][2003],l[N],l1,l2,c[N][26],mp[26];
char s[N],ss[N];

void insert(int x)
{
    int now=++sz,pre=last;
    last=now;
    dis[now]=dis[pre]+1;
    for (;pre&&!ch[pre][x];pre=fa[pre]) ch[pre][x]=now;

    if (!pre) fa[now]=root;
    else
    {
        int q=ch[pre][x];
        if (dis[q]==dis[pre]+1) fa[now]=q;
        else
        {
            int nows=++sz;
            dis[nows]=dis[pre]+1;
            memcpy(ch[nows],ch[q],sizeof(ch[q]));
            fa[nows]=fa[q]; fa[q]=fa[now]=nows;
            for (;pre&&ch[pre][x]==q;pre=fa[pre]) ch[pre][x]=nows;
        }
    }
}

void solve1()
{
    memset(f,0,sizeof(f));
    int ans=INF;
    for (int i=1;i<=l1;i++)
    {
        int a=0;
        for (int j=1;j<=l2;j++)
        {
            if (s[i]==ss[j]) f[i][j]=max(f[i][j],f[i-1][j-1]+1);
            a=max(a,f[i][j]);
        }
        if (a!=i) ans=min(ans,a+1);    //a!=i 
    }       
    if (ans>l1||ans>l2) printf("-1\n");
    else printf("%d\n",ans);
}

void solve2()
{
    memset(f,0,sizeof(f));
    int ans=INF;
    for (int i=1;i<=l1;i++)   //枚举起点 
    {
        int a=0;
        for (int j=1;j<=l2;j++)
        {
            if (s[i]==ss[j]) f[i][j]=max(f[i][j],f[i-1][j-1]+1);
            else f[i][j]=f[i][j-1];
            a=max(a,f[i][j]);
        }
        if (a!=i) ans=min(ans,a+1);
    }
    if (ans>l1||ans>l2) printf("-1\n");
    else printf("%d\n",ans);
}

void solve3()
{
    memset(l,0x33,sizeof(l));
    l[1]=0;
    int ans=INF;
    for (int i=1;i<=l1;i++)
        for (int j=1;j<=sz;j++)
        {
            int t=ch[j][s[i]-'a'];
            if (!t) ans=min(ans,l[j]+1);
            else l[t]=min(l[t],l[j]+1);
            //l表示的是用a的子序列去匹配后缀自动机中的结点，到结点i能得到的最短长度   
        }
    if (ans>l1||ans>l2) printf("-1\n");
    else printf("%d\n",ans);
}

void solve4()
{
    memset(l,0x33,sizeof(l));
    l[0]=0;
    int ans=INF;
    for (int i=l2;i>=0;i--)
    {
        for (int j=0;j<26;j++)
            if (mp[j]) c[i][j]=mp[j];
        mp[ss[i]-'a']=i;
    }
    for (int i=1;i<=l1;i++)
        for (int j=l2;j>=0;j--)
        {
            int t=c[j][s[i]-'a'];
            if (!t) ans=min(ans,l[j]+1);
            else l[t]=min(l[t],l[j]+1);
        }
    if (ans>l1||ans>l2) printf("-1\n");
    else printf("%d\n",ans);
}

int main()
{
    scanf("%s",s+1); 
    scanf("%s",ss+1);  len=strlen(ss+1);
    for (int i=1;i<=len;i++) insert(ss[i]-'a');
    l1=strlen(s+1); l2=strlen(ss+1);
    solve1();
    solve2();
    solve3();
    solve4();
    return 0;
}