[CF1063F]String Journey

题目

传送门 to CF

传送门 to luogu

题意概要
选出字符串的 $k$ 个不相交子串，使得后一个是前一个的子串。前后关系即原串中位置的先后关系。输出可能的最大 $k$ 值。

数据范围与提示
字符串长度 $|S|\le 5\times 10^5$ 。

思路

我真是太弱了……什么也发现不了……

首先，我们容易证明，选出的字符串长度依次是 $k,k-1,k-2,\dots ,1$ 。原因很简单：挑选下一个时，当然是选择长的好，因为长的具有更多可能性（完全没有在开车）；如果选不到，那你有这么长有什么用？不如 割断一点 选择一个更短的，方便前面的人。

或者，就利用本题的核心元素 调整法 来解释。当 $s_k⫌s_{k-1}⫌s_{k-2}$ 时，完全可以取 $|s_{k-1}|=|s_{k-2}|+1$ 而不会影响这个链条。

发现了这个之后，你就会发现 $k\le \sqrt{n}$，于是我们有了一个优秀的 $\mathcal{O}(n^{\frac{3}{2}}\log n)$ 做法。为什么大佬还会 $\mathcal{O}(n\sqrt{n})$ 的做法呢？因为他们把字符串的哈希值又拿去哈希了……

看来只知道这个不够。我们再找找别的性质。你可能会这样思考这个问题：只要 $s_j$ 在 $s_i(k\ge i\ge j)$ 中都出现过就行。那么你会发现，不要 $s_1$ 之后，剩下的仍然满足这个条件。形式化地说，如果存在一个 $s_k,s_{k-1},\dots ,s_1$ 满足 $s_k$ 的左端点是 $L$，那么存在一个 $s_{k-1},s_{k-2},\dots ,s_1$ 使得 $s_{k-1}$ 的左端点是 $L$ 。

其实这个玩意儿就是上面的结论的延伸。去掉 $s_1$ 之后，得到了一个长度为 $k-1$ 的选择方案。而上面说过了，总存在 $|s_i|=i$ 的方案。如果你还是不放心，就直接用调整法：每个 $s_i$ 都删除最后一个字符。

对于每个 $i$ 只需要求后缀 $i$ 中的最大答案，用 $f(i)$ 表示。可以二分后利用后缀数组解决。这就是 $\mathcal{O}(n{\log }^{2}n)$ 的了。

然后我们 不难发现 这样一个结论：
$$f(i)\le f(i+1)+1$$

这是为啥呢？还是调整法。前面我们有了把 $s_i$ 删除最后一个字符，我们现在把所有 $s_i$ 都删掉第一个字符。容易发现，我们得到了一个 $L+1$ 开头的、$k-1$ 长度的方案。所以 $f(L+1)\ge f(L)-1$ 是毋庸置疑的。

有了这个结论，就可以从后往前依次求出 $f$ 了。即，每次直接查询 $f(i)$ 是否是合理的，如果不是，则减一。显然只能减 $n$ 次。我们可以 $\mathcal{O}(\log n)$ 找到一个 $\mathrm{r}\mathrm{n}\mathrm{k}$ 的范围，使得 $\mathrm{l}\mathrm{c}\mathrm{p}\ge f(i)-1$，相当于查询是否存在 $j$ 使得

• ${\mathrm{r}\mathrm{n}\mathrm{k}}_j\in [L,R]$
• $j\ge i+f(i)$
• $f(j)\ge f(i)-1$

主席树解决了它！复杂度 $\mathcal{O}(n\log n)$ 。

代码

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
inline int readint(){
	int a = 0; char c = getchar(), f = 1;
	for(; c<'0'||c>'9'; c=getchar())
		if(c == '-') f = -f;
	for(; '0'<=c&&c<='9'; c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}

const int MaxN = 500005;
int sa[MaxN], tmp[MaxN<<1], n;
int rnk[MaxN<<1], buc[MaxN];
void collect(int m){
	memset(buc,0,m<<2);
	for(int i=0; i!=n; ++i)
		++ buc[rnk[i]];
	for(int i=1; i!=m; ++i)
		buc[i] += buc[i-1];
}
void getSA(int a[]){
	memcpy(rnk,a,n<<2);
	memset(tmp+n,-1,n<<2);
	int m = max(n+1,255); collect(m);
	for(int i=0; i!=n; ++i)
		sa[--buc[rnk[i]]] = i;
	for(int w=1,p=0; m!=n; w<<=1,m=p,p=0){
		for(int i=n-w; i!=n; ++i) tmp[p ++] = i;
		for(int i=0; i!=n; ++i) if(sa[i] >= w)
			tmp[p ++] = sa[i]-w;
		collect(m); for(int i=n-1; ~i; --i)
			sa[--buc[rnk[tmp[i]]]] = tmp[i];
		memcpy(tmp,rnk,n<<2);
		rnk[sa[0]] = 0, p = 1;
		for(int i=1; i!=n; ++i)
			if(tmp[sa[i]] != tmp[sa[i-1]] ||
			tmp[sa[i]+w] != tmp[sa[i-1]+w])
				rnk[sa[i]] = p ++;
			else rnk[sa[i]] = p-1;
	}
}

int heit[MaxN];
void getHeit(int a[]){
	for(int i=0,j,k=0; i!=n; ++i){
		if(k) -- k; if(!rnk[i]) continue;
		j = sa[rnk[i]-1];
		while(i+k < n && j+k < n
		&& a[i+k] == a[j+k]) ++ k;
		heit[rnk[i]] = k;
	}
}

namespace RMQ{
	int st[21][MaxN], logtwo[MaxN];
	void build(){
		logtwo[0] = heit[0] = -2;
		for(int i=0; i!=n; ++i){
			st[0][i] = heit[i];
			logtwo[i] = logtwo[i>>1]+1;
		}
		for(int j=0; (2<<j)<=n; ++j)
		for(int i=0; i+(2<<j)<=n; ++i)
			st[j+1][i] = min(st[j][i],st[j][i+(1<<j)]);
	}
	int findL(int x,int v){
		for(int j=20; ~j; --j)
			if(x-(1<<j)+1 >= 0 && st[j][x-(1<<j)+1] >= v)
				x = x-(1<<j); // (x,x_0]
		return x+1;
	}
	int findR(int x,int v){
		++ x; // heit do not include x
		for(int j=20; ~j; --j)
			if(x+(1<<j) <= n && st[j][x] >= v)
				x = x+(1<<j); // [x_0,x)
		return x-1;
	}
}

namespace SgTree{
	const int MaxM = 30000000;
	int rt[MaxN], cntNode, son[MaxM][2];
	int v[MaxM]; // maximum of range 
	# define LSON son[o][0],l,(l+r)>>1
	# define RSON son[o][1],((l+r)>>1)+1,r
	void modify(int id,int qv,int ori,int &o,int l=0,int r=n-1){
		o = ++ cntNode; // new node
		if(l == r) return void(v[o] = max(v[ori],qv));
		if(id <= ((l+r)>>1)){
			son[o][1] = son[ori][1];
			modify(id,qv,son[ori][0],LSON);
		}
		else{
			son[o][0] = son[ori][0];
			modify(id,qv,son[ori][1],RSON);
		}
		v[o] = max(v[son[o][0]],v[son[o][1]]);
	}
	int query(int ql,int qr,int o,int l=0,int r=n-1){
		if(!o || qr < l || r < ql) return 0;
		if(ql <= l && r <= qr) return v[o];
		return max(query(ql,qr,LSON),query(ql,qr,RSON));
	}
	void insert(int id,int x,int qv){
		modify(x,qv,rt[id+1],rt[id]);
	}
	int check(int id,int ql,int qr){
		return query(ql,qr,rt[id]);
	}
}

char str[MaxN]; int xyx[MaxN];
int main(){
	 n = readint(); scanf("%s",str);
	for(int i=0; i!=n; ++i)
		xyx[i] = str[i]-'a'+1;
	getSA(xyx), getHeit(xyx);
	RMQ::build(); int ans = 0;
	for(int i=n-1,f=0; ~i; --i){
		for(++f; f>=2; --f){
			int L = RMQ::findL(rnk[i],f-1)-1;
			int R = RMQ::findR(rnk[i],f-1);
			if(SgTree::check(i+f,L,R) >= f-1)
				break; // acceptable
			L = RMQ::findL(rnk[i+1],f-1)-1;
			R = RMQ::findR(rnk[i+1],f-1);
			if(SgTree::check(i+f,L,R) >= f-1)
				break; // [i+1,i+f)
		}
		SgTree::insert(i,rnk[i],f);
		if(ans < f) ans = f;
	}
	printf("%d\n",ans);
	return 0;
}

吐槽

明明题解上 $\mathcal{O}(n{\log }^{2}n)$ 都过不了，结果 $\mathtt{s}\mathtt{t}\mathtt{d}$ 太慢导致时限开了 $4\mathrm{s}$，然后 $\mathcal{O}(n\sqrt{n})$ 都起飞了……