bzoj 3145 - [Feyat cup 1.5]Str

Description

给你两个长度$10^5$级别的串$S, T$

求$S,T$的最长模糊匹配公共子串

模糊匹配 : 至多一个位置上的字符不同

Analysis

屯了好久的题, 之前看过3次都看不懂, 一直觉得这道题非常恐怖

现在重新翻出来看很快就有思路了, 也不是很恐怖嘛 (写了一个下午系列)

定义模糊点 : 位置不同的字符

情况1. 模糊点均在两串的中间部分

那么我们可以分为${A + * + B}$ , 其中$*$为模糊点

一个想法是对$S$建自动机, 然后从左往右扫$T$串, 在$S$中得到$A$部分的最大匹配的状态

然后那个状态有个$right$集, $right + 2$就是$B$部分的开头

我们用后缀数组来匹配$B$部分, 根据贪心, rk一定会是相邻的

我们在$SAM$(前缀逆序树)上维护两棵平衡树 , 一颗存出现在$S$串中的那些rk, 一颗存$T$的, 启发式合并的时候两两找相邻点在$SA$里求$LCP$

后来想了以下发现不行, 我这样$A$部分相当于贪心的找了最长的, 但是有可能该状态往上跳几下得到一对更优的$B$呢

我们发现$S,T$建广义自动机, 这样每个状态对应了一种长度的$A$部分公共子串

然后照样做就好了

Claris的方法是用反串的后缀数组替代广义自动机, 然后枚举公共$A$部分长度, 在rk上合并相邻$lcp >= len$的点

并查集 + 启发式合并

情况2. 至少一个模糊点在串头/串尾

在实现过程中特判处理即可

串头的用后缀数组匹配

串尾的用前缀逆序树匹配

Code

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cctype>

#include <cmath>

#include <algorithm>

#include <set>

#define rep(i,a,b) for (int i = (a); i <= (b); ++ i )

#define per(i,a,b) for (int i = (a); i >= (b); -- i )

#define For(i,a,b) for (int i = (a); i < (b); ++ i )

#define fore(i,a) for (its it = (a).begin(); it != (a).end(); ++ it )

using namespace std;

const int M = 2e5 + 7;

const int INF = 1e9 + 7;

char s[M], t[M];

int ls, lt;

int ans = 1;

namespace SA{

	static const int N = M << 1;

	char s[N]; int n, mid;

	int sa[N], t[N];

	int rk[N], f[N];

	int st[N][20], ln[N];

	int h[N];

	void getsa(){

		static int sum[M];

		int p, nw, i, j;

		for (i=1; i<=n; ++i) sum[s[i]]++;

		for (i=0; i<=255; ++i) sum[i] += sum[i-1];

		for (i=1; i<=n; ++i) sa[sum[s[i]]--] = i;

		for (p=0, i=1; i<=n; ++i) rk[sa[i]] = (p += (s[sa[i]] != s[sa[i-1]]));

		for (nw=p, j=1; nw!=n; j<<=1, nw=p) {

			memset(sum, 0, (1+nw)<<2);

			memcpy(f, rk, sizeof rk);

			for (p=0, i=n-j+1; i<=n; ++i) t[++p] = i;

			for (i=1; i<=n; ++i) if (sa[i] > j) t[++p] = sa[i] - j;

			for (i=1; i<=n; ++i) sum[f[i]]++;

			for (i=1; i<=nw; ++i) sum[i] += sum[i-1];

			for (i=n; i>=1; --i) sa[sum[f[t[i]]]--] = t[i];

			for (p=0, i=1; i<=n; ++i) rk[sa[i]] = (p += (f[sa[i]] != f[sa[i-1]] || f[sa[i]+j] != f[sa[i-1]+j]));

		}

	}

	void geth(){

		int i, j, p;

		for (p=0, i=1; i<=n; ++i){

			j = sa[rk[i]-1];

			for (; s[i+p] == s[j+p]; ++p);

			h[rk[i]] = p;

			if (p > 0) --p;

		}

	}

	void init(){

		rep (i, 1, n) st[i][0] = h[i];

		int i; for (ln[0]=ln[1]=0, i=2; i<=n; ++i) ln[i] = ln[i>>1] + 1;

		per (i, n, 1)

		rep (j, 1, ln[n-i+1])

			st[i][j] = min(st[i][j-1], st[i + (1 << j-1)][j-1]);

	}

	inline int LCP(int x, int y){

		if (x == y) return n-y+1;

		if (x > y) swap(x, y);

		++x; int l = ln[y-x+1];

		return min(st[x][l], st[y - (1 << l) + 1][l]);

	}

	void build(char *a, char *b, int la, int lb){

		n = 0;

		rep (i, 1, la) s[++n] = a[i];

		s[mid = ++n] = '+';

		rep (i, 1, lb) s[++n] = b[i];

		getsa();

		geth();

		init();

	}

}

namespace Set{

	static const int N = M << 1;

	int ans[N];

	int rt[2][N];

	set<int> s[2][N];

	typedef set<int> :: iterator its;

	int find(int x, int k, int p){

		int res = -1;

		its rt = s[k][x].upper_bound(p);

		if (rt != s[k][x].end())

			res = max(res, SA::LCP(*rt, p));

		if (rt != s[k][x].begin())

			res = max(res, SA::LCP(*(--rt), p));

		return res;

	}

	void ins(int x, int k, int p){

		ans[x] = max(ans[x], find(x, k^1, p));

		s[k][x].insert(p);

	}

	void merge(int &x, int y, int k){

		if (s[k][x].size() < s[k][y].size()) {

			fore (it, s[k][x]) s[k][y].insert(*it);

			x = y;

		}

		else

			fore (it, s[k][y]) s[k][x].insert(*it);

	}

	int upd(int x, int y, int kx, int ky){

		int res = -1;

		if (s[kx][x].size() < s[ky][y].size())

			fore (it, s[kx][x]) res = max(res, find(y, ky, *it));

		else

			fore (it, s[ky][y]) res = max(res, find(x, kx, *it));

		return res;

	}

	void Merge(int x, int y){

		rep (i, 0, 1) ans[x] = max(ans[x], upd(rt[i][x], rt[i^1][y], i, i^1));

		rep (i, 0, 1) merge(rt[i][x], rt[i][y], i);

		ans[x] = max(ans[x], ans[y]);

	}

}

namespace SAM{

	static const int N = M << 1;

	int last, tot;

	int ch[N][26];

	int stp[N], fa[N];

	int rt[2][N], ed[2];

	inline int newnode(int l){

		stp[++tot] = l;

		rt[0][tot] = rt[1][tot] = INF;

		return tot;

	}

	int ext(int p, int q, int c){

		int nq = newnode(stp[p] + 1);

		fa[nq] = fa[q], fa[q] = nq;

		memcpy(ch[nq], ch[q], sizeof ch[q]);

		for (; p && ch[p][c] == q; p = fa[p]) ch[p][c] = nq;

		return nq;

	}

	int sam(int p, int c){

		int np = ch[p][c];

		if (np) return (stp[p] + 1 == stp[np]) ? np : ext(p, np, c);

		np = newnode(stp[p] + 1);

		for (; p && ch[p][c] == 0; p = fa[p]) ch[p][c] =np;

		if (!p) fa[np] = 1;

		else {

			int q = ch[p][c];

			fa[np] = (stp[p] + 1 == stp[q]) ? q : ext(p, q, c);

		}

		return np;

	}

	void trans(int &p, int c, int &len){

		if (!ch[p][c]) {

			for (; p && ch[p][c] == 0; p = fa[p]);

			len = stp[p];

		}

		if (ch[p][c]) p = ch[p][c], ++len;

		else p = 1, len = 0;

	}

	void build(char *a, char *b, int la, int lb){

		last = tot = 1;

		rep (i, 1, la)

			rt[0][ last = sam(last, a[i]-'a') ] = i;

		last = 1;

		rep (i, 1, lb)

			rt[1][ last = sam(last, b[i]-'a') ] = la + 1 + i;

		ed[0] = la, ed[1] = la + 1 + lb;

		rt[0][1] = 0;

		rt[1][1] = la + 1;

	}

	void topu(){

		static int sum[N], pid[N];

		rep (i, 1, tot) sum[stp[i]]++;

		rep (i, 1, tot) sum[i] += sum[i-1];

		rep (i, 1, tot) pid[sum[stp[i]]--] = i;

		rep (i, 1, tot) rep (j, 0, 1) {

			Set::rt[j][i] = i;

			Set::ans[i] = -1;

			if (rt[j][i] != INF && rt[j][i]+2 <= ed[j])

				Set::ins(i, j, SA::rk[rt[j][i] + 2]);

		}

		per (i, tot, 1) {

			int x = pid[i];

			if (rt[0][x] != INF && rt[1][x] != INF)

				ans = max(ans, stp[x] + 1 + Set::ans[x]),

				ans = max(ans, stp[x] + (rt[0][x] < ed[0] && rt[1][x] < ed[1]) );

			if (x != 1){

				rep (j, 0, 1)

					rt[j][fa[x]] = min(rt[j][fa[x]], rt[j][x]);

				Set::Merge(fa[x], x);

			}

		}

	}

}

int main(){

#ifndef ONLINE_JUDGE

	freopen("a.in", "r", stdin);

#endif

	int i;

	scanf("%s", s+1); ls = strlen(s+1);

	scanf("%s", t+1); lt = strlen(t+1);

	SAM::build(s, t, ls, lt);

	SA::build(s, t, ls, lt);

	SAM::topu();

	printf("%d\n", ans);

	return 0;

}