hdu 6704 K-th occurrence 二分 ST表 后缀数组 主席树

我们考虑，一个子串必定是某个后缀的前缀。

排序相邻的后缀他们的前缀一定最相似。

所以全部的一种子串必定是一些排序相邻的后缀的公共前缀。

从l开始的子串，则从rank[l]开始看，两侧height保证大于子串长度，能延伸多长，则证明有多少个这种子串。

我们用ST表维护出height的最小值，然后通过最小值二分即可，边界有些棘手。

然后我们就得到了一个height不小于子串长度的连续区间，这个区间是以原后缀的字典序排序的。

而同时，sa数组下标为排序，值为原串位置。

所以我们对这个区间在sa数组上做主席树，求第k大，即为第k个子串出现的位置。

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
const int MAXN = 101000;
char str[MAXN];
int len,q,T,m,uni[30];
struct ktree
{
    int n,cnt;
    int root[MAXN];
    int ls[MAXN * 40],rs[MAXN * 40],s[MAXN * 40];
//插入一个新的版本，参数分别为左右区间，最近的历史版本，现在的版本，插入的值
//k值加一个引用可以完美的处理新子节点的序号分配问题。
//s数组记录了对应序号子树的元素个数
    void insert(int l,int r,int pre,int &k,int v)
    {
        k = ++cnt;
        s[k] = s[pre] + 1;
        if (l == r)
            return;
        int mid = (l + r) >> 1;
        //由于我们ｋ值传了引用参，所以这里可以直接将左右节点全部赋上值。
        ls[k] = ls[pre];
        rs[k] = rs[pre];
        //根据情况来进行左右递归。
        if (v <= mid)
            insert(l,mid,ls[pre],ls[k],v);
        else
            insert(mid + 1,r,rs[pre],rs[k],v);
    }
//查询x,y两个历史版本的权值线段树相减的得到新的线段树中的第k大
//这里我们考虑一下，如果我们求区间[x,y]的第k大。那么显然第x-1个版本相当于[1,x-1]的权值线段树，那么我们用第y个版本的线段树-第x-1个版本的线段树，得到就相当于是[x,y]区间得到的权值线段树，然后我们可以在这棵线段树上进行开心的查询。
    int ask(int l,int r,int k,int x,int y)
    {
        if (l == r)
            return l;
        int mid = (l + r) >> 1;
        if (s[ls[y]] - s[ls[x]] >= k)
            return ask(l,mid,k,ls[x],ls[y]);
        return ask(mid + 1,r,k - (s[ls[y]] - s[ls[x]]),rs[x],rs[y]);
    }
    void build(int _n,int *vec)
    {
        n = _n;
        for (int i = 1; i <= n; i++)
            insert(1,n,root[i - 1],root[i],vec[i]);
    }
    void clear()
    {
        for (int i = 1; i <= cnt; i++)
            s[i] = ls[i] = rs[i] = 0;
        for (int i = 0; i <= n; i++)
            root[i] = 0;
        n = 0;
        cnt = 0;
    }
} kt;
struct suffixvec
{
    int c[MAXN],sa[MAXN],rnk[MAXN],height[MAXN],tp[MAXN];
    int m,len;
    char str[MAXN];
    void build(int _len,char *s)
    {
        len = _len;
        strcpy(str + 1,s + 1);//因为要从1开始 
    }
    void clear()
    {
        for (int i = 1; i <= len; i++)
            sa[i] = rnk[i] = height[i] = 0;
    }
    void qsort()
    {
        for (int i = 0; i <= m; i++)
            c[i] = 0;
        for (int i = 1; i <= len; i++)
            c[rnk[i]]++;
        for (int i = 1; i <= m; i++)
            c[i] += c[i - 1];
        for (int i = len; i >= 1; i--)
            sa[c[rnk[tp[i]]]--] = tp[i];
    }
    void get_sa()
    {
        m = 200;
        for (int i = 1; i <= len; i++)
        {
            rnk[i] = str[i];
            tp[i] = i;
        }
        qsort();
        for (int k = 1,p = 0; p < len; m = p,k <<= 1)
        {
            p = 0;
            for (int i = 1; i <= k; i++)
                tp[++p] = len - k + i;
            for (int i = 1; i <= len; i++)
                if (sa[i] > k)
                    tp[++p] = sa[i] - k;
            qsort();
            swap(tp,rnk);
            rnk[sa[1]] = p = 1;
            for (int i = 2; i <= len; i++)
                rnk[sa[i]] = (tp[sa[i - 1]] == tp[sa[i]] && tp[sa[i - 1] + k] == tp[sa[i] + k]) ? p : ++p;
        }
    }
    int solve(int x,int y)
    {
        int res = 0;
        while (str[x++] == str[y++])
            res++;
        return res;
    }
    void get_height()
    {
        int cur = 0;
        for (int i = 1; i <= len; i++)
        {
            if (cur != 0)
                cur--;
            height[rnk[i]] = cur = cur + solve(i + cur,sa[rnk[i] + 1] + cur);
        }
    }
} sf;
struct stable
{
    int p[MAXN][30];
    int len;
    void init(int _len,int *vec)
    {
        len = _len;
        int tp = log2(len);
        for (int i = 1; i <= len; i++)
            p[i][0] = vec[i];
        for (int i = 1; i <= tp; i++)
            for (int j = 1; j + uni[i] - 1 <= len; j++)
                p[j][i] = min(p[j][i - 1],p[j + uni[i - 1]][i - 1]);
    }
    int querymin(int l,int r)
    {
        int tp = log2(r - l + 1);
        return min(p[l][tp],p[r - uni[tp] + 1][tp]);
    }
} st;
int tdl(int x,int lt)
{
    int l = 1,r = x;
    while (l < r)
    {
        int mid = l + r >> 1;
        if (st.querymin(mid,x) >= lt)
            r = mid;
        else
            l = mid + 1;
    }
    return l;
}
int tdr(int x,int lt)
{
    int l = x,r = len;
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (st.querymin(x,mid) >= lt)
            l = mid;
        else
            r = mid - 1;
    }
    return l;
}

int main()
{
    uni[0] = 1;
    for (int i = 1; i <= 25; i++)
        uni[i] = uni[i - 1] << 1;
    for(scanf("%d",&T); T != 0; T--)
    {
        scanf("%d%d",&len,&q);
        scanf("%s",str + 1);
        sf.clear();
        sf.build(len,str);
        sf.get_sa();
        sf.get_height();
        st.init(sf.len,sf.height);
        kt.clear();
        kt.build(len,sf.sa);
        int l,r,k,tl,tr;
        for (int i = 1; i <= q; i++)
        {
            scanf("%d%d%d",&l,&r,&k);
            if (sf.height[sf.rnk[l] - 1] < r - l + 1)
                tl = sf.rnk[l];
            else
                tl = tdl(sf.rnk[l] - 1,r - l + 1);
            if (sf.height[sf.rnk[l]] < r - l + 1)
                tr = sf.rnk[l];
            else
                tr = tdr(sf.rnk[l],r - l + 1) + 1;
            if (k > kt.s[kt.root[tr]] - kt.s[kt.root[tl - 1]])
                printf("-1
");
            else
                printf("%d
",kt.ask(1,len,k,kt.root[tl - 1],kt.root[tr]));
        }
    }
    return 0;
}