●BZOJ 4516 [Sdoi2016]生成魔咒

题链:

http://www.lydsy.com/JudgeOnline/problem.php?id=4516

题解:

把串反过来后,问题变为求每个后缀的互不相同的子串个数。
首先用倍增算法求出 sa[],rank[],height[],然后对 height[]数组建立 ST表。
接着求出整个串的子串个数,ans+=N-sa[i]-height[i]。(我从0开始编号的)
式子的含义就是考虑每个后缀相比它的前一名,多了几个与之前不同的且串头为该后缀的头的子串。
(一定要清晰地懂得并理解那个式子哦)

之前得出了0 位置开始的后缀(即整个串)的子串个数,
那么现在就需要把 rank[0]这个后缀从排好序的后缀数组中去除。
然后维护出新的后缀(即从1位置开始的后缀)的子串个数。
怎么做呢,反向考虑 ans的求法:
即把rank[0]产生的贡献减去(包括和它上面一名以及和它下面一名产生的贡献),相当于该后缀被去除了。
这时排在rank[0]上面一位的后缀(设为 u),和排在rank[0]下面一位的后缀(设为 d),
就挨在了一起,那么要加上 u 后缀和 d 后缀的贡献。
然后就得到了新的后缀的子串个数。
之后的其它后缀的计算就类似了。

另外再提一下,在找当前后缀的上一名后缀和下一名后缀时,找到的必须是还在后缀数组中(即还没有被去除),
可以用类似并查集的思想维护(好吧,是路径压缩的思想),做到均摊 O(1)。

除开倍增算法和求ST表的复杂度 O(N)

代码:

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define MAXN 100500
#define filein(x) freopen(#x".in","r",stdin);
#define fileout(x) freopen(#x".out","w",stdout);
using namespace std;
int sa[MAXN],rak[MAXN],hei[MAXN];
int up[MAXN],down[MAXN],A[MAXN],log2[MAXN],stm[MAXN][20];
bool vis[MAXN];
void build(int N,int M){
	static int cc[MAXN],ta[MAXN],tb[MAXN],*x,*y,h,p;
	x=ta; y=tb; h=0; A[N]=-1;
	for(int i=0;i<M;i++) cc[i]=0;
	for(int i=0;i<N;i++) cc[x[i]=A[i]]++;
	for(int i=1;i<M;i++) cc[i]+=cc[i-1];
	for(int i=N-1;i>=0;i--) sa[--cc[x[i]]]=i;
	for(int k=1;p=0,k<N;k<<=1){
		for(int i=N-k;i<N;i++) y[p++]=i;
		for(int i=0;i<N;i++) if(sa[i]>=k) y[p++]=sa[i]-k;
		for(int i=0;i<M;i++) cc[i]=0;
		for(int i=0;i<N;i++) cc[x[y[i]]]++;
		for(int i=1;i<M;i++) cc[i]+=cc[i-1];
		for(int i=N-1;i>=0;i--) sa[--cc[x[y[i]]]]=y[i];
		swap(x,y); y[N]=-1; x[sa[0]]=0; M=1;
		for(int i=1;i<N;i++)
			x[sa[i]]=y[sa[i]]==y[sa[i-1]]&&y[sa[i]+k]==y[sa[i-1]+k]?M-1:M++;
		if(M>=N) break;
	}
	for(int i=0;i<N;i++) rak[sa[i]]=i;
	for(int i=0,j;i<N;i++){
		if(h) h--;
		if(rak[i]){
			j=sa[rak[i]-1];
			while(A[i+h]==A[j+h]) h++;
		}
		stm[rak[i]][0]=hei[rak[i]]=h;
	}
	for(int k=1;k<=log2[N];k++)
        for(int i=(1<<k)-1;i<N;i++)
            stm[i][k]=min(stm[i-(1<<(k-1))][k-1],stm[i][k-1]);
}
int query(int l,int r,int N){
    static int k;
    if(l==-1||r==-1||l==N||r==N) return 0;
    if(l>r) swap(l,r); l++;
    k=log2[r-l+1];
    return min(stm[l+(1<<k)-1][k],stm[r][k]);
}
int find(int i,int *to,const int &N){
	if(i==-1||i==N||!vis[i]) return i;
	return to[i]=find(to[i],to,N);
}
void solve(int N){
	static long long now,ANS[MAXN];
	for(int i=1;i<N;i++) up[i]=i-1,down[i-1]=i; up[0]=-1; down[N-1]=N;
	for(int i=0;i<N;i++) now+=1ll*N-sa[i]-hei[i];
	ANS[N]=now; sa[N]=N;
	for(int i=0,r,u,d;i<N-1;i++){
		r=rak[i]; vis[r]=1; u=find(r,up,N); d=find(r,down,N);
		now-=1ll*N-sa[r]-query(u,r,N);
		now-=1ll*N-sa[d]-query(d,r,N);
		now+=1ll*N-sa[d]-query(u,d,N);
		ANS[N-i-1]=now;
	}
	for(int i=1;i<=N;i++) printf("%lld\n",ANS[i]);
}
int main()
{
	filein(incantation);fileout(incantation);
	static int tmp[MAXN];
	log2[1]=0; for(int i=2;i<=100000;i++) log2[i]=log2[i>>1]+1;
	int N,cnt; scanf("%d",&N);
	for(int i=N-1;i>=0;i--) scanf("%d",&A[i]),tmp[i]=A[i];
	sort(tmp,tmp+N);
	cnt=unique(tmp,tmp+N)-tmp;
	for(int i=0;i<N;i++) A[i]=lower_bound(tmp,tmp+cnt,A[i])-tmp;
	build(N,N);
	solve(N);
	return 0;
}
时间: 2024-10-06 20:10:33

●BZOJ 4516 [Sdoi2016]生成魔咒的相关文章

BZOJ 4516: [Sdoi2016]生成魔咒

Description 给出一串数字,求每次插入一个数字后本质不同的子串. Sol SAM. 在 SAM 上添加节点的时候统计一下 \(val[np]-val[par[np]]\) 就可以了... 用 map 存一下边,复杂度 \(O(nlogn)\) Code /************************************************************** Problem: 4516 User: BeiYu Language: C++ Result: Accept

[Sdoi2016]生成魔咒[SAM or SA]

4516: [Sdoi2016]生成魔咒 Time Limit: 10 Sec  Memory Limit: 128 MBSubmit: 1017  Solved: 569[Submit][Status][Discuss] Description 魔咒串由许多魔咒字符组成,魔咒字符可以用数字表示.例如可以将魔咒字符 1.2 拼凑起来形成一个魔咒串 [1,2]. 一个魔咒串 S 的非空字串被称为魔咒串 S 的生成魔咒. 例如 S=[1,2,1] 时,它的生成魔咒有 [1].[2].[1,2].[2

BZOJ4516: [Sdoi2016]生成魔咒 后缀自动机

#include<iostream> #include<cstdio> #include<cstring> #include<queue> #include<cmath> #include<algorithm> #include<cstdlib> #include<map> #define N 200005 #define ll long long using namespace std; int read()

bzoj4516: [Sdoi2016]生成魔咒(SAM)

4516: [Sdoi2016]生成魔咒 题目:传送门 题解: 真奥义之SAM裸题... 其实对于当前新增节点x的操作,每次对ans的贡献就是dep[x]-dep[fail[x]](根据fail指针的定义随便YY) 然后有思路之后乍看题目每个x是10^9...瞬间GG %了已发cc然后被D飞,直接上map啊 代码: 1 #include<cstdio> 2 #include<cstring> 3 #include<cstdlib> 4 #include<cmath

P4070 [SDOI2016]生成魔咒

题目地址:P4070 [SDOI2016]生成魔咒 相信看到题目之后很多人跟我的思路是一样的-- 肯定要用 SA(P3809 [模板]后缀排序) 肯定要会求本质不同的子串个数(P2408 不同子串个数) 然后?就不会了...... 瓶颈在哪儿? 你会发现每往后添加一个字符,整个 sa 数组只会插入一个数,要维护不难 但是 height 会无规律变化,这就导致无法高效维护 怎么办呢? 倒置字符串 我们将整个字符串倒置过来 显然本质不同的子串个数不会变化 而每往前添加一个字符串, height 的变

[SDOI2016] 生成魔咒 - 后缀数组,平衡树,STL,时间倒流

[SDOI2016] 生成魔咒 Description 初态串为空,每次在末尾追加一个字符,动态维护本质不同的子串数. Solution 考虑时间倒流,并将串反转,则变为每次从开头删掉一个字符,即每次从后缀集合中删掉一个后缀. 预处理出后缀数组和高度数组后,用平衡树维护所有后缀集合(按照后缀排序),要删除一个后缀 \(S[sa[p],n]\) 时,找到它在平衡树上的前驱 \(u\) 和后继 \(v\) ,如果都存在,那么这一步的贡献就是 \[(n-sa[p]+1) - Max(h[p],h[v]

Bzoj4516 [Sdoi2016]生成魔咒

Time Limit: 10 Sec  Memory Limit: 128 MBSubmit: 947  Solved: 529 Description 魔咒串由许多魔咒字符组成,魔咒字符可以用数字表示.例如可以将魔咒字符 1.2 拼凑起来形成一个魔咒串 [1,2]. 一个魔咒串 S 的非空字串被称为魔咒串 S 的生成魔咒. 例如 S=[1,2,1] 时,它的生成魔咒有 [1].[2].[1,2].[2,1].[1,2,1] 五种.S=[1,1,1] 时,它的生成魔咒有 [1]. [1,1].[

[SDOI2016]生成魔咒

OJ题号: BZOJ4516 题目大意: 按顺序在一个序列的末尾插入数字,每次求出插入后能得到的本质不同的子串个数. 思路: 每次在SAM后加入这个数字,每次新出现的本质不同的子串个数就等于new_p->len-new_p->link->len. 由于数字范围比较大,可以考虑离散化或者map. 事实上也可以用hash,不过实践证明会比map还慢很多,内存也浪费很多. 另外需要注意开long long. 1 #include<map> 2 #include<cstdio&

LibreOJ #2033. 「SDOI2016」生成魔咒

二次联通门 : LibreOJ #2033. 「SDOI2016」生成魔咒 /* LibreOJ #2033. 「SDOI2016」生成魔咒 调了整整一天啊... 绝望啊 最后发现是1打成i了啊!!! */ #include <iostream> #include <cstdio> #include <algorithm> #include <cmath> #include <map> const int BUF = 10000020; char