Codeforces #123D: String 题解

题目里说，如果某一种子串s在原串中出现了k次，根据题目定义的函数，它产生的贡献是(k+1)*k/2

这个条件很奇怪，我们尝试转化模型，就会发现这个函数相当于我们将这k个s串排成一排，每个串和它自己以及后面的串匹配一次，总次数就是题目要求的函数

于是我们可以上后缀数组+高度数组，对于每一个后缀，和后面的每一个后缀的算一个最长公共前缀，然后根据长度统计答案

这个东西可以用单调栈搞一搞

最后别忘了每个后缀和自己可以匹配一次，也就是说如果读入的串长度为n，ans+=(n+1)*n/2

 

#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <cstdlib>
#include <utility>
#include <cctype>
#include <algorithm>
#include <bitset>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <cmath>
#define LL long long
#define LB long double
#define x first
#define y second
#define Pair pair<int,int>
#define pb push_back
#define pf push_front
#define mp make_pair
#define LOWBIT(x) x & (-x)
using namespace std;

const int MOD=1e9+7;
const LL LINF=2e16;
const int INF=2e9;
const int magic=348;
const double eps=1e-10;

inline int getint()
{
    char ch;int res;bool f;
    while (!isdigit(ch=getchar()) && ch!='-') {}
    if (ch=='-') f=false,res=0; else f=true,res=ch-'0';
    while (isdigit(ch=getchar())) res=res*10+ch-'0';
    return f?res:-res;
}

char s[100048];int len,k;
int sa[100048],rnk[100048],tmp[100048],lcp[100048];

bool compare_sa(int x,int y)
{
	if (rnk[x]!=rnk[y]) return rnk[x]<rnk[y];
	int tmp1=x+k<=len?rnk[x+k]:-1,tmp2=y+k<=len?rnk[y+k]:-1;
	return tmp1<tmp2;
}

void construct_sa()
{
	int i;
	for (i=1;i<=len;i++)
	{
		sa[i]=i;
		rnk[i]=s[i];
	}
	for (k=0;k<=len;k==0?k++:k<<=1)
	{
		sort(sa+1,sa+len+1,compare_sa);
		tmp[sa[1]]=1;int cnt=0;
		for (i=2;i<=len;i++)
		{
			tmp[sa[i]]=tmp[sa[i-1]]+(compare_sa(sa[i-1],sa[i])?1:0);
			cnt+=tmp[sa[i-1]]==tmp[sa[i]]?0:1;
		}
		for (i=1;i<=len;i++) rnk[i]=tmp[i];
		if (cnt>=len-1) break;
	}
}

void construct_lcp()
{
	int i,j,h=0;
	for (i=1;i<=len;i++) rnk[sa[i]]=i;
	for (i=1;i<=len;i++)
	{
		j=sa[rnk[i]-1];
		if (h) h--;
		while (i+h<=len && j+h<=len && s[i+h]==s[j+h]) h++;
		lcp[rnk[i]-1]=h;
	}
}

stack<Pair> sta;
int main ()
{
	int i;
	scanf("%s",s+1);
	len=strlen(s+1);
	construct_sa();
	construct_lcp();
	LL ans=(long long)len*(long long)(len+1)/2;
	LL cnt=0;
	for (i=len-1;i>=1;i--)
	{
		Pair ins=mp(lcp[i],1);
		while (!sta.empty() && sta.top().x>ins.x)
		{
			cnt-=(long long)sta.top().x*sta.top().y;
			ins.y+=sta.top().y;
			sta.pop();
		}
		cnt+=(long long)ins.x*ins.y;
		sta.push(ins);
		ans+=cnt;
	}
	cout<<ans<<endl;
	return 0;
}

update

最近学习了SAM，发现这样的题目用SAM做很无脑

题目相当于如果一个串s'在S中出现了a次，答案加上(a+1)*a/2，那么我们直接对S建SAM，然后对于每种子串算一下贡献就好了

#include <bits/stdc++.h>
using namespace std;

#define LL long long
#define LB long double
#define ull unsigned long long
#define x first
#define y second
#define pb push_back
#define pf push_front
#define mp make_pair
#define Pair pair<int,int>
#define pLL pair<LL,LL>
#define pii pair<double,double>
#define LOWBIT(x) x & (-x)

const int INF=2e9;
const LL LINF=2e16;
const int magic=348;
const int MOD=998244353;
const double eps=1e-10;
const double pi=acos(-1);

inline int getint()
{
	bool f;char ch;int res;
	while (!isdigit(ch=getchar()) && ch!='-') {}
	if (ch=='-') f=false,res=0; else f=true,res=ch-'0';
	while (isdigit(ch=getchar())) res=res*10+ch-'0';
	return f?res:-res;
}

const int MAXN=1e5;

char s[MAXN+48];int len;
vector<int> v[MAXN*2];

namespace SAM
{
	int root,last,tot;
	int nxt[MAXN*2][27],par[MAXN*2],maxn[MAXN*2],minn[MAXN*2],sz[MAXN*2];
	inline void init() {root=last=1;++tot;}	
	inline void insert(char ch)
	{
		int p=last,np=++tot;maxn[np]=maxn[p]+1;sz[np]=1;int w=ch-'a'+1;
		while (p && !nxt[p][w]) nxt[p][w]=np,p=par[p];
		if (!p)
			par[np]=root;
		else
		{
			int q=nxt[p][w];
			if (maxn[q]==maxn[p]+1)
				par[np]=q;
			else
			{
				int nq=++tot;maxn[nq]=maxn[p]+1;
				memcpy(nxt[nq]+1,nxt[q]+1,26*sizeof(int));
				par[nq]=par[q];par[np]=nq;par[q]=nq;
				while (p && nxt[p][w]==q) nxt[p][w]=nq,p=par[p];
			}
		}
		last=np;
	}
}

using namespace SAM;

inline void dfs(int cur)
{
	for (register int i=0;i<int(v[cur].size());i++)
		dfs(v[cur][i]),sz[cur]+=sz[v[cur][i]];
}

int main ()
{
	scanf("%s",s+1);len=strlen(s+1);int i;
	init();for (i=1;i<=len;i++) insert(s[i]);
	for (i=2;i<=tot;i++) minn[i]=maxn[par[i]]+1;
	for (i=2;i<=tot;i++) v[par[i]].pb(i);
	dfs(1);
	LL ans=0;
	for (i=2;i<=tot;i++) ans+=1ll*(maxn[i]-minn[i]+1)*(sz[i]+1)*sz[i]/2;
	printf("%lld\n",ans);
	return 0;
}