一、题目大意

长度为n（n<=100000）的数组，进行m次查询（m<=5000），每次查询时，输入为 i j k，返回为数组 [i,j] 的分片里第k大数字（1<=i<=j<=n,k<=j-i+1)

二、解题思路

如果采用朴素的方法去计算，针对每次的i 和 j，从 i 到 j 循环把数组的元素放在一个tmp数组里，然后给tmp数组排序，输出tmp[k]的话，在最差情况下，时间复杂性为 O ( m * n * log(n) )，也就是10000000000左右，肯定是行不通的。

于是考虑使用平方分割，按 floor(sqrt(n))为一块，分成根号n块，然后把每一块的数字进行排序，根据查询的 i 和 j，找出 i 和 j 范围内所有的块，然后把 块未覆盖到的左边的和右边范围内放在一个 other数组里，把other数组排序。

这时相当于得到多个有序的块，然后我们需要找到这些块合并在一起后的第k大的，朴素的合并多的话，还是会很慢（合并两个有序数组为一个的操作次数，为其中大的数组的长度），所以考虑二分，可以对数组内所有的元素进行排序。

设一开始输入的数组为dat，那么我们把dat排序后作为sortedDat，然后 L = -1,R=n（二分时候的 l 和 r 是达不到的，都取开区间）当L+1 < R时循环，mid = (L+R)/2，然后我们再循环对这些块来使用二分，找到所有块中小于sortedDat[mid]的数量和cnt，如果cnt<k，则L=mid，否则R=mid，这样的话，最终的临界情况就是，所有块中，小于sortedDat[L]的元素为k-1个，小于sortedDat[L+1]的元素为k个，此时，sortedDat[L]就是当前区间里第k大的数。

考虑下复杂性 O(log(n)*sqrt(n)*log(n)*m)，好像是可以的，但实际并不如此。

此时我们需要对算法进行优化，如何优化呢？考虑下比较糟糕的情况，假如n=100000，则我们会分316块，假设涉及的区间包含200块，那么每次二分，循环200次，然后200次循环里还有2分，起始也可能会比较慢，所以我们考虑如何把200个小块合并，假设2个相邻的合并成一个，改成100的话，速度可以快一倍。

于是我们可以在起初分桶的时候，按2 * floor(sqrt(n)) 来分一些大块，然后对这些块也都进行排序，一个大块相当于2个小块。

于是我们执行每次查询时需要进行的操作为：

1、根据区间 i j 找到包含的桶

2、根据找到的桶，来处理不在桶内，而且被 i 和 j 包含的区间，对此区域排序并记录长度。

3、循环包含的桶，如果 两个相邻的小桶可以被一个大桶替换的话，则用这个大桶替换掉小桶，依据此思路，把所有的小桶都用大桶替换。

4、 对sortedDat里面的数进行二分，L = -1,R=n，针对每次的mid，循环里利用二分找到所有涉及的小桶、大桶和其他区域里小于 sortedDat[mid]的数量总和cnt，如果cnt小于k，则L=mid，否则R=mid，循环结束时，输出sortedDat[L]即可

（如果不涉及到任何桶，那直接输出other[k-1]即可，不用走二分这个思路）

（然后利用大桶替换小桶时，可以循环涉及的小桶，如果它不是涉及到的最后一个，且它的下标 i是偶数，则它和它的下一个被一个大桶替换，否则的话这个桶保留，简单的思路就是定义一个变量i=0，设当前区间涉及的小桶数量为bucketLen，保存当前区间相关的桶的数组为bucket，然后 i < bucketLen时候循环，如果i+1小于bucketLen且bucket[i]%2==0，那么就把 i /2记录为当前涉及的大桶 bucketBig[bigLen++]=i/2，然后i +=2，否则就把 bucket[i]加到队列里，最后把不在队列里的小桶都去掉，把队列里的小桶记录下来为替换后涉及到的小桶，然后大桶就是bucketBig里的大桶）

（我针对桶的下标从0开始计算，然后下标 i 的小桶的区间为 [ i * 根号n , (i + 1) * 根号n)，下标 i 的大桶的区间为[ 2 *  i * 根号n , (i + 1) * 2 * 根号n)，这样的话大桶 i /2就代表小桶 i 和 i + 1，需要i%2==0 ）

优化之后，就侥幸过了

三、代码

#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
int bucket[320][320];
int bucket_1[160][640];
int dat[100009], sortedDat[100009], n, bQue[320], queLen, bQue_1[160], queLen_2, b, otherLen, other[100009];
queue<int> que;
void input()
{
    for (int i = 0; i < n; i++)
    {
        scanf("%d", &dat[i]);
        sortedDat[i] = dat[i];
    }
    sort(sortedDat, sortedDat + n);
}
void bucketMethod()
{
    b = 1;
    while (b * b <= n)
    {
        b++;
    }
    b--;
    for (int i = 0; ((i + 1) * b) <= n; i++)
    {
        for (int j = 0; j < b; j++)
        {
            bucket[i][j] = dat[j + (i * b)];
        }
        sort(bucket[i], bucket[i] + b);
    }
    for (int i = 0; ((i + 1) * 2 * b) <= n; i++)
    {
        for (int j = 0; j < (2 * b); j++)
        {
            bucket_1[i][j] = dat[j + (i * b * 2)];
        }
        sort(bucket_1[i], bucket_1[i] + (2 * b));
    }
}
void findBucket(int L, int R)
{
    queLen = 0;
    for (int i = 0; ((i + 1) * b) <= n; i++)
    {
        if ((i * b) >= L && ((i + 1) * b) <= R)
        {
            bQue[queLen++] = i;
        }
    }
}
void handleOther(int L, int R)
{
    otherLen = 0;
    if (queLen == 0)
    {
        for (int i = L; i < R; i++)
        {
            other[otherLen++] = dat[i];
        }
    }
    else
    {
        for (int i = L; i < (bQue[0] * b); i++)
        {
            other[otherLen++] = dat[i];
        }
        for (int i = ((bQue[queLen - 1] + 1) * b); i < R; i++)
        {
            other[otherLen++] = dat[i];
        }
    }
    if (otherLen > 0)
    {
        sort(other, other + otherLen);
    }
}
void findBucketPlus()
{
    queLen_2 = 0;
    if (queLen == 0)
    {
        return;
    }
    while (!que.empty())
    {
        que.pop();
    }
    int i = 0;
    while (i < queLen)
    {
        if ((i + 1) < queLen && (bQue[i] % 2 == 0))
        {
            bQue_1[queLen_2++] = bQue[i] / 2;
            i += 2;
        }
        else
        {
            que.push(bQue[i]);
            i++;
        }
    }
    if (queLen_2 != 0)
    {
        queLen = 0;
        while (!que.empty())
        {
            int _front = que.front();
            que.pop();
            bQue[queLen++] = _front;
        }
    }
}
int binarySearch(int *arr, int len, int num)
{
    int l = -1, r = len;
    while (l + 1 < r)
    {
        int mid = (l + r) / 2;
        if (arr[mid] < num)
        {
            l = mid;
        }
        else
        {
            r = mid;
        }
    }
    return (l + 1);
}
void solve(int k)
{
    if (queLen == 0 && queLen_2 == 0)
    {
        printf("%d\n", other[k - 1]);
        return;
    }
    int l = -1, r = n;
    while (l + 1 < r)
    {
        int mid = (l + r) / 2;
        int cnt = 0;
        for (int i = 0; i < queLen; i++)
        {
            cnt = cnt + binarySearch(bucket[bQue[i]], b, sortedDat[mid]);
        }
        for (int i = 0; i < queLen_2; i++)
        {
            cnt = cnt + binarySearch(bucket_1[bQue_1[i]], 2 * b, sortedDat[mid]);
        }
        if (otherLen > 0)
        {
            cnt = cnt + binarySearch(other, otherLen, sortedDat[mid]);
        }
        if (cnt < k)
        {
            l = mid;
        }
        else
        {
            r = mid;
        }
    }
    printf("%d\n", sortedDat[l]);
}
int main()
{
    int m, i, j, k;
    while (~scanf("%d%d", &n, &m))
    {
        input();
        bucketMethod();
        while (m--)
        {
            scanf("%d%d%d", &i, &j, &k);
            findBucket(i - 1, j);
            handleOther(i - 1, j);
            findBucketPlus();
            solve(k);
        }
    }
    return 0;
}