ACM-ICPC 2018 焦作赛区网络预赛-H.String and Times-后缀数组/后缀自动机-出现次数大于l小于r的子串个数

题意：

即求出现次数大于l小于r的可重叠子串个数

思路：

类比于求出现次数等于k的可重叠子串个数，即求出次数大于等于k次的，再求出出现次数大于等于k+1次的，然后用出现大于等于k次的减去出现大于等于k+1次的，再容斥处理一下，即是正好出现k次的子串个数
只需要修改一下容斥部分，就可以很容易的将上述问题改为本题
对于本题，我们要求的就是出现大于等于l次的和出现大于r次的，用出现大于等于k次的减去出现大于r次的，就是出现[l,r]次的子串个数
先求出所有l长度区间的贡献，然后减去相邻区间的重复贡献，再减去r+1长度区间的贡献，最后容斥一下，加上被重复减去的部分

代码：

后缀数组

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

const int MAXN = 200006;
int s[MAXN];  // s 数组保存了字符串中的每个元素值，除最后一个元素外，每个元素的值在 1..m 之间，最后一个元素的值为 0
int wa[MAXN], wb[MAXN], wc[MAXN], wd[MAXN];  // 这 4 个数组是后缀数组计算时的临时变量，无实际意义
int sa[MAXN]; //  sa[i] 保存第 i 小的后缀在字符串中的开始下标，i 取值范围为 0..n-1
int cmp(int *r, int a, int b, int l) {
    return r[a] == r[b] && r[a + l] == r[b + l];
}
void getSA(int *r, int *sa, int n, int m) {  // n 为字符串的长度，m 为字符最大值
    int i, j, p, *x = wa, *y = wb;
    for (i = 0; i < m; ++i) wd[i] = 0;
    for (i = 0; i < n; ++i) wd[x[i] = r[i]]++;
    for (i = 1; i < m; ++i) wd[i] += wd[i - 1];
    for (i = n - 1; i >= 0; --i) sa[--wd[x[i]]] = i;
    for (j = 1, p = 1; p < n; j *= 2, m = p) {
        for (p = 0, 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 < n; ++i) wc[i] = x[y[i]];
        for (i = 0; i < m; ++i) wd[i] = 0;
        for (i = 0; i < n; ++i) wd[wc[i]]++;
        for (i = 1; i < m; ++i) wd[i] += wd[i - 1];
        for (i = n - 1; i >= 0; --i) sa[--wd[wc[i]]] = y[i];
        for (swap(x, y), p = 1, x[sa[0]] = 0, i = 1; i < n; ++i)
            x[sa[i]] = cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
    }
    return;
}

int n;            //字符串长度
int Rank[MAXN];  // Rank[i] 表示从下标 i 开始的后缀的排名，值为 1..n
int height[MAXN]; // 下标范围为 1..n，height[1] = 0,表示suffix(sa[i-1])和suffix(sa[i])的最长公共前缀，即排名相邻的两个后缀的最长公共前缀
void getHeight(int *r,int *sa,int n) {
    int i, j, k = 0;
    for (i = 1; i <= n; ++i) Rank[sa[i]] = i;
    for (i = 0; i < n; i++) {
        if (k) k--;
        int j = sa[Rank[i] - 1];
        while (r[i + k] == r[j + k]) k++;
        height[Rank[i]] = k;
    }
    return;
}
int lcp[MAXN][30];
void init_RMQ(int n)
{
    for(int i=0;i<n;i++) lcp[i][0]=height[i];
    for(int j=1;(1<<j)<=n;j++)
        for(int i=0;i+(1<<j)<=n;i++)
            lcp[i][j]=min(lcp[i][j-1],lcp[i+(1<<(j-1))][j-1]);
}
int RMQ(int l,int r)
{
    int k=0;
    while((1<<(k+1))<=r-l+1) k++;
    int ans=min(lcp[l][k],lcp[r-(1<<k)+1][k]);
    return ans;
}
int ask(int l,int r)
{
    if(l==r) return n-sa[r];
    return RMQ(l+1,r);
}

char str[2000006];
int main()
{
    while(~scanf("%s",&str))
    {
        int l,r;
        scanf("%d%d",&l,&r);
        n=strlen(str);
        for(int i=0;i<n;i++)
            s[i]=str[i]-'A'+1;
        s[n]=0;
        getSA(s,sa,n+1,30);
        getHeight(s,sa,n);
        init_RMQ(n+1);
        long long ans=0;
        for(int i=1;i+l-1<=n;i++)
        {
            ans+=ask(i,i+l-1);                    //求出所有长度为l的区间的贡献
            if(i-1>0) ans-=ask(i-1,i+l-1);         //减去相邻区间重复贡献值
            if(i+r<=n) ans-=ask(i,i+r);            //减去长度为r+1区间的贡献值
            if(i-1>0 && i+r<=n) ans+=ask(i-1,i+r);       //容斥处理，加上多减去的部分
        }
        printf("%lld\n",ans);
    }
    return 0;
}

后缀自动机

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e6+3;

int root,last;
int cnt;
int l;

int sv[maxn*2];
struct query
{
    int a;
    ll ans;
}qu[maxn];

struct sam_node
{
    int fa,son[26];
    int len;
    void init(int _len)
    {
        len = _len;
        fa = -1;
        memset(son,-1,sizeof(son));
    }
}t[maxn*2];

void init()
{
    cnt = 0;
    root = last = 0;
    t[cnt].init(0);
}

void extend(int w)
{
    int p = last;
    int np = ++cnt;
    t[cnt].init(t[p].len+1);
    sv[l] = np;
    int q, nq;
    while(p != -1 && t[p].son[w] == -1)
    {
        t[p].son[w] = np;
        p = t[p].fa;
    }
    if(p == -1) t[np].fa = root;
    else
    {
        q = t[p].son[w];
        if (t[p].len+1 == t[q].len) t[np].fa=q;
        else
        {
            nq = ++cnt;
            t[nq].init(0);
            t[nq] = t[q];
            t[nq].len = t[p].len+1;
            t[q].fa = nq;
            t[np].fa = nq;
            while(p!=-1&&t[p].son[w]==q)
            {
                t[p].son[w] = nq;
                p = t[p].fa;
            }
        }
    }
    last = np;
}

int w[maxn], r[maxn*2];

void topo()
{
    for(int i = 0; i <= l; ++i) w[i] = 0;
    for(int i = 1; i <= cnt; ++i) w[t[i].len]++;
    for(int i = 1; i <= l; ++i) w[i] += w[i-1];
    for(int i = cnt; i >= 1; --i) r[w[t[i].len]--] = i;
    r[0] = 0;
}

int dp[maxn*2];
char s[maxn];


int main()
{
    int n, k, p;
    while(~scanf("%s",&s))
    {
        int L,R;
        scanf("%d%d",&L,&R);
        int tl = strlen(s);
        l = 0;
        init();
        for(int i = 0; i < tl; ++i)
        {
            ++l;
            extend(s[i]-'A');
        }
        for(int i = 0; i <= cnt; ++i) dp[i] = 0;
        topo();
        p = root;
        for(int i = 0; i < l; ++i)
        {
            p = t[p].son[s[i]-'A'];
            dp[p]++;
        }
        for(int i = cnt; i >= 1; --i)
        {
            p = r[i];
            if(t[p].fa != -1) dp[t[p].fa] += dp[p];
        }
        ll ans1 = 0, ans2 = 0;
        for(int i = 1; i <= cnt; ++i)
            if(dp[i] >= L)                        //L表示下界
                ans1 += t[i].len-t[t[i].fa].len;
        for(int i = 1; i <= cnt; ++i)
            if(dp[i] >= R+1)                      //R表示上界
                ans2 += t[i].len-t[t[i].fa].len;

        printf("%lld\n", ans1-ans2);           //求出现次数为L~R之间的子串的个数
    }
    return 0;
}