CF1827C Palindrome Partition

CF1827C Palindrome Partition

前言

一个下午和 jimmywang 大力发明未果，写题解以记之。

思路

首先考虑求出以每个位置结尾的不可分割的偶回文串，这样就可以从前往后转移，但如果同一个位置结尾的这样的串有很多，$\text{dp}$ 的复杂度肯定炸。

但其实每个点结尾的不可分割的偶回文串只有一个。

证明：假设以 $x$ 这个位置结尾存在第二短的不可分割的偶回文串。记第一短的不可分割的偶回文串为 $A$，第二短的为 $B$, $A$ 的左端点为 $i$，$B$ 的对称中心的左侧点为 $j$。若 $j<i$，那么 $B$ 形如 $A+C+A$，其中 $C$ 也为偶回文串，与 $B$ 是不可分割的矛盾。若 $j\ge i$，则 $A$ 形如 $D+E+D$，其中 $D$ 与 $E$ 都是偶回文串，与 $A$ 是不可分割的矛盾。故 $B$ 不存在，以 $x$ 结尾的不可分割的偶回文串只有一个，且是以 $x$ 结尾的最短的偶回文串。

可以结合图理解一下：

那么每个点只可能由前面的一个点转移过来，$\text{dp}$ 的复杂度是 $O(n)$ 的。

只需要在合适的复杂度里找出以每个点为结尾的最短偶回文串即可。

众所周知，$\text{Manachar}$ 算法可以在线性时间内求解每个回文中心往外扩展的最长回文串。但我们要求的是最短。所以一个叫做车拉马的算法诞生了

先把所有对称中心以及每个中心当前对应期望回文串长度放进一个 $\text{pair}$ 里入队，依然考虑从每个对称中心往外扩，如果当前期望长度下是回文串且右端点没被标记过，那就标记右端点，并把期望长度加 $2$ 继续入队，否则直接出队。由于每个右端点只能被标记一次，复杂度 $O(n)$。

非常的对啊。

被轻松 $\text{Hack}$ 了，例如在 $\text{abbbba}$ 中，中间三个 $\text{bb}$ 被标记完后就扩不到整个串了。

既然线性做不到，舍弃一点复杂度，多个 $\log$ 也没事嘛。

把所有右端点扔进一个 $\text{set}$ 里，表示未被标记的右端点的集合，每次入队前用 $\text{upper\_bound}$ 找到后面第一个没被标记右端点。

与之前不同的是，如果一个对称中心从队中取出，其原本期望长度对应的串是否为回文串用 $\text{Hash}$ 判断。若不是则直接出队，否则当前右端点没被标记过就标记，并找到下一个右端点继续入队。

但写完以后又挂了，$\text{Hack}$ 是 $\text{abbbbaabbbba}$。对，又是它。答案是 $24$，但输出是 $23$。原因是一个中心往下跳很远找到下一个右端点，并且赶在离那个右端点较近的中心之前把它标记了，就gg了。（上面这个串中最后一个 $\text{a}$ 匹配了第一个 $\text{a}$）

一个普通队列倒下了，就有千万个优先队列站起来

按期望的回文串长度丢进优先队列（小根堆），复杂度 $O(n\log n)$。

真的吗？这个过程唯一的问题在于这一步：

否则当前右端点没被标记过就标记，并找到下一个右端点继续入队

如果一个中心每次出队没有标记任何右端点又被入队，相当于它被虚空入队很多次，是否会使复杂度不是 $O(n\log n)$ 呢？

暂时还不太会证，但是能过，只能感性理解所有中心一轮出入队必然能标记一些右端点，出队时期望右端点已被标记的情况数不会很多。

因为复杂度证不出来，jimmywang 觉得没有前途，改造了原版 $\text{Manachar}$，严格 $O(n\log n)$。

后来发现 jimmywang 的方法在题解区有用链表实现 $O(n)$ 的。

Code

点击查看代码

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mpr make_pair
const ll SIZE = 500005;
const ll mod = 180181327;
ll T, n;
char ch[SIZE];
ll las[SIZE];
ll dp[SIZE];
ll sum[SIZE], sum1[SIZE];
ll pp[SIZE];
 
inline ll rd(){
	ll x = 0, f = 1;
	char ch = getchar();
	while(ch < '0' || ch > '9'){
		if(ch == '-') f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9'){
		x = (x<<1) + (x<<3) + (ch^48);
		ch = getchar();
	}
	return x*f;
}
 
ll power(ll x, ll y){
	ll jl = 1;
	while(y){
		if(y & 1) jl = (jl * x) % mod;
		x = (x * x) % mod;
		y >>= 1;
	}
	return jl;
}
 
bool check(ll l, ll r){
	if(l < 1 || r > n) return false;
	if(l % 2 == r % 2) return false;
	ll mid = (l + r) / 2;
	ll x = (sum[mid] - ((sum[l-1] * pp[mid-l+1]) % mod) + mod) % mod;
	ll y = (sum1[mid+1] - ((sum1[r+1] * pp[mid-l+1]) % mod) + mod) % mod;
	return (x==y);
}
 
int main(){
	T = rd(); priority_queue<pair<ll, ll> > q; set<ll> s;
	pp[0] = 1;
	for(ll i = 1; i <= 500000; i++) pp[i] = (pp[i-1] * 26) % mod; 
	while(T--){
		n = rd(); cin >> ch+1;
		sum[0] = sum1[n+1] = 0; 
		s.clear();
		for(ll i = 1; i <= n; i++){
			sum[i] = ((sum[i-1] * 26) % mod + ch[i] - 'a') % mod;
		}
		for(ll i = n; i >= 1; i--){
			sum1[i] = ((sum1[i+1] * 26) % mod + ch[i] - 'a') % mod;
		}
		for(ll i = 1; i <= n; i++) las[i] = -1, s.insert(i);
		for(ll i = 1; i <= n; i++) q.push(mpr(-1, i));
		while(q.size()){
			ll x = q.top().second, len = -q.top().first; q.pop();
			if(x-len+1 < 1 || x+len > n) continue;
			if(ch[x-len+1] != ch[x+len]) continue;
			if(las[x+len] == -1){
				las[x+len] = x-len;
				s.erase(x+len);
			}
			if(s.upper_bound(x) != s.end()){
				ll jl = *s.upper_bound(x);
				if(check(x-(jl-x)+1, jl)) q.push(mpr(-(jl-x), x));
			}
		}
		ll ans = 0;
		for(ll i = 1; i <= n; i++){
			if(las[i] != -1){
				dp[i] = dp[las[i]] + 1, ans += dp[i];		
			}
			else dp[i] = 0;
		}
		printf("%lld\n", ans);
	}
	return 0;
}