@bzoj - 4378@ [POI2015] Logistyka

目录

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

维护一个长度为 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<=109。

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

@solution@

如果序列中的某个数 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 code@

#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");
		}
	}
}

@details@

一开始找了一个比较复杂的结论，还涉及到线段树上二分等诡异的操作。

大概一两个月过后再去看……这什么玩意儿啊……我怎么看不懂我写了啥啊……

然后翻看题解才看到了这个比较简单的结论。