CF 932G 回文树

关于log个border的dp,把等差数列的border的贡献和记录在最长的回文节点上。
 

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
const int maxn=1000007;
char str[maxn];

struct PAM{
	int next[maxn][26];
	int fail[maxn];
	int cnt[maxn];
	int num[maxn];
	int len[maxn];
	int S[maxn];
	ll dp[maxn];
	int dif[maxn];
	int anc[maxn];
	ll sum[maxn];//等差数列的border贡献和,记录在最长的回文节点上
	int last,n,sz;
	int newnode(int l){
		for(int i=0;i<26;i++){
			next[sz][i]=0;
		}
		cnt[sz]=0;
		len[sz]=l;
		return sz++;
	}
	void init(){
		sz=0;
		newnode(0);
		newnode(-1);
		last=0;
		n=0;
		S[n]=-1;
		fail[0]=1;
		dp[0]=1;
	}
	int getfail(int x){
		while(S[n-len[x]-1]!=S[n])x=fail[x];
		return x;
	}
	void insert(char ch){
		int c=ch-'a';
		S[++n]=c;
		int u=getfail(last);
		if(!next[u][c]){
			int v=newnode(len[u]+2);
			fail[v]=next[getfail(fail[u])][c];
			next[u][c]=v;
			num[v]=num[fail[v]]+1;
		}
		last=next[u][c];
		cnt[last]++;
		dif[last]=len[last]-len[fail[last]];
		anc[last]=(dif[last]==dif[fail[last]]?anc[fail[last]]:fail[last]);
		int p=last;
		while(p){
			if(anc[p]==fail[p]){
				sum[p]=dp[n-len[p]];
			}
			else {
				sum[p]=(sum[fail[p]]+dp[n-len[anc[p]]-dif[p]])%mod;
			}
			if(n%2==0)dp[n]=(dp[n]+sum[p])%mod;
			p=anc[p];
		}
	}
	ll count(){
		ll ret=0;
		for(int i=sz-1;i;i--){
			cnt[fail[i]]+=cnt[i];
			ret=(ret+cnt[i])%mod;
		}
		return ret;
	}
}pam;

int main(){
	scanf("%s",str);
	int len=strlen(str);
	pam.init();
	for(int i=1;i<=len/2;i++){
		pam.insert(str[i-1]);
		pam.insert(str[len-i]);
	}
	printf("%lld\n",pam.dp[len]);
}

 

### 回文的概念与实现方法 回文是一种用于高效处理字符串中回文子串的数据结构。它能够在 \(O(N)\) 的时间复杂度内完成对字符串的所有本质不同回文子串的查找,并记录它们出现的次数。以下是回文的核心概念和实现方法。 #### 1. 数据结构定义 回文的节点表示一个回文子串,每个节点存储以下信息: - `len`:该节点对应的回文子串的长度。 - `fail`:指向最长的后缀回文子串的节点。 - `next`:用于存储从当前节点通过某个字符扩展得到的新回文子串的指针。 - `cnt`:以该节点对应的回文子串为结尾的本质不同回文子串的数量。 回文通常使用两个特殊的节点初始化: - **节点0**:表示空字符串,其长度为0。 - **节点1**:表示单个字符的回文子串,其长度为-1(虚拟节点)。 #### 2. 核心算法思想 回文的构建基于以下关键点: - 每个回文子串可以由另一个回文子串加上两边相同的字符构成。 - 利用 `fail` 指针快速找到当前回文子串的最长后缀回文子串。 - 在插入新字符时,尝试从当前节点扩展新的回文子串,并更新相关指针。 #### 3. 实现步骤 以下是回文的实现代码示例: ```cpp #include <bits/stdc++.h> using namespace std; struct PalindromeTree { int nodes; // 当前节点数 int last; // 最近添加的节点 int fail; // 失败指针 vector<int> len; // 每个节点对应的回文长度 vector<vector<int>> next; // 节点扩展关系 vector<int> cnt; // 记录每个节点对应回文子串的出现次数 string s; int n; PalindromeTree() : nodes(2), last(0), fail(1), len(2), next(2, vector<int>(26, -1)), cnt(2, 0) { len[0] = 0; len[1] = -1; } void init(string str) { s = str; n = s.size(); for (int i = 0; i < n; ++i) { extend(s[i] - 'a'); } } int getFail(int cur) { while (s[n - 1 - len[cur] - 1] != s[n - 1]) { cur = fail; } return cur; } void extend(int c) { int cur = getFail(last); if (next[cur][c] == -1) { int newNode = nodes++; len.push_back(len[cur] + 2); next.push_back(vector<int>(26, -1)); cnt.push_back(0); int tmp = fail; while (s[n - 1 - len[tmp] - 1] != s[n - 1]) { tmp = fail; } fail = next[tmp][c]; next[cur][c] = newNode; fail = next[getFail(fail)][c]; } last = next[cur][c]; cnt[last]++; } void count() { for (int i = nodes - 1; i >= 0; --i) { if (fail != 1) { cnt[fail] += cnt[i]; } } } }; ``` #### 4. 时间与空间复杂度分析 - **时间复杂度**:由于每个字符的插入操作最多需要常量次失败指针跳转,因此总的时间复杂度为 \(O(N)\)[^2]。 - **空间复杂度**:回文的空间复杂度取决于字符串中的本质不同回文子串数量,最坏情况下为 \(O(N \times |\Sigma|)\),其中 \(|\Sigma|\) 表示字符集大小[^2]。 #### 5. 应用场景 回文适用于以下问题: - 统计字符串中所有本质不同的回文子串。 - 计算每个回文子串在字符串中的出现次数。 - 动态维护字符串的回文信息。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值