[CF932G]Palindrome Partition

题目

传送门 to luogu

思路

可以看看 $\mathtt{y}\mathtt{y}\mathtt{b}$ 大佬的博客。如果你直接觉得 “ 没问题！简单！” 那就不用看这篇博客了 😉

第一步，令 $S^{\prime }=S_1{S}_n{S}_2{S}_{n-1}{S}_3{S}_{n-2}\dots S_{\frac{n}{2}}{S}_{\frac{n}{2}+1}$ ，那么问题转化为，将 $S^{\prime }$ 划分为若干个偶数长度的回文串。这个构造请自己手推。

用 $f(x)$ 表示长度为 $x$ 的前缀的划分方案数。建立回文自动机之后，不难想到 $\mathcal{O}(n^2)$ 的暴力跳 $fail$ 的转移。为了让 “ 偶数长度 ” 这个奇怪的限制滚蛋，直接令 $f(2x+1)=0$ 就可以无差别转移了。

第二步，由于转移只是单纯的 $\sum f$ ，可以考虑用 $g$ 存储一段 $dif(x)=len(x)-len(fail)$ 相等的点。

然而，这一步有问题了！那就是，$g$ 到底代表哪些 $f$ 的和？因为字符串的右端点是在改变的！

我的理解是，事实上 $g(x)={\sum }_{k}f[\omega -1+kdif(x)]$ ，其中 $\omega$ 是该字符串 最后一次出现 的左端点位置。而 $k$ 的范围是什么呢？当然是 “ $dif$ 等值链 ” 的长度。

此时重新考虑这个问题。加入一个字符，会影响哪些 $g$ 的值呢？也就是 $\omega$ 什么时候会变？显然是后缀。那么我们只要把新点 $fail$ 链上的 $g$ 更新了即可！

好，我们继续。怎么转移 $g$ 呢？考虑 $fail(x)$ 的 $g$ 是哪些 $f$ 。众所周知，对于一个回文自动机，新产生的后缀串 $Str(fail(x))$ ，如果长度不小于 $\frac{len(x)}{2}$ ，其最后一次出现恰好是将其用 $Str(x)$ 翻转后的结果！

这个东西挺好证。首先，用 $Str(x)$ 将其翻转后结果必然是一次出现。其次，如果它有更靠后的出现，那么这两个串取并也是一个回文串，与 $fail(x)$ 是最长的回文后缀冲突。

要不咱还是画个图？虽然是用代码块的像素风。

Str(x):                   ------xxxxxxxxxx
Str(fail):                ---------xxxxxxx
REVERSE, Str(fail):       ------xxxxxxx---
if Str(fail):             -------xxxxxxx--
then Str(?):              -------xxxxxxxxx

不难验证，上图中的 $Str(?)$ 是一个回文串，它是由别的 $Str(fail)$（我们假设的一个，在 if 语句中的）和后缀 $Str(fail)$ 拼接而成的。如果它真的存在，它肯定会成为 $fail$ ，因为它更长。

既然这个结论成立，那么我们的更新就可以变的骚一点。先记 $g(x)$ 恰好管不着的那个点为 $top(x)$（确实很像链剖分）。如果 $top(x)=fail(x)$ ，直接更新即可（因为此时 $g$ 只能管自己的值）。否则，$dif(x)<\frac{len(x)}{2}$ ，毕竟 $dif[fail(x)]=dif(x)$ 嘛，跳两下父节点的话，长度要变小 $2dif(x)$ 的。

于是，$len[fail(x)]>\frac{len(x)}{2}$ ，恰好满足我们上面的结论触发条件。所以 $fail(x)$ 和 $x$ 都满足 $\omega =n-len(x)+1$ 。那么 $g[fail(x)]$ 和 $g(x)$ 的唯一差别就只在于定义式中 $k$ 的范围。显然 $x$ 对应的 $k$ 的范围比 $fail(x)$ 的大 $1$ 。直接加上这个差异点 $f[n-len(top)-dif]$ 即可。

用行中公式写一下：$$g(x)=g[fail(x)]+f[n-len(top)-dif]$$

如果你没有看懂上面这段话！请看 $\mathtt{l}\mathtt{l}\mathtt{s}\mathtt{w}$ 题解中的最后一张图片。
$ExtraExplanation$：为啥差异点是那个玩意儿？因为 $g(x)$ 恰好管不着的位置是 $n-len(top)$ 嘛，往回退一步就是管的到的。

所以，只要 $fail(x)$ 信息正确，就可以求出 $g(x)$ 。这么显然应该不用加粗才对。

可是这样仍然是 $\mathcal{O}(n^2)$ 的，因为整条链的 $g$ 都要被修改……

给出骚操作：每次更新，只更新 “ $dif$ 等值链 ” 的交界处 和当前点（目前的整个串的最长回文后缀）。这样就足以保证正确性。

怎么想到的？不知道。但是正确性容易证明。考虑没有被及时更新的点，其本质是 $dif(x)=dif(so{n}_x)$（虽然并没有 $son$ 这个数组，意会就好），否则就会成为链的交界处。

假设我们正在更新 $g(y)$ 。考虑一下，$g[fail(y)]$ 是不是在我们想要的 $n-dif(y)$ 处更新了呢？不妨用反证法，假设 当初 它没有被更新，因为它被子节点 $x$ 跳了过去，满足 $fail(x)=fail(y)$ 且 $dif(x)=dif[fail(x)]$ 。

首先你要意识到，$dif$ 就是周期，因为 $fail$ 就是 $\mathrm{b}\mathrm{o}\mathrm{r}\mathrm{d}\mathrm{e}\mathrm{r}$ 。有了这一点，你就会意识到 $dif$ 在 $fail$ 链上是单减的（不然周期不会变）。由于我们要更新 $y$ ，所以 $dif(so{n}_y)>dif(y)$ 。

并且，因为 $dif$ 是周期，所以 $Str(x)$ 一定是 $Str[fail(x)]$ 前面加上一个周期（一定是完整的周期）得到的结果。而我们知道，$Str[fail(x)]$ 当初的右端点为 $n-dif(y)$ ，恰好是 $Str(y)$ 去掉从右边开始数的一个周期（尽管可能不是所谓的完整周期，但是确实为一个周期的长度），所以 $Str(x)=Str(y)$ 。

还是 用代码块风格 画一张图。要想到这一点：$fail$ 只跟这个节点本身有关，所以无论右端点怎么变，$fail$ 不变，进而 $dif$ 也不变。因为 $fail(y)$ 的 $dif$ 不变，所以导致它被跳过的 $x$ 也就固定了。

.............. : son(y) (whatever string)
   abababababa : y (dif vary, so it's processed)
     ababababa : fail(y)
       abababa : fail(fail(y)) (just to show dif = 2)
   ababababa   : expected fail(y)
 abababababa   : x, who caused skip on fail(y)
 ababababababa : x∪y, who should be fail(son(y))

显然 $Str(x)$ 和 $Str(y)$ 相交，所以二者的并也是回文串。不难发现这是从 $n-dif(y)-len(y)+1$ 到 $n$ 的。然鹅，$dif(so{n}_y)>dif(y)\Rightarrow len(so{n}_y)>len(y)+dif(y)$ ，所以这个新回文串仍然包含在 $so{n}_y$ 以内。也就是说！在 $Str(so{n}_y)$ 内！有一个比 $fail$ 更长的回文后缀！矛盾！

当然，你会说，如果 $y$ 是当前点而寻求更新呢？不一定满足 $dif(so{n}_y)>dif(y)$ 了吧（因为根本没有子节点）？然而这种情况 $Str(x)=Str(y)$ 是仍然成立的。怎么可能新加入的点代表一个已经存在的字符串呢？

总结：虽然我们的更新不完全，但它足以应付我们需要用到的 $g$ 了。

时间复杂度呢？由于 $dif$ 是 $\mathrm{b}\mathrm{o}\mathrm{r}\mathrm{d}\mathrm{e}\mathrm{r}$ ，所以一定要 $len\le dif$ 时才能切换一个 $dif$ 。这个分析就跟辗转相除一样了：如果 $dif$ 不超过 $\frac{len}{2}$ ，那么余数自然不能超过 $dif$ ；而 $dif$ 超过一半长度时，一步到位。最多跳 $\mathcal{O}(\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 Mod = 1e9+7;
const int MaxN = 1000005;
const int CharSiz = 26;

int f[MaxN], g[MaxN];
namespace PAM{
	int ch[MaxN][CharSiz];
	int fail[MaxN], cntNode = 1;
	char item[MaxN]; int len[MaxN];
	int n = 0, lst = 1, top[MaxN];
	void init(){
		++ cntNode; // include 0
		memset(ch,0,cntNode*CharSiz<<2);
		memset(fail,0,cntNode<<2);
		n = 0, cntNode = lst = 1;
		fail[0] = fail[1] = 1;
		len[1] = item[0] = -1;
	}
	void add(char c){
		item[++ n] = c; int x = lst;
		while(item[n-len[x]-1] != item[n])
			x = fail[x]; // find it
		int now = ch[x][c];
		if(now == 0){
			now = ++ cntNode; // new node
			int &p = fail[now] = fail[x];
			while(item[n-len[p]-1] != item[n])
				p = fail[p]; // find it
			p = ch[p][c]; // add char c
			ch[x][c] = now; // last step
			len[now] = len[x]+2;
			if((len[fail[now]]<<1) ==
			len[now]+len[fail[fail[now]]])
				top[now] = top[fail[now]];
			else top[now] = fail[now];
		}
		lst = now; // update lst
	}
	void solve(){
		int p = lst;
		for(; p&&p!=1; p=top[p]){
			int dif = len[p]-len[fail[p]];
			g[p] = f[n-len[top[p]]-dif];
			if(fail[p] != top[p])
				g[p] = (g[p]+g[fail[p]])%Mod;
			if(!(n&1)) f[n] = (f[n]+g[p])%Mod;
		}
	}
}

char xez[MaxN], tmp[MaxN];
int main(){
	scanf("%s",tmp);
	int zxy = strlen(tmp);
	for(int i=0; (i<<1)<zxy; ++i)
		xez[i<<1] = tmp[i];
	for(int i=0; (i<<1|1)<zxy; ++i)
		xez[i<<1|1] = tmp[zxy-1-i];
	PAM::init(), f[0] = 1;
	for(int i=0; i<zxy; ++i){
		PAM::add(xez[i]-'a');
		PAM::solve();
	}
	printf("%d\n",f[PAM::n]);
	return 0;
}

双倍经验

这道题做法没有任何区别。同样的构造方式。同样的优化方式。