#include <bits/stdc++.h>
#define endl '\n'
using namespace std;
const int INF = 1e9 + 7;
const int MAX_N = 1e5 + 5;
//-------------------------------------------------
struct WaveletTree {
private:
struct Node;
void BuildTree(Node *node, int low, int high);
int FindKth(Node *node, int le, int ri, int k);
Node *root;
public:
WaveletTree(const vector< int > &numbers);
int FindKth(int le, int ri, int k);
void Build(const vector< int > &v);
};
struct WaveletTree::Node {
vector< int > a, b;
Node *left, *right;
Node();
};
WaveletTree::Node::Node() : left(nullptr), right(nullptr) {
a.clear();
b.clear();
}
WaveletTree::WaveletTree(const vector< int > &numbers) {
Build(numbers);
}
void WaveletTree::BuildTree(Node *node, int low, int high) {
node -> b.push_back(0);
if(node -> a.size() == 1 || low == high) {
return;
}
int mid = (low + high) / 2, cntSmallerOrEqual = 0;
node -> left = new Node();
node -> right = new Node();
node -> left -> a.push_back(INF);
node -> right -> a.push_back(INF);
for(int num : node -> a) {
if(num == INF) {
continue;
}
if(num <= mid) {
node -> left -> a.push_back(num);
cntSmallerOrEqual++;
}
else {
node -> right -> a.push_back(num);
}
node -> b.push_back(cntSmallerOrEqual);
}
BuildTree(node -> left, low, mid);
BuildTree(node -> right, mid + 1, high);
}
void WaveletTree::Build(const vector< int > &v) {
int maxNum = -INF, minNum = INF;
root = new Node();
root -> a.push_back(INF);
for(int num : v) {
root -> a.push_back(num);
minNum = min(minNum, num);
maxNum = max(maxNum, num);
}
BuildTree(root, minNum, maxNum);
}
int WaveletTree::FindKth(Node *node, int le, int ri, int k) {
if(le == ri) {
return node -> a[le];
}
int goingLeft = node -> b[ri] - node -> b[le - 1];
if(goingLeft >= k) {
return FindKth(node -> left, node -> b[le - 1] + 1, node -> b[ri], k);
}
else {
int newLe = le - node -> b[le - 1];
int newRi = ri - node -> b[ri];
int newK = k - goingLeft;
return FindKth(node -> right, newLe, newRi, newK);
}
}
int WaveletTree::FindKth(int le, int ri, int k) {
return FindKth(root, le, ri, k);
}
//-------------------------------------------------
int fromNewToOld[MAX_N];
void Compress(vector< int > &v) {
vector< int > numbers = v;
sort(numbers.begin(), numbers.end());
for(int i = 0; i < v.size(); i++) {
int oldValue = v[i];
v[i] = lower_bound(numbers.begin(), numbers.end(), oldValue) - numbers.begin() + 1;
fromNewToOld[v[i]] = oldValue;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector< int > v(n);
for(int i = 0; i < n; i++) {
cin >> v[i];
}
Compress(v);
WaveletTree waveletTree = WaveletTree(v);
for(int i = 0; i < m; i++) {
int le, ri, k;
cin >> le >> ri >> k;
cout << fromNewToOld[waveletTree.FindKth(le, ri, k)] << endl;
}
return 0;
}
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