CodeForces - 1227D2(树状数组)

D2. Optimal Subsequences (Hard Version)

This is the harder version of the problem. In this version, 1≤n,m≤2⋅105. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems.

You are given a sequence of integers a=[a1,a2,…,an] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:

[11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
[40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1≤k≤n) is given, then the subsequence is called optimal if:

it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b1,b2,…,bk] is lexicographically smaller than the sequence c=[c1,c2,…,ck] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1≤t≤k) such that b1=c1, b2=c2, …, bt−1=ct−1 and at the same time bt<ct. For example:

[10,20,20] lexicographically less than [10,21,1],
[7,99,99] is lexicographically less than [10,21,1],
[10,21,0] is lexicographically less than [10,21,1].
You are given a sequence of a=[a1,a2,…,an] and m requests, each consisting of two numbers kj and posj (1≤k≤n, 1≤posj≤kj). For each query, print the value that is in the index posj of the optimal subsequence of the given sequence a for k=kj.

For example, if n=4, a=[10,20,30,20], kj=2, then the optimal subsequence is [20,30] — it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request kj=2, posj=1 is the number 20, and the answer to the request kj=2, posj=2 is the number 30.

Input
The first line contains an integer n (1≤n≤2⋅105) — the length of the sequence a.

The second line contains elements of the sequence a: integer numbers a1,a2,…,an (1≤ai≤109).

The third line contains an integer m (1≤m≤2⋅105) — the number of requests.

The following m lines contain pairs of integers kj and posj (1≤k≤n, 1≤posj≤kj) — the requests.

Output
Print m integers r1,r2,…,rm (1≤rj≤109) one per line: answers to the requests in the order they appear in the input. The value of rj should be equal to the value contained in the position posj of the optimal subsequence for k=kj.

Examples
input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
output
20
10
20
10
20
10
input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:

for k=1: [20],
for k=2: [10,20],
for k=3: [10,20,10].

题意：
给定一个n长度的序列，m次操作，每次操作要求求出一个长度为k的子序列，该子序列要求总和最大，字典序最小，然后求该子序列第j个数是几。
数组数组对数列就行单点修改和求前缀和即可。
先对n个数排序，再对所求m次操作的长度进行排序，长度由小到大，然后逐个插点，先将最大的数插进去（该操作可满足总和最大），如果两个数同样大，先插位置靠后的（该操作可以满足字典序最小），然后每次插完，判断能不能回答一部分操作的问题，对于当前操作的问题，二分查找第j个位置的数即可。

#include<stdio.h>
#include<algorithm>
using namespace std;
const int N=200500;
int n,m;
int sum[N],ans[N],c[N];
struct node1 {
	int x,i;
	friend bool operator<(const node1 e,node1 f) {
		if(e.x==f.x) {
			return e.i>f.i;
		}
		return e.x<f.x;
	}
} a[N];
struct node2 {
	int k,pos,i;
	friend bool operator<(const node2 e,node2 f) {
		return e.k<f.k;
	}
} zz[N];
void add(int x,int y) {
	for(; x<=n; x+=x&-x)c[x]+=y;
}
int ask(int x) {
	int ans=0;
	for(; x; x-=x&-x) {
		ans+=c[x];
	}
	return ans;
}
int solve(int x) {
	int l=1,r=n;
	while(l<r) {
		int mid=(l+r)/2;
		if(ask(mid)>=x) {
			r=mid;
		} else {
			l=mid+1;
		}
	}
	return sum[l];
}
int main() {
	scanf("%d",&n);
	for(int i=1; i<=n; ++i) {
		int x;
		scanf("%d",&x);
		a[i].x=x;
		a[i].i=i;
		sum[i]=x;
	}
	sort(a+1,a+n+1);
	scanf("%d",&m);
	for(int i=1; i<=m; ++i) {
		scanf("%d %d",&zz[i].k,&zz[i].pos);
		zz[i].i=i;
	}
	sort(zz+1,zz+m+1);
	int cut=1;
	for(int i=n; i; --i) {
		add(a[i].i,1);
		while(cut<=m&&zz[cut].k==n-i+1) {
			ans[zz[cut].i]=solve(zz[cut].pos);
			cut++;
		}
	}
	for(int i=1; i<=m; ++i) {
		printf("%d\n",ans[i]);
	}
	return 0;
}

一杯可乐一支烟，一个bug调一天（我好菜）。