[Luogu P4143] 采集矿石 [2018HN省队集训D5T3] 望乡台platform

[Luogu P4143] 采集矿石 [2018HN省队集训D5T3] 望乡台platform

题意

给定一个小写字母构成的字符串, 每个字符有一个非负权值. 输出所有满足权值和等于这个子串在所有本质不同子串按字典序降序排序后的排名的子串的数量及左右端点.

\(n\le 2\times 10^5\), 保证合法子串个数不超过 \(2\times 10^5\).

题解

我们看这个排名是按字典序逆序排的必有高论. 显然固定左端点后串长越长字典序越大排名越靠前, 而同时子串权值和会增大, 于是对于每个左端点其实最多只有一个满足条件的右端点...(所以那句保证其实是废话)

显然我们对于每个左端点二分这个可能的交点判一下就好了. 子串求和地球人都知道要用前缀和, 问题转化为如何快速求某个子串的排名.

这个后缀自动机好像不是很好搞QAQ...估计要对反串拉出一棵后缀树一看就很难写分明是你懒吧

考虑后缀数组. 我们发现每个后缀对本质不同的子串数量的贡献就是 \(height_{rank_i}\) 与后缀 \(i\) 的长度的差. 如果按后缀排名计算的话, 先算入的子串的字典序显然是要小的. 我们只要二分找到当前子串第一次出现时的左端点然后计算它之前出现的本质不同子串个数就好了.

字典序逆序同理, 前缀和变后缀和.

然后这题就完了. 复杂度两个 \(\log\) (比题解里的一个 \(\log\) 线段树做法快到不知哪里去了). 好像可以算后缀数组求子串排名板子题

参考代码

#include <bits/stdc++.h>

const int MAXN=2e5+10;
typedef long long intEx;

int n;
int a[MAXN];
char s[MAXN];
int SA[MAXN];
int lg[MAXN];
int cnt[MAXN];
int rank[MAXN];
intEx sum[MAXN];
int height[MAXN];
int st[20][MAXN];
int* x=new int[MAXN];
int* y=new int[MAXN];

void BuildSA();
void STBuild();
int STMin(int,int);
intEx Rank(int,int);

int main(){
    scanf("%s",s+1);
    n=strlen(s+1);
    for(int i=1;i<=n;i++){
        scanf("%d",a+i);
        a[i]+=a[i-1];
    }
    BuildSA();
    STBuild();
    std::vector<std::pair<int,int>> ans;
    for(int i=1;i<=n;i++){
        int l=i,r=n+1;
        while(r-l>1){
            int mid=(l+r)>>1;
            if(Rank(i,mid)>=a[mid]-a[i-1])
                l=mid;
            else
                r=mid;
        }
        if(Rank(i,l)==a[l]-a[i-1])
            ans.emplace_back(i,l);
    }
    printf("%d\n",int(ans.size()));
    for(auto p:ans)
        printf("%d %d\n",p.first,p.second);
    return 0;
}

intEx Rank(int l,int r){
    int L=0,R=rank[l];
    while(R-L>1){
        int mid=(L+R+1)>>1;
        if(mid==rank[l]||STMin(mid+1,rank[l])>=(r-l+1))
            R=mid;
        else
            L=mid;
    }
//  printf("$ [%d,%d]: first=%d\n",l,r,R);
    return sum[R+1]+(n-SA[R]+1)-(r-l+1)+1;
}

void BuildSA(){
    int m=127;
    for(int i=1;i<=n;i++)
        ++cnt[x[i]=s[i]];
    for(int i=1;i<=m;i++)
        cnt[i]+=cnt[i-1];
    for(int i=n;i>=1;i--)
        SA[cnt[x[i]]--]=i;
    for(int k=1;k<=n;k<<=1){
        int p=0;
        for(int i=n-k+1;i<=n;i++)
            y[++p]=i;
        for(int i=1;i<=n;i++)
            if(SA[i]>k)
                y[++p]=SA[i]-k;
        memset(cnt+1,0,sizeof(int)*m);
        for(int i=1;i<=n;i++)
            ++cnt[x[i]];
        for(int i=1;i<=m;i++)
            cnt[i]+=cnt[i-1];
        for(int i=n;i>=1;i--)
            SA[cnt[x[y[i]]]--]=y[i];
        std::swap(x,y);
        p=1;
        x[SA[1]]=1;
        for(int i=2;i<=n;i++)
            x[SA[i]]=(y[SA[i]]==y[SA[i-1]]&&y[SA[i]+k]==y[SA[i-1]+k])?p:++p;
        if(p>=n)
            break;
        m=p;
    }
    int k=0;
    for(int i=1;i<=n;i++)
        rank[SA[i]]=i;
    for(int i=1;i<=n;i++){
        if(rank[i]==1)
            continue;
        if(k)
            --k;
        int j=SA[rank[i]-1];
        while(i+k<=n&&j+k<=n&&s[i+k]==s[j+k])
            ++k;
        height[rank[i]]=k;
    }
    for(int i=n;i>=1;i--)
        sum[i]=n-SA[i]+1-height[i]+sum[i+1];
//  for(int i=1;i<=n;i++){
//      printf("SA[%d]=%d sum[%d]=%lld\n",i,SA[i],i,sum[i]);
//  }
}

int STMin(int l,int r){
    int len=(r-l+1);
    return std::min(st[lg[len]][l],st[lg[len]][r-(1<<lg[len])+1]);
}

void STBuild(){
    for(int i=2;i<=n;i<<=1)
        lg[i]=1;
    for(int i=2;i<=n;i++){
        lg[i]+=lg[i-1];
        st[0][i]=height[i];
    }
    for(int j=1;(1<<j)<=n;j++){
        for(int i=2;i<=n;i++){
            st[j][i]=st[j-1][i];
            if(i+(1<<(j-1))<=n)
                st[j][i]=std::min(st[j][i],st[j-1][i+(1<<(j-1))]);
        }
    }
}

转载于:https://www.cnblogs.com/rvalue/p/10479966.html