|
|
// http: // poj.org/problem?id=2104
|
|
|
//#include <bits/stdc++.h>
|
|
|
#include <iostream>
|
|
|
#include <string.h>
|
|
|
#include <stdio.h>
|
|
|
#include <vector>
|
|
|
#include <map>
|
|
|
#include <queue>
|
|
|
#include <algorithm>
|
|
|
#include <math.h>
|
|
|
#include <cstdio>
|
|
|
|
|
|
const int N = 100010;
|
|
|
using namespace std;
|
|
|
|
|
|
//建立一颗权值线段树，每个点存储的信息为该值域区间存在的数的个数
|
|
|
struct Node {
|
|
|
int l, r; //分别表示左右节点编号
|
|
|
int cnt; //区间内数字个数
|
|
|
} tr[N * 4 + N * 17]; //初始骨架N * 4 再加上最多M次插入一共修改MlogM个节点
|
|
|
//也见过有的大佬说，直接开N*32就行
|
|
|
|
|
|
vector<int> nums; //用于离散化的数组,由于数的范围很大，但是不能开那么大的空间，所以需要离散化
|
|
|
int root[N], idx; // root记录根节点的版本号【root[r]表示插入了第r个数版本的线段树】, idx记录树节点的版本号
|
|
|
int a[N]; //原始数组
|
|
|
int n, m;
|
|
|
|
|
|
//离散化二分查找
|
|
|
int find(int x) {
|
|
|
return lower_bound(nums.begin(), nums.end(), x) - nums.begin();
|
|
|
}
|
|
|
|
|
|
//构建新版本的线段树,返回新创建的节点号
|
|
|
//注意里与普通版本的线段树不一样，普通线段树是的左儿子编号是父亲的编号*2，右儿子的编号是父亲的编号*2+1
|
|
|
//而主席树的节点编号是通过tot++随用随算的，因为多个版本，不能沿用原来的处理办法，那样就空着内存节点的太多了
|
|
|
int build(int l, int r) { // l,r是指数据管辖区间
|
|
|
int p = ++idx; //生成节点号
|
|
|
if (l == r) return p; //到叶子节点,直接返回新产生的节点号，不再递归
|
|
|
int mid = (l + r) >> 1; // 2x,2x+1，静态线段树构建办法
|
|
|
tr[p].l = build(l, mid); //构建左子树
|
|
|
tr[p].r = build(mid + 1, r); //构建右子树
|
|
|
return p;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @brief 对原始数据，通过一个一个的insert方式存入主席树，以达到生成每个版本线段树的目标
|
|
|
*
|
|
|
* @param p 上一个版本的版本号
|
|
|
* @param l
|
|
|
* @param r
|
|
|
* @param x
|
|
|
* @return int
|
|
|
*/
|
|
|
int insert(int p, int l, int r, int x) {
|
|
|
int q = ++idx; // 1、获取到可用节点编号
|
|
|
tr[q] = tr[p]; // 2、旧版本啥样我啥样
|
|
|
if (l == r) { // 3、第x大位置的数字个数增加了1个
|
|
|
tr[q].cnt++;
|
|
|
return q;
|
|
|
}
|
|
|
int mid = (l + r) >> 1;
|
|
|
if (x <= mid) // 4、x小于等于mid，向左半部递归
|
|
|
tr[q].l = insert(tr[p].l, l, mid, x);
|
|
|
else // 5、x大于mid,向右半部递归
|
|
|
tr[q].r = insert(tr[p].r, mid + 1, r, x);
|
|
|
|
|
|
//更新区间内数字个数,相当于pushup
|
|
|
tr[q].cnt = tr[tr[q].l].cnt + tr[tr[q].r].cnt;
|
|
|
return q; //返回新创建的节点编号
|
|
|
}
|
|
|
/**
|
|
|
* @brief 在q这个版本的线段树中，它的前序版本是p，管辖范围是[l,r],求第k小数
|
|
|
*
|
|
|
* @param q 当前版本号
|
|
|
* @param p 前序版本号
|
|
|
* @param l 左边界
|
|
|
* @param r 右边界
|
|
|
* @param k 第k小
|
|
|
* @return int 是什么数字
|
|
|
*/
|
|
|
int query(int q, int p, int l, int r, int k) {
|
|
|
if (l == r) return r; //到叶子节点了，返回是第l个数字，nums返回原始数字
|
|
|
//当前版本左儿子区间内的数字个数，减去，前序版本左儿子区间内的数字个数，
|
|
|
//描述了在从l到r这两个版本间增加的数字数量，类似于前缀和思想
|
|
|
int cnt = tr[tr[q].l].cnt - tr[tr[p].l].cnt;
|
|
|
int mid = (l + r) >> 1;
|
|
|
if (k <= cnt)
|
|
|
return query(tr[q].l, tr[p].l, l, mid, k);
|
|
|
else
|
|
|
return query(tr[q].r, tr[p].r, mid + 1, r, k - cnt);
|
|
|
}
|
|
|
|
|
|
int main() {
|
|
|
cin >> n >> m;
|
|
|
for (int i = 1; i <= n; i++) {
|
|
|
cin >> a[i];
|
|
|
nums.push_back(a[i]);
|
|
|
}
|
|
|
//离散化 为什么要离散化？是因为值域范围1e9，太大
|
|
|
sort(nums.begin(), nums.end());
|
|
|
nums.erase(unique(nums.begin(), nums.end()), nums.end());
|
|
|
|
|
|
//构建版本0,只有版本0需要构建
|
|
|
//因为离散化后的范围区间是0~nums.size()-1
|
|
|
//看来构建线段树的l,r其实是指的原始数组的索引位置
|
|
|
root[0] = build(0, nums.size() - 1);
|
|
|
|
|
|
//构建不同版本的线段树
|
|
|
for (int i = 1; i <= n; i++)
|
|
|
// 1、每个新版本，都只能在上一个版本基础上进行修改获取到
|
|
|
// 2、现在这个新版本，也和上一个版本的范围是一样的，也是[0,nums.size()-1]
|
|
|
// 3、find(a[i])：通过二分获取a[i]这个数据现在离散化后所在的位置
|
|
|
root[i] = insert(root[i - 1], 0, nums.size() - 1, find(a[i]));
|
|
|
|
|
|
while (m--) {
|
|
|
int l, r, k;
|
|
|
cin >> l >> r >> k;
|
|
|
//查询[l,r]区间中的第k大数，利用前缀和的思想,从[l ~ r]中的数据剔除掉[1 ~ l-1]的数据,
|
|
|
//不同版本的线段树的结构都是一样的，所以初始都是从0到nums.size()这个范围当中找
|
|
|
printf("%d\n", nums[query(root[r], root[l - 1], 0, nums.size() - 1, k)]);
|
|
|
}
|
|
|
return 0;
|
|
|
} |
