Codeforces Round #631 (Div. 1) A-C

在 \(\text{Div. 2/3}\) 混了一个多月后，四个号终于都上紫了，也没用理由不打 \(\text{Div. 1}\) 了。这是我人生中的第一场 \(\text{Div .1}\) ，之前也没用刻意的刷过题。在赛场上 \(\text{A}\) 在 WA 了 \(3\) 次后终于过了，然后 \(35 \text{min}\) 的时候过了 \(\text{B}\)，想了一个小时 \(\text{C}\) 未果，耻辱下线。事后上了 \(60\) 分，大概是安慰吧......

A. Dreamoon Likes Coloring

比较显然地想到贪心，让左端点从左到右的顺序放线段，每次最少给上次的颜色留出一个位置即可。

然后比较坑的是，这题你放的左端点必须保证右端点 \(\le n\)，所以贪心地考虑就是让每条线段尽量往左放，但是你又不知道往左放后面会不会不够。所以记录一个 \(d = n - m\)。初始设定每个颜色包含的块时 \(1\)，\(d\) 维护的就是当前还需要扩展的块数。然后逆向思维，从右往左考虑，尽量让左端点往左边放即可，但是不能超过 \(d\)，否则把别的颜色本该有的地方给占领了。

几个无解的判断：

• \(\sum l < n\) 肯定有空白

• \(l_m > n - (m - 1)\) 最后一个覆盖了太多，导致容不下 \(m\) 个颜色

• 放的过程中发现右端点势必 \(> n\)

还有一些细节，具体看代码

时间复杂度 \(O(n)\)

#include <iostream>
#include <cstdio>

using namespace std;

const int N = 100005;

int n, m, l[N], ans[N];

typedef long long LL;

LL s = 0;

int main() {
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= m; i++) scanf("%d", l + i), s += l[i];
	if (s < n) {
		puts("-1");
		return 0;
	}
	if (l[m] > n - (m - 1)) {
		puts("-1");
		return 0;
	}

	int j = n - l[m] + 1;
	int d = (j - 1) - (m - 1);
	ans[m] = j;
	for (int i = m - 1; i; i--) {
		j -= min(d + 1, l[i]) ;
		d -= min(d + 1, l[i]) - 1;
		if (j + l[i] - 1 > n) {
			puts("-1");
			return 0;
		}
		ans[i] = j;
	}
	for (int i = 1; i <= m; i++) printf("%d ", ans[i]);
	return 0;
}

B. Dreamoon Likes Sequences

既然要保证异或和、值本身都上升的序列。那么不妨从二进制的角度去考虑：

• 要让值上升，意味着 \(a_{2}\) 在二进制下最高的 \(1\) 大于等于 \(a_{1}\) 的位置，否则 \(a_{i - 1}\) 就大了
• 异或和上升，意味着 \(a_2\) 在二进制下最高的 \(1\) 必须大于 \(a_1\) 的位置，否则异或和就把最高的那处一消掉了，就不能保证上升了。

然后通过数学归纳法，我们能知道 \(a_i\) 和 \(b_i\) 二进制意义下最高的 \(1\) 位置是一样的，否则被消掉了肯定不能保证异或和上升。

所以若 \(a_{i + 1}\) 能接上 \(a_i\)，当且仅当 \(a_{i + 1}\) 二进制下最高的 \(1\) 比 \(a_i\) 大。

由于不涉及序列长度以及具体数值，只关心最后一个数二进制下最高的 \(1\) 的位置，那么这样设计 \(\text{DP}\) 状态：

• 设 \(f_i\) 表示一段序列，最后一个数在二进制下最高的 \(1\) 在第 \(i\) 位的方案数。

考虑状态转移，\(f_j (j > i) \gets f_i * \text{w(j)}\)。\(\text{w(j)}\) 表示在二进制下最高位是 \(1\)，且不超过 \(d\) 的数字的数量，这个很好搞，下界就是 \(2^j\)，上界就是 \(\min(2^{j+1}-1, d)\)。

注意初始化，第一个元素可以为 \([1, d]\) 的任意值。

时间复杂度 \(O(T\log^2 10^9)\)

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

typedef long long LL;

const int S = 31;

int d, P, f[S];

int main() {
	int T; scanf("%d", &T);
	while (T--) {
		memset(f, 0, sizeof f);
		scanf("%d%d", &d, &P);
		for (int i = 0; i < S; i++) {
			if ((1 << i) > d) continue;
			int c = min((LL)d, (1ll << (i + 1)) - 1) - (1 << i) + 1;
			f[i] = c;
		}
		for (int i = 0; i < S; i++) {
			if (f[i] == 0) continue;
			for (int j = i + 1; j < S; j++) {
				if ((1 << j) > d) continue;
				int c = min((LL)d, (1ll << (j + 1)) - 1) - (1 << j) + 1;
				f[j] = (f[j] + (LL)c * f[i]) % P;
			}
		}
		int ans = 0;
		for (int i = 0; i < S; i++) (ans += f[i]) %= P;
		printf("%d\n", ans);
	}
	return 0;
}

C. Drazil Likes Heap

考虑每一次的删数操作，实际上是将一个叶子节点的位置去除了，我们要保证堆的结构仍然为满二叉树，删除总和最大的一些数。我们可以预处理出来删除每个节点，最终会去除的叶子节点的位置的高度，设这个东西为 \(maxDep_i\)。

我们发现，删除一个数是否合法的条件为：\(maxDep_i > g\)。否则会打破深度限制。

然后贪心策略是：从小到大的顺序依次考虑每一层，能删则删，循环直到不能删为止。为啥这样是对的呢？首先我们的策略应该是：尽可能删合法的大的，因为假设你不删大的，那一定还得删另外一个数，来消除本应该这个大的数消除的叶子位置，这样顶替的肯定不优，所以能删则删。

还有个性质，就是说不同子树之间删除互不影响，这个比较显然，因为自己删除只会改变自己的子树。所以根据堆的性质，我们只需要从小到大考虑每一层能不能删即可。可以理解为当考虑删除当前位置的节点时，权重更大的能消除这个位置的（就是当前节点的祖先）已经考虑过了，所以这种枚举方式是正确的。

代码实现起来，就是模拟一个堆，然后删除的过程中不要忘了维护 \(maxDep\) 信息，每次操作是 \(O(dep)\) 的，所以总复杂度是 \(O(T2 ^ hh)\) 的。

#include <iostream>
#include <cstdio>

using namespace std;

const int N = 3000005;

typedef long long LL;

int h, g, a[N], dep[N], maxDep[N], adj[N], tot;

LL ans;

void inline pushup(int p) {
	maxDep[p] = max(dep[p], a[p << 1] > a[p << 1 | 1] ? maxDep[p << 1] : maxDep[p << 1 | 1]);
}

void del(int p) {
	a[p] = 0;
	if (!a[p << 1] && !a[p << 1 | 1]) { maxDep[p] = 0; return; }
	else if (!a[p << 1]) a[p] = a[p << 1 | 1], del(p << 1 | 1);
	else if (!a[p << 1 | 1]) a[p] = a[p << 1], del(p << 1);
	else {
		int t = a[p << 1] > a[p << 1 | 1] ? p << 1 : p << 1 | 1;
		a[p] = a[t], del(t);
	}
	pushup(p);
}

int main() {
	int T; scanf("%d", &T);
	while (T--) {
		ans = tot = 0;
		scanf("%d%d", &h, &g);
		for (int i = 1; i < (1 << h); i++) {
			scanf("%d", a + i);
			a[i << 1] = a[i << 1 | 1] = 0;
			dep[i] = dep[i >> 1] + 1;
			ans += a[i];
		}
		for (int i = (1 << h) - 1; i; i--) pushup(i);
		for (int i = 1; i < (1 << h); i++)
			while (a[i] && maxDep[i] > g) {
				ans -= a[i], adj[++tot] = i, del(i);
			}
		printf("%lld\n", ans);
		for (int i = 1; i <= tot; i++) printf("%d " , adj[i]);
		puts("");
	}
	return 0;
}