@loj - 2174@ 「FJOI2016」神秘数

目录

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

---

@description@

一个可重复数字集合 S 的神秘数定义为最小的不能被 S 的子集的和表示的正整数。例如：

S = {1,1,1,4,13}

1 = 1

2 = 1+1

3 = 1+1+1

4 = 4

5 = 4+1

6 = 4+1+1

7 = 4+1+1+1

8 无法表示为集合 S 的子集的和，故集合 S 的神秘数为 8。

现给定 n 个正整数 a1 ... an， m 个询问，每次询问给定一个区间 [l, r] (l <= r)，求由 al ... ar 所构成的可重复数字集合的神秘数。

输入格式

第一行一个整数 n，表示数字个数。

第二行 n 个整数，从 1 编号。

第三行一个整数 m，表示询问个数。

以下 m 行，每行一对整数 l, r，表示一个询问。

输出格式

对于每个询问，输出一行对应的答案。

样例输入

5

1 2 4 9 10

5

1 1

1 2

1 3

1 4

1 5

样例输出

2

4

8

8

8

数据范围与提示

对于 100% 的数据点， n, m <= 100000，∑a = 10^9。

@solution@

不妨先看对于一个集合怎么快速求它的 “神秘数”。

众所周知子集和问题是 NPC 的，所以这个 “神秘数” 肯定是具有一定性质的。

我们考虑一个个加入元素。假如加入某一元素 x 时，此时的 “神秘数” 为 k。

如果用上 x 也无法拼出 k，则要么 x > k，要么 k - x 在加入 x 之前也无法被拼出。又因为 k 是最小的，只能说明 x > k。

如果我们从小到大考虑一个集合内的所有元素，且 x > k，则 x 以后也 > k。此时 “神秘数” 就保持不变了。

另一方面，假如 x <= k，则我们的 “神秘数” 将会从 k 变成 k + x。

这样我们就可以 O(n) 从小到大扫一遍，维护一个 “神秘数” k。

注意到 k 始终等于某个前缀的和 + 1，而这给了我们用数据结构维护的机会。

进一步地，假如套到原题上面来，我们可以莫队 + 维护一棵线段树，每个位置维护 \((\sum_{p=1}^{i-1}a_p) + 1 - a_i\)。然后线段树上二分求第一个负数的位置。

但是这还不够。复杂度 \(O(n\sqrt{n}\log n)\) 还是太慢了。

考虑复杂度卡在，我们每一次只能往集合里塞一个数。

假如说每一次当前所有 x <= k 的 x 全部塞进集合，会发生什么。

设前一次的 “神秘数” 为 p，则前一次我们可以把 <= p 的全部塞进集合，得到新一次的 “神秘数” 为 q。

新一轮中，我只能塞 p < x <= q 的数（太小的已经塞过了，太大的塞不进去）。假如能塞，则下一次的 “神秘数” >= 2*p。

于是这种操作下：“神秘数” 呈指数级增长。

那么对于每一个区间 [l, r]，我们只需要找到 p < x <= q 的数的求和，得到新的 “神秘数”。

这个是可持久化线段树的经典应用了。我们按 ai 从小到大的顺序往线段树里塞，得到 <= ai 的 n 棵线段树。

@accepted code@

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
typedef pair<int, int> pii;
#define mp make_pair
#define fi first
#define se second
const int MAXN = 100000;
struct node{
	int sum;
	node *ch[2];
}t[40*MAXN + 5], *rt[MAXN + 5], *ncnt, *NIL;
struct segtree{
	segtree() {
		NIL = ncnt = &t[0];
		NIL->ch[0] = NIL->ch[1] = NIL;
		NIL->sum = 0;
	}
	void pushup(node *x) {
		x->sum = x->ch[0]->sum + x->ch[1]->sum;
	}
	node *newnode(const node *pre = NIL) {
		ncnt++; *ncnt = *pre;
		return ncnt++;
	}
	node *insert(const node *pre, int l, int r, int p, int k) {
		node *x = newnode(pre); x->sum += k;
		if( l == r ) return x;
		int mid = (l + r) >> 1;
		if( p <= mid ) x->ch[0] = insert(pre->ch[0], l, mid, p, k);
		else x->ch[1] = insert(pre->ch[1], mid + 1, r, p, k);
		pushup(x);
		return x;
	}
	int query(const node *x, int l, int r, int ql, int qr) {
		if( ql <= l && r <= qr )
			return x->sum;
		if( l > qr || r < ql )
			return 0;
		int mid = (l + r) >> 1;
		return query(x->ch[0], l, mid, ql, qr) + query(x->ch[1], mid + 1, r, ql, qr);
	}
}T;
int a[MAXN + 5]; pii b[MAXN + 5];
int main() {
	int n, m; scanf("%d", &n);
	for(int i=1;i<=n;i++)
		scanf("%d", &a[i]);
	scanf("%d", &m);
	for(int i=1;i<=n;i++)
		b[i] = mp(a[i], i);
	sort(b + 1, b + n + 1);
	rt[0] = NIL;
	for(int i=1;i<=n;i++)
		rt[i] = T.insert(rt[i - 1], 1, n, b[i].se, b[i].fi);
	for(int i=1;i<=m;i++) {
		int l, r, nw = 0, x; scanf("%d%d", &l, &r);
		while( true ) {
			x = T.query(rt[nw], 1, n, l, r) + 1;
			int y = upper_bound(b + 1, b + n + 1, mp(x, n + 1)) - b - 1;
			if( nw == y ) break;
			nw = y;
		}
		printf("%d\n", x);
	}
}

@details@

实现基本没有细节。

所以我太菜了。把正解思路擦边擦了个遍，就是没有想到正解的 “一次加入能加入的所有数”。

这本来是道 sb 题，可惜我太 sb，切不出来。