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\n");
            else
                printf("%d\n",kt.ask(1,len,k,kt.root[tl - 1],kt.root[tr]));
        }
    }
    return 0;
}