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

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

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 446  Solved: 224
[Submit][Status][Discuss]

Description

 在虐各种最长公共子串、子序列的题虐的不耐烦了之后，你决定反其道而行之。

一个串的“子串”指的是它的连续的一段，例如bcd是abcdef的子串，但bde不是。

一个串的“子序列”指的是它的可以不连续的一段，例如bde是abcdef的子串，但bdd不是。

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

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

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

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

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

Input

有两行，每行一个小写字母组成的字符串，分别代表A和B。

Output

输出4行，每行一个整数，表示以上4个问题的答案的长度。如果没有符合要求的答案，输出-1.

Sample Input

aabbcc
abcabc

Sample Output

2
4
2
4

HINT

 

 对于100%的数据，A和B的长度都不超过2000

 

 

Source

 

[Submit][Status][Discuss]

 

本来以为是HEOI2015的大水题，然后被小甜甜安利了一发序列自动机……

我等蒟蒻并不会此等算法，所以只好暴力喽！

 

拿到之后看到是四个答案，就分别考虑。

 

问题一 A的一个最短的子串，不是B的子串

这个比较简单哈，刺姐姐和任哥哥不约而同地给出了HASH做法——预先对B串的每个子串处理出HASH值，扔进哈希表里，然后暴力枚举A串的每个子串，查询是否在B中出现过，如果没有出现过，就可以用来更新答案。

然后蒟蒻的我表示并不会HASH此等算法，只好KMP暴力喽。每次枚举A串中的一个位置，作为其子串的左端点，记为$L$。此时我们希望查询所有以$L$作为左端点的A的子串，最短的一个不是B的子串的东东。这个就对A串的$[L,Len]$求next数组，拿B串跑一遍KMP就行了。时间复杂度$O(N^2)$。

 

问题二 A的一个最短的子串，不是B的子序列

这个非常简单哈，众神犇（除了我的所有人）一致给出了暴力做法。枚举A的子串的左端点，然后暴力检查至少以那个点作为右端点，该子串才不是B的子序列。时间复杂度$O(N^2)$。

 

问题三 A的一个最短的子序列，不是B的子串

这个也很简单哈，众神犇表示不直接序列自动机直接上就可以，但是蒟蒻的我依旧不会，只好写暴力了哈。

先取出B的所有子串，塞到Trie树里面去，总的节点数是$O(N^2)$，算了下内存有点吃紧，就用map<int,int>了。

然后在每个节点上记录一个标记mark，代表A串中最少选出几个字符，才能匹配到Trie上的这个节点来。这个直接DFS就可以得到了。

然后在在每个Trie树节点上枚举一个字符，如果该节点没有这个字符的出边，那么A串就有机会找出一个合法的解了。此时我们只需要知道A串在mark位置之后是否出现过字符c即可，这个很简单喽。

 

问题四 A的一个最短的子序列，不是B的子序列

这个最最简单哈，只要用$f_{i,j}$表示使用A的前$i$个字符，使得B不得不使用前$j$个字符和其匹配，所能使用的最少字符数。这个$O(N^2)$动态规划，太简单就不说了。

 

然后顺利用四种暴力水过HEOI2015的最水一题。

 

#include <map>
#include <cstdio>
#include <cstring>

#define chr char
#define rst register
#define rnt register int

template <class T>
inline T min(const T &a, const T &b)
{
    return a < b ? a : b;
}

template <class T>
inline T max(const T &a, const T &b)
{
    return a > b ? a : b;
}

#define mxn 2005
#define mxm 4000005

int n, m;

chr a[mxn];
chr b[mxn];

namespace case1
{
    int tot;
    int pos;
    int vis[mxn];
    int fil[mxn];
    int nxt[mxn][26];
    
    inline int solve(int s)
    {
        tot = 1;
        pos = 1;
        
        memset(vis, 0, sizeof vis);
        memset(nxt, 0, sizeof nxt);
        memset(fil, 0, sizeof fil);
        
        for (rnt i = s; i < n; ++i)
            pos = nxt[pos][a[i] - 'a'] = ++tot;
        
        fil[1] = 1;
        
        for (rnt i = 0; i < 26; ++i)
            if (nxt[1][i])
                fil[nxt[1][i]] = 1;
            else
                nxt[1][i] = 1;
        
        for (rnt i = 2; i <= tot; ++i)
            for (rnt j = 0; j < 26; ++j)
                if (nxt[i][j])
                    fil[nxt[i][j]] = nxt[fil[i]][j];
                else
                    nxt[i][j] = nxt[fil[i]][j];
        
        pos = 1;
        
        for (rnt i = 0; i < m; ++i)
            vis[pos = nxt[pos][b[i] - 'a']] = 1;
        
        for (rnt i = 2; i <= tot; ++i)
            if (!vis[i])return i - 1;
        
        return 1E9;
    }
    
    inline void main(void)
    {
        int ans = 1E9;

        for (rnt i = 0; i < n; ++i)
            ans = min(ans, solve(i));
        
        if (ans != 1E9)
            printf("%d\n", ans);
        else
            printf("%d\n", -1);
    }
}

namespace case2
{
    inline int solve(int s)
    {
        for (rnt i = s, j = 0; i < n; ++i, ++j)
        {
            while (j < m && b[j] != a[i])
                ++j;
            
            if (j >= m)
                return i - s + 1;
        }
        
        return 1E9;
    }
    
    inline void main(void)
    {
        int ans = 1E9;
        
        for (rnt i = 0; i < n; ++i)
            ans = min(ans, solve(i));
        
        if (ans != 1E9)
            printf("%d\n", ans);
        else
            printf("%d\n", -1);
    }
}

namespace case3
{
    int nxt[mxn][26];
    
    inline void prework(void)
    {
        for (rnt i = 0; i <= n; ++i)
            for (rnt j = 0; j < 26; ++j)
                nxt[i][j] = n;
        
        for (rnt i = 0; i < n; ++i)
            nxt[i][a[i] - 'a'] = i;
        
        for (rnt i = n - 2; i >= 0; --i)
            for (rnt j = 0; j < 26; ++j)
                nxt[i][j] = min(nxt[i][j], nxt[i + 1][j]);
    }
    
    typedef std::map<int, int> map;
    typedef std::map<int, int>::iterator itr;
    
    int tot = 1;
    int mrk[mxm];
    map son[mxm];
    
    inline void build(void)
    {
        for (rnt i = 0; i < m; ++i)
        {
            rnt t = 1;
            
            for (rnt j = i; j < m; ++j)
            {
                rnt c = b[j] - 'a';
                
                if (son[t][c] == 0)
                    son[t][c] = ++tot;
                
                t = son[t][c];
            }
        }
    }
    
    int ans = 1E9;
    
    inline void getmark(int t = 1, int d = 1)
    {
        if (d >= ans)return;

        int p = mrk[t];
        
        for (rnt i = 0; i < 26; ++i)
            if (nxt[p][i] < n) {
                if (son[t][i])
                    mrk[son[t][i]] = nxt[p][i] + 1,
                    getmark(son[t][i], d + 1);
                else
                    ans = min(ans, d);
            }
    }
    
    inline void main(void)
    {
        build();
        
        prework();
        
        getmark();
        
        if (ans != 1E9)
            printf("%d\n", ans);
        else
            printf("%d\n", -1);
    }
}

namespace case4
{
    int nxt[mxn][26];
    
    int len[mxn][mxn];
    
    inline void main(void)
    {
        for (rnt i = 0; i <= m; ++i)
            for (rnt j = 0; j < 26; ++j)
                nxt[i][j] = m;
        
        for (rnt i = 0; i < m; ++i)
            nxt[i][b[i] - 'a'] = i;
        
        for (rnt i = m - 2; i >= 0; --i)
            for (rnt j = 0; j < 26; ++j)
                nxt[i][j] = min(nxt[i][j], nxt[i + 1][j]);
        
        memset(len, 0x3f, sizeof len);
        
        len[0][0] = 0;
        
        rnt t;
        
        for (rnt i = 0; i < n; ++i)
            for (rnt j = 0; j <= m; ++j)
                if (len[i][j] < 0x3f3f3f3f) {
                    t = nxt[j][a[i] - 'a'] + 1;
                    len[i + 1][j] = min(len[i + 1][j], len[i][j]);
                    len[i + 1][t] = min(len[i + 1][t], len[i][j] + 1);
                }
        
        int ans = 1E9;
        
        for (rnt i = 0; i <= n; ++i)
            ans = min(ans, len[i][m + 1]);
        
        if (ans != 1E9)
            printf("%d\n", ans);
        else
            printf("%d\n", -1);
    }
}

signed main(void)
{
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    freopen("out", "w", stdout);
#endif    
    
    scanf("%s", a); n = strlen(a);
    scanf("%s", b); m = strlen(b);
    
    case1::main();
    case2::main();
    case3::main();
    case4::main();
}

 

@Author: YouSiki