string（SAM+PAM）

https://ac.nowcoder.com/acm/contest/884/I?&headNav=acm

题意：求string串有多少个本质不同的子串，且这些子串之间两两不存在 a==rev(a），及不存在长度1以上的回文串

题解：要算string 和 rev(string)的所有子串，对string

和rev(string）建立广义后缀自动机，则理论上所有子串增加了一倍，但实际回文串和 不是回文但a == rev(a）的串没有增加，

比如 aba子串ab和ba。则我们计算出此时不同串个数 ans1, 再计算出string串中回文串数 ans2，则(ans1+ans2)/2即为所求.

为什么呢？ 举个栗子，abac子串 a, ab , aba, abac,  b, ba, bac, ac, c。  其逆cabc新增子串 ca,cab,caba.我们看一看没有新增加

的子串 a, b, c, aba, ab, ba  ，除了 ab和ba都是回文串,于是再求出回文串就是说 此时（ans1+ans2)是表示所有串都有与之对应的

逆序串，除以2就是单独一份了。
--------------------- 
作者：wym_king 
来源：CSDN 
原文：https://blog.csdn.net/qq_41603898/article/details/97611570 
版权声明：本文为博主原创文章，转载请附上博文链接！

嘤嘤嘤，SAM刚接触，啥也不懂，以后再说

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+10;
const int N=2e5+10;
const int maxc=26;
char s[N];
struct Suffix_Automaton {
	int len[maxn * 2]; //最长子串的长度(该节点子串数量=len[x]-len[link[x]])
	int link[maxn * 2];   //后缀链接(最短串前部减少一个字符所到达的状态)
	int cnt[maxn * 2];   //被后缀连接的数
	int nex[maxn * 2][maxc];  //状态转移(尾部加一个字符的下一个状态)(图)
	int idx; //结点编号
	int last;    //最后结点
	ll num[maxn * 2]; // enpos数（子串出现数量）
	ll a[maxn];		//长度为i的子串出现最大次数
 
	void init() {	//初始化
		for(int i=1; i<=idx; i++)
			link[i] = len[i] = 0,memset(nex[i],0,sizeof(nex[i]));
		last = idx = 1; //1表示root起始点 空集
	}
//SAM建图
	void extend(int c) {     //插入字符，为字符ascll码值
		int x = ++idx; //创建一个新结点x;
		len[x] = len[last] + 1; //  长度等于最后一个结点+1
		num[x] = 1;  //接受结点子串除后缀连接还需加一
		int p;  //第一个有C转移的结点;
		for (p = last; p && !nex[p][c]; p = link[p])
			nex[p][c] = x;//沿着后缀连接 将所有没有字符c转移的节点直接指向新结点
		if (!p)link[x] = 1, cnt[1]++;  //全部都没有c的转移 直接将新结点后缀连接到起点
		else {
			int q = nex[p][c];    //p通过c转移到的结点
			if (len[p] + 1 == len[q])    //pq是连续的
				link[x] = q, cnt[q]++; //将新结点后缀连接指向q即可,q结点的被后缀连接数+1
			else {
				int nq = ++idx;   //不连续 需要复制一份q结点
				len[nq] = len[p] + 1;   //令nq与p连续
				link[nq] = link[q];   //因后面link[q]改变此处不加cnt
				memcpy(nex[nq], nex[q], sizeof(nex[q]));  //复制q的信息给nq
				for (; p&&nex[p][c] == q; p = link[p])
					nex[p][c] = nq;    //沿着后缀连接 将所有通过c转移为q的改为nq
				link[q] = link[x] = nq; //将x和q后缀连接改为nq
				cnt[nq] += 2; //  nq增加两个后缀连接
			}
		}
		last = x;  //更新最后处理的结点	
	} 
	ll getSubNum() {	//求不相同子串数量
		ll ans = 0;
		for (int i = 2; i <= idx; i++)
			ans += len[i]-len[link[i]];	//一状态子串数量等于len[i]-len[link[i]]
		return ans;
	} 
} sam;
struct Palindromic_Tree{
	int next[N][26];//next指针，next指针和字典树类似，指向的串为当前串两端加上同一个字符构成
	int fail[N];//fail指针，失配后跳转到fail指针指向的节点     最长回文后缀 
	int len[N];//len[i]表示节点i表示的回文串的长度  
	int S[N];//存放添加的字符
	ll cnt[N];//结点表示的本质不同的回文串的个数(调用count()后)
	int num[N];//结点表示的最长回文串的最右端点为回文串结尾的回文串个数
	int last;;//指向上一个字符所在的节点，方便下一次add 
	int n;//字符数组指针  
    int p;//节点指针
	int newnode(int x){//新建节点 
		memset(next[p],0,sizeof(next[p]));
		cnt[p]=0;
		num[p]=0;
		len[p]=x;
		return p++;
	}
	void init(){
		p=0;
		newnode(0);
		newnode(-1);
		last=0;
		n=0;
		S[0]=-1;//开头放一个字符集中没有的字符，减少特判 
		fail[0]=1;
	}
	int get_fail(int x){//和KMP一样，失配后找一个尽量最长的  
		while(S[n-len[x]-1]!=S[n]) x=fail[x];
		return x;
	} 
	void add(int c){
		c-='a';
		S[++n]=c;
		int cur=get_fail(last);//通过上一个回文串找这个回文串的匹配位置
		if(!next[cur][c]){//如果这个回文串没有出现过，说明出现了一个新的本质不同的回文串  
			int now=newnode(len[cur]+2);//新建节点
			fail[now]=next[get_fail(fail[cur])][c];//和AC自动机一样建立fail指针，以便失配后跳转  
			num[now]=num[fail[now]]+1;
			next[cur][c]=now;
		} 
		last=next[cur][c];
		cnt[last]++;		
	}
	void count(){
		for(int i=p-1;i>=0;i--) cnt[fail[i]]+=cnt[i];
		//父亲累加儿子的cnt，因为如果fail[v]=u，则u一定是v的子回文串！
	}
}pam;
int main(){
    scanf("%s",s);
    int len=strlen(s);
    //建广义SAM 
    sam.init();
    for(int i=0;i<len;i++) sam.extend(s[i]-'a');
    sam.last=1;
    for(int i=len-1;i>=0;i--) sam.extend(s[i]-'a');
    int a=sam.getSubNum();//得到不同的子串的数目
	//建PAM 
	pam.init();
	for(int i=0;i<len;i++) pam.add(s[i]);
	int b=pam.p-2;
	printf("%d\n",(a+b)/2); 
	return 0;
}