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

题目链接

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

First.A子串≠B子串

实际上就是求两个串的最长公共子串
$f[i][j]$表示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);

$a$记录的最长公共子串长度

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

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

Second.A子串≠B子序列

贪心（真是book思议）
枚举序列A的匹配起点，贪心的匹配B序列
我们也可以用dp完成
$f[i][j]$表示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])$

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

还是注意：

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

Third.A子序列≠B子串

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

Fourth.A子序列≠B子序列

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

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

tip

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

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

#include<cstdio>
#include<cstring>
#include<iostream>

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;
}