牛客多校 - B-Suffix Array(后缀数组)

题目链接：点击查看

题目大意：给出一个只含有 ' a ' 和 ' b ' 的字符串，再给出 B 数组的构造方法如下：对于每个位置 i 来说

1. 如果存在一个位置 j ，使得 j < i 且 s[ j ] == s[ i ] ，则 b[ i ] = i - j
2. 否则 s[ i ] = 0

现在需要对字符串的每个后缀构造 B 数组，并按照字典序排序

题目分析：参考博客：https://blog.csdn.net/weixin_43965698/article/details/107304525

一个例子：

通过观察，可以将每个后缀的 B 数组分成两段，分别记为段 A 和段 B（上图中表示为段 A 和段 D ）

段 A 的特点是：第一个数字和最后一个数字同为 0，且段 A 中只有这两个 0，段 B 的特点是：是字符串 s 的 B 数组的其中一个后缀

因为只有段 A 中含有 0 ，所以在排序时，段 A 的优先级要高于段 B 的，所以段 A 长度更小的，显然应该排在前面

当段 A 的长度相等时，再考虑段 B ，因为此时的段 B 都是字符串 s 的 B 数组的后缀，所以可以利用后缀数组得到 rk 数组，rk[ i ] 当然就是后缀 i 的排名了

当然存在特殊情况，就是如果段 B 为空时，此时显然段 B 为空的字典序更小

代码：
 

#include<iostream>
#include<cstdio>
#include<string>
#include<ctime>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<stack>
#include<climits>
#include<queue>
#include<map>
#include<set>
#include<sstream>
#include<cassert>
using namespace std;

typedef long long LL;

typedef unsigned long long ull;

const int inf=0x3f3f3f3f;

const int N=1e5+100;
 
char str[N];
 
int sa[N]; //SA数组，表示将S的n个后缀从小到大排序后把排好序的
//的后缀的开头位置顺次放入SA中
int t1[N],t2[N],c[N];
 
int rk[N],height[N],len;
 
int s[N];
 
void build_sa(int s[],int n,int m)//n为添加0后的总长
{
    int i,j,p,*x=t1,*y=t2;
    for(i=0;i<m;i++) 
		c[i]=0;
    for(i=0;i<n;i++) 
		c[x[i]=s[i]]++;
    for(i=1;i<m;i++) 
		c[i]+=c[i-1];
    for(i=n-1;i>=0;i--) 
		sa[--c[x[i]]]=i;
    for(j=1;j<=n;j<<=1) 
	{
        p=0;
        for(i=n-j;i<n;i++) 
			y[p++]=i;
        for(i=0;i<n;i++) 
            if(sa[i]>=j) 
                y[p++]=sa[i]-j;
        for(i=0;i<m;i++) 
			c[i]=0;
        for(i=0;i<n;i++) 
			c[x[y[i]]]++;
        for(i=1;i<m;i++) 
			c[i]+=c[i-1];
        for(i=n-1;i>=0;i--) 
			sa[--c[x[y[i]]]]=y[i];
        swap(x,y);
        p=1,x[sa[0]]=0;
        for(i=1;i<n;i++) 
            x[sa[i]]=y[sa[i-1]]==y[sa[i]]&&y[sa[i-1]+j]==y[sa[i]+j]?p-1:p++;
        if(p>=n) 
			break;
        m=p;
    }
}
 
void get_height(int s[],int n)//n为添加0后的总长
{
    int i,j,k=0;
    for(i=0;i<=n;i++)
        rk[sa[i]]=i;
    for(i=0;i<n;i++) 
	{
        if(k) 
			k--;
        j=sa[rk[i]-1];
        while(s[i+k]==s[j+k]) 
			k++;
        height[rk[i]]=k;
    }
}
 
void solve(int base=128)
{
	build_sa(s,len+1,base);
	get_height(s,len);
}

struct Node
{
	int id,len_a,pos_b;//id:编号,len_a:段A的长度,pos_b:段B的起始位置 
	Node(int id,int len_a,int pos_b):id(id),len_a(len_a),pos_b(pos_b){}
	bool operator<(const Node& t)const
	{
		if(len_a!=t.len_a)//如果段A的长度不相等，较短的字典序更短 
			return len_a<t.len_a;
		if(pos_b!=-1&&t.pos_b!=-1)//如果都有段B，直接根据后缀数组比较大小 
			return rk[pos_b]<rk[t.pos_b];
		return pos_b==-1;//否则没有段B的显然更小 
	}
};

int main()
{
#ifndef ONLINE_JUDGE
//  freopen("input.txt","r",stdin);
//  freopen("output.txt","w",stdout);
#endif
//  ios::sync_with_stdio(false);
	while(scanf("%d",&len)!=EOF)
	{
		scanf("%s",str);
		int pre_a=-1,pre_b=-1;
		for(int i=0;i<len;i++)//根据题目要求初始化s数组 
		{
			if(str[i]=='a')
			{
				if(pre_a==-1)
					s[i]=1;
				else
					s[i]=i-pre_a+1;
				pre_a=i;
			}
			else
			{
				if(pre_b==-1)
					s[i]=1;
				else
					s[i]=i-pre_b+1;
				pre_b=i;
			}
		}
		s[len]=0;
		solve(len+1);
		pre_a=pre_b=-1;
		vector<Node>ans;
		for(int i=len-1;i>=0;i--)
		{
			if(str[i]=='a')
			{
				if(pre_b==-1)//如果a之后没再有b的话，说明不存在段B，设置起初始位置为-1，设置段A的长度为len-i+1 
					ans.push_back(Node(i,len-i+1,-1));
				else//如果同时存在段A和段B，记录段A的长度和段B的初始位置 
					ans.push_back(Node(i,pre_b-i+1,pre_b+1));
				pre_a=i;
			}
			else
			{
				if(pre_a==-1)
					ans.push_back(Node(i,len-i+1,-1));
				else
					ans.push_back(Node(i,pre_a-i+1,pre_a+1));
				pre_b=i;
			}
		}
		sort(ans.begin(),ans.end());
		for(auto v:ans)
			printf("%d ",v.id+1);
		puts("");
	}









    return 0;
}