牛客每日一题3.25 tokitsukaze and Soldier 权值线段树

考虑我们可以怎么获得答案，如果某一个人选了他，那么答案人数的集合就必定小于等于s[i], 对于答案需要的人的集合的人数为num,那么集合里面所有的s[i]的最小值必然是小于等于num。
明确了上述最关键的点后就是可以知道，我们如果答案的人数是2人，则s[i]>=2的全部人数取前2个就是答案，s[i] < 2的被我们排除了。那么解题步骤就是设目标人数是num人，取s[i] >= num的人中权值最大的前num个。
我们就可以从选一个人开始枚举，然后现在要选num人，就可以把s[i]为num-1的人给删掉，因为选取的人数是不断增加的，所以这个被删掉的点在后面也是不可能满足条件的。
接下来的问题就是如果快速的知道一堆人里面权值最大的前k个，我用的是权值线段树。按权值离散化后，一开始把全部的人塞进去，然后根据上面的分析不断删人就可以了。权值线段树找最大的k人就节点维护人数和权值的总和就可以很随意的写出来了。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<time.h>
#include<string>
#include<cmath>
#include<stack>
#include<map>
#include<set>
#define int long long
#define double long double
using namespace std;
#define PI  3.1415926535898
#define eqs 1e-17
const long long max_ = 2e5 + 7;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
const long long INF = 1e18;
int read() {
	int s = 0, f = 1;
	char ch = getchar();
	while (ch<'0' || ch>'9') {
		if (ch == '-')
			f = -1;
		ch = getchar();
	}
	while (ch >= '0'&&ch <= '9') {
		s = s * 10 + ch - '0';
		ch = getchar();
	}
	return s * f;
}
inline void write(int x) {
	if (x < 0) {
		putchar('-');
		x = -x;
	}
	if (x > 9)
		write(x / 10);
	putchar(x % 10 + '0');
}
inline int min(int a, int b) {
	return a < b ? a : b;
}
inline int max(int a, int b) {
	return a > b ? a : b;
}
struct kk{
	int num, val;
}tree_[4 * max_],node[max_];
int yuan[max_],ynn,n;
bool cmp(const kk & t1, const kk & t2) {
	if (t1.num == t2.num)return t1.val > t2.val;
	return t1.num > t2.num;
}
void update(int node, int L, int R, int aim,int no) {
	if (L == R) {
		if (no) {
			tree_[node].num++;
			tree_[node].val += yuan[L];
		}
		else {
			tree_[node].num--;
			tree_[node].val -= yuan[L];
		}
		return;
	}
	int mid = (L + R) >> 1, L_tree = node << 1, R_tree = node << 1 | 1;
	if (mid >= aim)update(L_tree, L, mid, aim,no);
	else update(R_tree, mid + 1, R, aim,no);
	tree_[node].num = tree_[L_tree].num + tree_[R_tree].num;
	tree_[node].val = tree_[L_tree].val + tree_[R_tree].val;
}
int ask(int node, int L, int R, int aim_num) {
	if (aim_num <= 0)return 0;
	if (tree_[node].num == aim_num)return tree_[node].val;
	if (L == R && tree_[node].num >= aim_num) {
		return yuan[L] * aim_num;
	}
	int mid = (L + R) >> 1, L_tree = node << 1, R_tree = node << 1 | 1;
	int t1 = 0, t2 = 0;
	if (tree_[R_tree].num >= aim_num)
		t2 = ask(R_tree, mid + 1, R, aim_num);
	else {
		t1 = ask(L_tree, L, mid , aim_num - tree_[R_tree].num);
		t2 = tree_[R_tree].val;
	}
	return t1 + t2;
}
vector<int> ind[max_];
int bianhao[max_];
signed main() {
	n = read();
	for (int i = 1; i <= n; i++) {
		node[i].val = read();
		node[i].num = read();
		yuan[++ynn] = node[i].val;
		ind[node[i].num].push_back(i);
	}
	sort(yuan + 1, yuan + 1 + ynn);
	ynn = unique(yuan + 1, yuan + 1 + ynn) - yuan - 1;
	
	for (int i = 1; i <= n; i++) {
		int wei = lower_bound(yuan + 1, yuan + 1 + ynn, node[i].val) - yuan; 
		bianhao[i] = wei;
		update(1, 1, ynn, wei,1);
	}
	int ans = ask(1, 1, ynn, 1);
	for (int i = 2; i <= n; i++) {
		for (auto to : ind[i - 1]) {
		update(1, 1, ynn, bianhao[to], 0);
		}
		if (tree_[1].num < i)break;
		int v = ask(1, 1, ynn, i);
		ans = max(v, ans);
	}
	cout << ans;
	return 0;
}