洛谷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 = ;

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

 int tr[N * ][], 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] + ;
     while(p && !tr[p][f]) {
         tr[p][f] = np;
         p = fail[p];
     }
     if(!p) {
         fail[np] = ;
     }
     else {
         int Q = tr[p][f];
         if(len[Q] == len[p] + ) {
             fail[np] = Q;
         }
         else {
             int nQ = ++tot;
             len[nQ] = len[p] + ;
             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, , sizeof(tr));
     memset(fail, , sizeof(fail));
     memset(e, , sizeof(e));
     memset(len, , sizeof(len));
     memset(bin, , sizeof(bin));
     memset(topo, , sizeof(topo));
     memset(cnt, , sizeof(cnt));
     last = tot = top = ;
     return;
 }

 namespace t1 {
     bool vis[N];
     inline int split(int p, int f) {
         int Q = tr[p][f], nQ = ++tot;
         len[nQ] = len[p] + ;
         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] + ) {
                 return Q;
             }
             return split(p, f);
         }
         int np = ++tot;
         len[np] = len[p] + ;
         while(p && !tr[p][f]) {
             tr[p][f] = np;
             p = fail[p];
         }
         if(!p) {
             fail[np] = ;
         }
         else {
             int Q = tr[p][f];
             if(len[Q] == len[p] + ) {
                 fail[np] = Q;
             }
             else {
                 fail[np] = split(p, f);
             }
         }
         return np;
     }
     void DFS(int x) {
         if(vis[x] || !x) {
             return;
         }
         vis[x] = ;
         DFS(fail[x]);
         return;
     }
     inline void solve() {
         int last = ;
         tot = ;
         for(int i = ; i < n; i++) {
             last = insert(A[i], last);
         }
         last = ;
         for(int i = ; i < m; i++) {
             last = insert(B[i], last);
         }
         // SAM over
         int p = ;
         for(int i = ; i < m; i++) {
             p = tr[p][B[i] - 'a'];
             DFS(p);
         }
         int ans = n + m;
         for(int i = ; i <= tot; i++) {
             if(!vis[i]) {
                 ans = std::min(ans, len[fail[i]] + );
             }
         }
         printf("%d\n", (ans != n + m) ? ans : -);
         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 \n", x, posA[x]);
         int p = pos[fail[x]] - ;
         for(int i = posA[x] - len[fail[x]]; i >= posA[x] - len[x] + ; i--) {
             //printf(" > i = %d \n", i);
             while(p >=  && B[p] != A[i]) {
                 //printf(" > > p = %d \n", p);
                 p--;
             }
             //printf(" > > p = %d \n", p);
             if(p < ) {
                 ans = std::min(ans, posA[x] - i + );
                 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 = ;
         for(int i = ; i < n; i++) {
             int t = tot;
             insert(A[i]);
             for(int j = t + ; j <= tot; j++) {
                 posA[j] = i;
             }
         }
         ans = n + m;
         for(int i = ; i <= tot; i++) {
             add(fail[i], i);
             //printf("add %d %d \n", fail[i], i);
         }
         pos[] = m;
         DFS();
         printf("%d\n", ans != n + m ? ans : -);
         return;
     }
 }

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

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

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

     return ;
 }

AC代码

附：序列自动机。

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

能够识别所有的子序列。