牛客多校第四场I——string（后缀自动机+回文自动机）

链接：https://ac.nowcoder.com/acm/contest/884/I
来源：牛客网
 

时间限制：C/C++ 2秒，其他语言4秒
空间限制：C/C++ 524288K，其他语言1048576K
64bit IO Format: %lld

题目描述

We call a,ba,ba,b non-equivalent if and only if a≠ba \neq ba​=b and a≠rev(b)a \neq rev(b)a​=rev(b), where rev(s)rev(s)rev(s) refers to the string obtained by reversing characters of sss, for example rev(abca)=acbarev(abca)=acbarev(abca)=acba.

There is a string sss consisted of lower-case letters. You need to find some substrings of sss so that any two of them are non-equivalent. Find out what's the largest number of substrings you can choose.

输入描述:

A line containing a string sss of lower-case letters.

输出描述:

A positive integer - the largest possible number of substrings of sss that are non-equivalent.

示例1

输入

复制

abac

输出

复制

8

说明

The set of following substrings is such a choice: abac,b,a,ab,aba,bac,ac,cabac,b,a,ab,aba,bac,ac,cabac,b,a,ab,aba,bac,ac,c.

备注:

1≤∣s∣≤2×1051 \leq |s|\leq 2 \times 10^51≤∣s∣≤2×105, sss is consisted of lower-case letters.

 

思路：

要计算string串中本质不同的子串，且任意两个子串a和b，不能有a=rev(b)，rev表示对串b取反

对string串和rev(string)串一起建立后缀自动机，可以这样组合：string#string，#是没有用的字符，那么我们可以求组合后的串中不包含#的本质不同的子串，注意到这样一个事实：如果一个串的rev串也出现过，那么这个串和它的rev串都只会被计算一次，而其他的串都会被计算两次。

比如说，对于串abac，插入abac#caba，原串中是不是有ab,ba两个串，那么在新插入的串中，ab->ba，ba->ab，那么当我们计算本质不同的串的时候，是不是ab,ba都只计算了一次？

所以接下来，对于有回文串的存在，再建立一颗回文树，求原串中有多少个本质不同的回文串，答案就是(ans1+ans2)/2。

#include<stdio.h>
#include<bits/stdc++.h>
#define maxc 28
using namespace std;
const int maxn = 1e6 + 5;
const int mod = 1e9 + 7;
typedef long long ll;
char str[maxn];
int lenn;
struct Suffix_Automaton {
	int len[maxn * 2], //最长子串的长度(该节点子串数量=len[x]-len[link[x]])
	    link[maxn * 2],   //后缀链接(最短串前部减少一个字符所到达的状态)
	    cnt[maxn * 2],    //被后缀连接的数
	    nex[maxn * 2][maxc],  //状态转移(尾部加一个字符的下一个状态)(图)
	    idx, //结点编号
	    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 PAM{//回文树
    int next[maxn][26],fail[maxn],len[maxn],cnt[maxn],S[maxn];
    int id,n,last;
    int newnode(int x){
        for(int i=0;i<26;i++){
            next[id][i]=0;
        }
        cnt[id]=0;
        len[id]=x;
        return id++;
    }
    void init(){
        id=0;
        newnode(0);
        newnode(-1);
        fail[0]=1;
        S[0]=-1;
        last=n=0;
    }
    int getfail(int x){
        while(S[n-len[x]-1]!=S[n]) x=fail[x];
        return x;
    }
    void Insert(int c){
        S[++n]=c;
        int cur=getfail(last);
        if(!next[cur][c]){
            int now=newnode(len[cur]+2);
            fail[now]=next[getfail(fail[cur])][c];
            next[cur][c]=now;
        }
        last=next[cur][c];
        cnt[last]++;
    }
    
}pam;
 
int main(){
	scanf("%s",str);
	lenn = strlen(str);
	sam.init();
	for(int i=0;i<lenn;i++){
		sam.extend(str[i]-'a');
	}
	sam.last = 1;
	for(int i=lenn-1;i>=0;i--){
		sam.extend(str[i]-'a');
	}
	ll p = sam.getSubNum(); 
	pam.init();
	for(int i = 0;i<lenn;i++){
		pam.Insert(str[i]-'a');
	}
	printf("%lld\n",(p+pam.id-2)/2);
	return 0;
}