ccpc网络赛补题C.K-th occurrence

最近补完3个自动机、后缀数组和区间第K大(主席树用法的一种)终于可以去做当时CCPC的劝退题。
后缀数组sa让相似的后缀连起来,相当于也是将片段连起来，然后用sa建主席树准备询问区间第k大，使用rank对要询问的开头进行索引快速定位，确定相同子串区间中一点，然后利用Sparse-Table处理height数组快速询问区间内的最小值，最小值不能小于子串的长度，然后基于这个二分确定区间第k大的询问区间的左界与右界。(此处边界细节有点毒瘤。。)
然后询问即可
suffix_array形成o(nlogn)
二分定界o(logn)
询问o(logn)

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

int uni[30];
const int maxn = 100000 + 10;
struct SuffixArray
{
    char s[maxn];     // 原始字符数组（最后一个字符应必须是0，而前面的字符必须非0）
    int sa[maxn];     // 后缀数组
    int rank[maxn];   // 名次数组. rank[0]一定是n-1，即最后一个字符
    int height[maxn]; // height数组
    int t[maxn], t2[maxn], c[maxn]; // 辅助数组
    int n; // 字符个数

    void clear()
    {
        n = 0;
        memset(sa, 0, sizeof(sa));
        memset(height, 0, sizeof(height));
    }

    // m为最大字符值加1。调用之前需设置好s和n
    void build_sa(int m)
    {
        int i, *x = t, *y = t2;
        for(i = 0; i < m; i++) c[i] = 0;
        for(i = 0; i < n; i++) c[x[i] = s[i]]++;
        for(i = 1; i < m; i++) c[i] += c[i - 1];
        for(i = n - 1; i >= 0; i--) sa[--c[x[i]]] = i;
        for(int k = 1; k <= n; k <<= 1)
        {
            int p = 0;
            for(i = n - k; i < n; i++) y[p++] = i;
            for(i = 0; i < n; i++) if(sa[i] >= k) y[p++] = sa[i] - k;
            for(i = 0; i < m; i++) c[i] = 0;
            for(i = 0; i < n; i++) c[x[y[i]]]++;
            for(i = 0; i < m; i++) c[i] += c[i - 1];
            for(i = n - 1; i >= 0; i--) sa[--c[x[y[i]]]] = y[i];
            swap(x, y);
            p = 1;
            x[sa[0]] = 0;
            for(i = 1; i < n; i++)
                x[sa[i]] = y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k] ? p - 1 : p++;
            if(p >= n) break;
            m = p;
        }
    }
    
    void build_height()
    {
        int i, j, k = 0;
        for(i = 0; i < n; i++) rank[sa[i]] = i;
        for(i = 0; i < n; i++)
        {
        	if (!rank[i]) continue; 
            if(k) k--;
            int j = sa[rank[i] - 1];
            while(s[i + k] == s[j + k]) k++;
            height[rank[i]] = k;
        }
    }
};

SuffixArray sa;

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 query(int l,int r)
    {
        int tp = log2(r - l + 1);
        return min(p[l][tp],p[r - uni[tp] + 1][tp]);
    }
} st;
 
struct Node{
	int l,r;
	int cnt;
}pool[20*maxn];
 
int a[maxn],sorta[maxn],n,m,i,j,d[maxn],cur = 1,tot = 0;
 
void maintain(int o)
{
	pool[o].cnt = pool[pool[o].l].cnt + pool[pool[o].r].cnt;
}
 
int Build (int l,int r)
{
	int k = ++tot;
	if (l == r)
	{
		pool[k].cnt = 0;
		return k;
	}
	int mid = (l+r) >> 1;
    pool[k].l = Build (l,mid);
    pool[k].r = Build (mid+1,r);
    maintain(k);
    return k;
}
 
int Insert (int o,int l,int r,int pos)
{
	int k = ++tot;
	pool[k] = pool[o];
	if (l == pos && r == pos)
	{
		++pool[k].cnt;
		return k;
	}
	int mid = (l+r) >> 1;
	if (pos <= mid) pool[k].l = Insert(pool[o].l,l,mid,pos);
	else pool[k].r = Insert(pool[o].r,mid+1,r,pos);
	maintain(k);
	return k;
}
 
int query (int l,int r,int L,int R,int k)
{
	if (l == r) return l;
	int DT = pool[pool[R].l].cnt - pool[pool[L].l].cnt;
	int mid = (l+r) >> 1;
	if (DT >= k) return query(l,mid,pool[L].l,pool[R].l,k);
	else return query(mid+1,r,pool[L].r,pool[R].r,k-DT);
}
 
int main()
{
	uni[0] = 1;
    for (int i = 1; i <= 25; i++)
        uni[i] = uni[i - 1] << 1;
	int T;
	scanf("%d", &T);
	while (T--)
	{
		scanf("%d %d", &n, &m);
		scanf("%s", sa.s);
		sa.clear();
		sa.n = n + 1;
		sa.build_sa('z' + 1);
		sa.build_height();
		st.init(n, sa.height);
		/*
		pool[20*maxn];
		int a[maxn],sorta[maxn],n,m,i,j,d[maxn],cur = 1,tot = 0;
		*/
		memset(pool, 0, sizeof(pool));
		memset(d, 0, sizeof(d));
		cur = 1;
		tot = 0;
		for (i = 1; i <= n; i++)
		{
			a[i] = sa.sa[i];
			sorta[i] = a[i];
		}
		sort(sorta + 1,sorta + n + 1);
		for (i = 2; i <= n; i++)
		  	if (sorta[i] != sorta[i-1])
		    	sorta[++cur] = sorta[i];
		d[0] = Build(1,cur);
		for (i = 1; i <= n; i++)
		{
			int pos = lower_bound (sorta + 1,sorta + n + 1,a[i]) - sorta;
			d[i] = Insert (d[i-1],1,cur,pos);
		}
		while (m--)
		{
			int x,y,k;
			scanf("%d%d%d",&x,&y,&k);
			int len = y - x + 1;
			int mid = sa.rank[x - 1];
			int L, R, l, r;
			if (sa.height[mid] < len)
				l = mid;
			else
			{
				L = 1, R = mid + 1;
				while (L < R)
				{
					int M = L + ((R - L) >> 1);
					if (st.query(M, mid) >= len) R = M;
					else L = M + 1;
				}
				l = L - 1;
			}
			if ((mid < n && sa.height[mid + 1] < len) || mid == n)
				r = mid;
			else
			{
				L = mid + 1;
				R = n + 1;
				while (L < R)
				{
					int M = L + ((R - L) >> 1);
					if(st.query(mid + 1, M) >= len) L = M + 1;
					else R = M;
				}
				r = L - 1;
			}
			if (r - l + 1 >= k)
			{
				int pos = query(1, cur, d[l - 1], d[r], k);
				printf("%d\n", sorta[pos] + 1);
			}
			else
			{
				printf("-1\n");
			}
		}
	}
	return 0;
}
/*
2
12 6
aaabaabaaaab
3 3 4
2 3 2
7 8 3
3 4 2
1 4 2
8 12 1
1 1
a
1 1 1

1
12 1
aaabaabaaaab
8 12 1
*/

不得不说大二开始学算法真心累。但是没办法，就是喜欢，不管我多辣鸡，我都喜欢这个。转眼一年过去，在不断解题和搜题解的过程中，知道世界有多大、各路神犇的传奇。当时真是不知道天高地厚去参加CCPC网络赛，一个下午才做3道签到题。关键是结束后，以我的能耐撑死才补了一道题。。。最坑爹的是剩下所有题的题解居然一个都看不懂。。。什么后缀自动机。。什么主席树。。什么狄利克雷卷积杜教筛。。。对于当时的我来说就像怪兽一样。。。
CCPC的网络赛居然这么难(一切都是当事人太蔡了的错TvT)按照c题的时空要求，要使用后缀自动机或后缀数组+Sparse-Table(RMQ)+二分+可持久化线段树(主席树)才能达标，关键是知道了思路后还要处理坑爹的边界。代码量也大，几个板子之间衔接也麻烦。
关键是当时天真的我居然妄想用KMP做出这题。。。只会一点算法加暴力的我实在是太low了，太low了，太low了。low到连时间复杂度预算都没有B数。。看着肯定过不了的方法强行去提交。结果当然很显然。
这就是某种劝退，于是当时的一个队友就退了。他知道CCPC和ACM什么的以我们队的水准肯定白忙一场，还不如好好做项目找工作现实，但我就是认为我是井底之蛙。。我想去看看外面的世界，一直都没有停下。于是二十天前银川区域赛打铁，如果当时准备好的板子就有铜，但也只是铜，而万事也没有如果，但好歹，我见识到了某种峥嵘。并准备参加明年的ACM。坚决不能再打铁了TvT。