考虑我们可以怎么获得答案,如果某一个人选了他,那么答案人数的集合就必定小于等于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;
}