目录
- @[email protected]
- @[email protected]
- @accepted [email protected]
- @[email protected]
@[email protected]
维护一个长度为 n 的序列，一开始都是 0，支持以下两种操作：
1.U k a 将序列中第 k 个数修改为 a。
2.Z c s 在这个序列上，每次选出 c 个正数，并将它们都减去 1，询问能否进行 s 次操作。
每次询问独立，即每次询问不会对序列进行修改。
input
第一行包含两个正整数 n, m (1<=n, m<=1000000)，分别表示序列长度和操作次数。
接下来 m 行为 m 个操作，其中 1<=k, c<=n，0<=a<=10^9，1<=s<=10^9。
output
包含若干行，对于每个 Z 询问，若可行，输出 TAK，否则输出 NIE。
sample input
3 8
U 1 5
U 2 7
Z 2 6
U 3 1
Z 2 6
U 2 2
Z 2 6
Z 2 1
sample output
NIE
TAK
NIE
TAK
@[email protected]
如果序列中的某个数 x > s，因为我们只进行 s 次 -1 的操作，这个数能用到的部分只有 s 这么多。
所以我们可以将序列中所有大于 s 的数修改成 s。
询问能够成立的必要条件是序列所有数之和 >= c*s。
而可以发现，当我们将大于 s 的数修改成 s 过后，如上的条件就变成了充要条件。
证明的话可以使用归纳法。
首先可以发现，每次操作至少保留 c 个正数。分类讨论等于 s 的数的个数：
（1）若等于 s 的数 >= c，显然成立（直接拿这几个数进行操作）。
（2）若等于 s 的数 < c，我们保证选出的 c 个数包含这些等于 s 的数。这样操作完后依然满足所有数之和 >= c*(s-1)且所有数<=(s-1)，就可以归纳证明了。
至于实现，我们并不需要真的把所有大于 s 的数修改成 s，只需要统计大于 s 的数的个数再乘上 s 即可。
可以用平衡树维护，也可以用离散化 + 线段树维护。
@accepted [email protected]
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int MAXN = 1000000;
struct query{
int type, x, y;
}qry[MAXN + 5];
int a[MAXN + 5], d[MAXN + 5];
int n, m, dcnt;
void discrete() {
sort(d+1, d+dcnt+1);
dcnt = unique(d+1, d+dcnt+1) - d - 1;
for(int i=1;i<=m;i++)
if( !qry[i].type )
qry[i].y = lower_bound(d+1, d+dcnt+1, qry[i].y) - d;
}
struct node{
int le, ri;
ll sum; int cnt;
}tree[4*MAXN + 5];
void pushup(int x) {
tree[x].sum = tree[x<<1].sum + tree[x<<1|1].sum;
tree[x].cnt = tree[x<<1].cnt + tree[x<<1|1].cnt;
}
void build(int x, int l, int r) {
tree[x].le = l, tree[x].ri = r;
tree[x].sum = tree[x].cnt = 0;
if( l == r ) {
if( l == 1 ) tree[x].cnt = n;
return ;
}
int mid = (l + r) >> 1;
build(x<<1, l, mid);
build(x<<1|1, mid+1, r);
pushup(x);
}
void modify(int x, int p, int k) {
if( p > tree[x].ri || p < tree[x].le )
return ;
if( tree[x].le == tree[x].ri ) {
tree[x].sum += k*d[tree[x].le];
tree[x].cnt += k;
return ;
}
modify(x<<1, p, k);
modify(x<<1|1, p, k);
pushup(x);
}
ll s; int c;
void query(int x, int p) {
if( d[tree[x].ri] <= p ) s += tree[x].sum;
else if( d[tree[x].le] > p ) c += tree[x].cnt;
else query(x<<1, p), query(x<<1|1, p);
}
char cmd[2];
int main() {
d[dcnt = 1] = 0;
scanf("%d%d", &n, &m);
for(int i=1;i<=m;i++) {
scanf("%s%d%d", cmd, &qry[i].x, &qry[i].y);
if( cmd[0] == ‘U‘ )
qry[i].type = 0, d[++dcnt] = qry[i].y;
else qry[i].type = 1;
}
discrete(); build(1, 1, dcnt);
for(int i=1;i<=n;i++)
a[i] = 1;
for(int i=1;i<=m;i++) {
if( !qry[i].type ) {
modify(1, a[qry[i].x], -1);
a[qry[i].x] = qry[i].y;
modify(1, a[qry[i].x], 1);
}
else {
s = c = 0; query(1, qry[i].y);
puts(1LL*qry[i].x*qry[i].y <= s + 1LL*c*qry[i].y ? "TAK" : "NIE");
}
}
}@[email protected]
一开始找了一个比较复杂的结论，还涉及到线段树上二分等诡异的操作。
大概一两个月过后再去看……这什么玩意儿啊……我怎么看不懂我写了啥啊……
然后翻看题解才看到了这个比较简单的结论。
原文地址：https://www.cnblogs.com/Tiw-Air-OAO/p/10359090.html