Luogu4022 CTSC2012 熟悉的文章 广义SAM、二分答案、单调队列

传送门

---

先将所有模板串扔进广义SAM。发现作文的\(L0\)具有单调性，即\(L0\)更小不会影响答案，所以二分答案。

假设当前二分的值为\(mid\)，将当前的作文放到广义SAM上匹配。

设对于第\(1-i\)个字符来说，最少的失配字符数为\(dp_i\)，那么\(dp_i = dp_{i-1} + 1\)，且如果当前匹配长度\(len \geq mid\)，还有转移\(dp_i = \min\limits_{j=i-len}^{i-mid} dp_j\)。发现在\(i\)增大的过程中\(i-len\)单调不减，因为\(i\)增大\(1\)，\(len\)也最多增大\(1\)。这类似于滑动窗口问题，可以单调队列优化转移，做到复杂度\(O(LlogL)\)。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<cctype>
#include<algorithm>
#include<cstring>
#include<iomanip>
#include<queue>
//This code is written by Itst
using namespace std;

const int MAXN = 2.2e6 + 7;
namespace SAM{
    int Lst[MAXN] , Sst[MAXN] , fa[MAXN] , trans[MAXN][2];
    int cnt = 1 , L;

    int insert(int p , int len , int x){
        int t = ++cnt;
		Lst[t] = len;
        while(p && !trans[p][x]){
            trans[p][x] = t;
            p = fa[p];
        }
        if(!p){
            Sst[t] = fa[t] = 1;
            return t;
        }
        int q = trans[p][x];
        Sst[t] = Lst[p] + 2;
        if(Lst[q] == Lst[p] + 1){
            fa[t] = q;
            return t;
        }
        int k = ++cnt;
        memcpy(trans[k] , trans[q] , sizeof(trans[k]));
        Lst[k] = Lst[p] + 1;
        Sst[k] = Sst[q];
        Sst[q] = Lst[p] + 2;
        fa[k] = fa[q];
        fa[q] = fa[t] = k;
        while(trans[p][x] == q){
            trans[p][x] = k;
            p = fa[p];
        }
		return t;
    }
};
char s[MAXN >> 1];
int ch[MAXN >> 1][2] , dep[MAXN >> 1] , ind[MAXN >> 1];
int N , M , L , cnt = 1;

void insert(){
	scanf("%s" , s + 1);
	L = strlen(s + 1);
	int cur = 1;
	for(int i = 1 ; i <= L ; ++i){
		if(!ch[cur][s[i] - '0']){
			ch[cur][s[i] - '0'] = ++cnt;
			dep[cnt] = dep[cur] + 1;
		}
		cur = ch[cur][s[i] - '0'];
	}
}

void build(){
	queue < int > q;
	q.push(ind[1] = 1);
	while(!q.empty()){
		int x = q.front();
		q.pop();
		for(int i = 0 ; i < 2 ; ++i)
			if(ch[x][i]){
				ind[ch[x][i]] = SAM::insert(ind[x] , dep[ch[x][i]] , i);
				q.push(ch[x][i]);
			}
	}
}

deque < int > q;
int dp[MAXN >> 1];
bool check(int mid){
	q.clear();
	int u = 1 , len = 0;
	for(int i = 1 ; i <= L ; ++i){
		dp[i] = dp[i - 1] + 1;
		if(SAM::trans[u][s[i] - '0']){
			u = SAM::trans[u][s[i] - '0'];
			++len;
		}
		else{
			while(u && !SAM::trans[u][s[i] - '0'])
				u = SAM::fa[u];
			!u ? (u = 1 , len = 0) : (len = SAM::Lst[u] + 1 , u = SAM::trans[u][s[i] - '0']);
		}
		while(!q.empty() && q.front() < i - len)
			q.pop_front();
		if(len >= mid){
			while(!q.empty() && dp[q.back()] >= dp[i - mid])
				q.pop_back();
			q.push_back(i - mid);
		}
		if(!q.empty())
			dp[i] = min(dp[i] , dp[q.front()]);
	}
	return dp[L] <= 0.1 * L;
}

int main(){
    #ifndef ONLINE_JUDGE
    freopen("in" , "r" , stdin);
    //freopen("out" , "w" , stdout);
    #endif
	cin >> N >> M;
	for(int i = 1 ; i <= M ; ++i)
		insert();
	build();
	for(int i = 1 ; i <= N ; ++i){
		scanf("%s" , s + 1);
		L = strlen(s + 1);
		int l = 0 , r = L;
		while(l < r){
			int mid = (l + r + 1) >> 1;
			check(mid) ? l = mid : r = mid - 1;
		}
		cout << l << endl;
	}
    return 0;
}