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;
    }