[BZOJ1212] [HNOI2004]L语言

Description

标点符号的出现晚于文字的出现，所以以前的语言都是没有标点的。现在你要处理的就是一段没有标点的文章。一段文章T是由若干小写字母构成。一个单词W也是由若干小写字母构成。一个字典D是若干个单词的集合。我们称一段文章T在某个字典D下是可以被理解的，是指如果文章T可以被分成若干部分，且每一个部分都是字典D中的单词。例如字典D中包括单词{‘is’, ‘name’, ‘what’, ‘your’}，则文章‘whatisyourname’是在字典D下可以被理解的因为它可以分成4个单词：‘what’, ‘is’, ‘your’, ‘name’，且每个单词都属于字典D，而文章‘whatisyouname’ 在字典D下不能被理解，但可以在字典D’=D+{‘you’}下被理解。这段文章的一个前缀‘whatis’，也可以在字典D下被理解而且是在字典D下能够被理解的最长的前缀。给定一个字典D，你的程序需要判断若干段文章在字典D下是否能够被理解。并给出其在字典D下能够被理解的最长前缀的位置。

Input

输入文件第一行是两个正整数n和m，表示字典D中有n个单词，且有m段文章需要被处理。之后的n行每行描述一个单词，再之后的m行每行描述一段文章。其中1<=n, m<=20，每个单词长度不超过10，每段文章长度不超过1M。

Output

对于输入的每一段文章，你需要输出这段文章在字典D可以被理解的最长前缀的位置。

Sample Input

4 3
is
name
what
your
whatisyourname
whatisyouname
whaisyourname

Sample Output

14
6
0 整段文章’whatisyourname’都能被理解
前缀’whatis’能够被理解
没有任何前缀能够被理解

设$f[i]$表示文章前i个字符是否可以被理解，那么$\large f[i] |= f[j]$，当且仅当$S[j+1...i]$是字典中的一个字串。

那么这个过程可以用哈希来实现，总复杂度$\large O(MN|S|)$。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
using namespace std;
#define reg register

int n, m;
char st1[25][25];
char str[25000005];
unsigned long long hsh[25], power[25], hah[25000005];
int f[25000005];

int main()
{
    scanf("%d%d", &n, &m);
    for (reg int i = 1 ; i <= n ; i ++)
    {
        scanf("%s", st1[i] + 1);
        int len = strlen(st1[i] + 1);
        for (reg int j = 1 ; j <= len ; j ++) hsh[i] = hsh[i] * 27 + st1[i][j] - 'a';
    }
    power[0] = 1;
    for (reg int i = 1 ; i <= 20 ; i ++) power[i] = power[i - 1] * 27;
    while(m--)
    {
        memset(f, 0, sizeof f);
        f[0] = 1;
        scanf("%s", str + 1);
        int len = strlen(str + 1);
        hah[0] = 0;
        for (reg int i = 1 ; i <= len ; i ++) hah[i] = hah[i - 1] * 27 + str[i] - 'a';
        for (reg int i = 1 ; i <= len ; i ++)
        {
            for (reg int j = 1 ; j <= n ; j ++)
            {
                int L = strlen(st1[j] + 1);
                if (hah[i] - hah[i - L] * power[L] == hsh[j]) {
                    f[i] |= f[i - L];
                }
            }
        }
        for (reg int i = len ; i >= 0 ; i --)
            if (f[i]) {printf("%d\n", i);break;}
    }
    return 0;
}

hash

在Luogu上足以通过此题，但是bzoj会卡死，我们需要一个更加优越的算法。

观察到其实我们在判断是否出现过这个字串的时候直接在AC自动机上匹配就行了。

可以把时间复杂度降低到$\large O(M|S|)$，可以再Bzoj上通过。

#include <bits/stdc++.h>
using namespace std;
#define reg register
 
int n, m;
char str[2500005];
int ch[4005][27], fail[4005], Le[4005], End[4005], tot;
bool f[2500005];
 
inline void Ins(char *s) {
    int len = strlen(s + 1);
    int now = 0;
    for (reg int i = 1 ; i <= len ; i ++)
    {
        if (!ch[now][s[i] - 'a']) ch[now][s[i] - 'a'] = ++tot;
        now = ch[now][s[i] - 'a'];
    }
    End[now] = 1, Le[now] = len;
}
 
inline void AC_Build() {
    queue <int> q;
    for (reg int i = 0 ; i <= 26 ; i ++) if (ch[0][i]) q.push(ch[0][i]);
    while(!q.empty()) {
        int x = q.front();
        q.pop();
        for (reg int i = 0 ; i <= 26 ; i ++) {
            if (ch[x][i]) fail[ch[x][i]] = ch[fail[x]][i], q.push(ch[x][i]);
            else ch[x][i] = ch[fail[x]][i];
        }
        End[x] |= End[fail[x]];
    }
}
 
inline void AC_Match(char *s) {
    int len = strlen(s + 1);
    int now = 0;
    for (reg int i = 1 ; i <= len ; i ++)
    {
        now = ch[now][s[i] - 'a'];
        for (int j = now ; j ; j = fail[j])
            if (End[j]) f[i] |= f[i - Le[j]];
    }
}
 
 
int main() {
    scanf("%d%d", &n, &m);
    for (reg int i = 1 ; i <= n ; i ++) {
        scanf("%s", str + 1);
        Ins(str);
    }
    AC_Build();
    while(m--) {
        scanf("%s", str + 1);
        memset(f, 0, sizeof f);
        f[0] = 1;
        AC_Match(str);
        int len = strlen(str + 1);
        for (reg int i = len ; i >= 0 ; i --)
            if (f[i]) {printf("%d\n", i);break;}
    }
    return 0;
}