Week Round 30

T1 是无意义题，就不说了。这次周赛出得最差的题目就是 T1。

T2: ABC282E

题目描述

有 $n$ 个数 $a_i$ ，你每次可以选出两个数 $a_i$ 和 $a_j$ ，获得 $(a_i^{a_j}+a_j^{a_i}) \bmod M$ 分，并选择这两个数中的一个数删掉，求最大得分。

$1\le n\le 500$ 。

题目思路

我们把选出的两个数看成一条边， $(a_i^{a_j}+a_j^{a_i}) \bmod M$ 就是边权。先对两两个数建边，可以得到一个图。可以知道，通过操作得到的一个图不存在环。即选出的子图是一颗树。

也就是说：对原图求最大生成树，就是答案。

T3: CF1954E

题目描述

给定一个长度为 $n$ 的序列 $a$ ，你还有一个属性 $k$ ，定义一次操作为：

选择 $a$ 中一段极长的区间 $[l, r]$ ，满足 $\min \limits_{i = l} ^ r a_i > 0$ 。

在这里，极长的区间定义为 $[l, r]$ 满足条件但 $[l - 1, r]$ 与 $[l, r + 1]$ 不满足条件。
$\forall i \in [l, r] \cap \mathbb{N}$ ，执行 $a_i \gets a_i - k$ 。

定义 $f(k_0)$ 为当 $k = k_0$ 时，为使 $\max \limits_{i = 1} ^ n a_i \le 0$ 的最小操作数。

你需要分别求出 $f(1), f(2), f(3), \dots, f(\max \limits_{i = 1} ^ n a_i)$ 的值。

保证 $1 \le n \le 10 ^ 5$ ， $1 \le a_i \le 10 ^ 5$ 。

题目思路

这次周赛出得最好的题目之一就是 T3。

为了简单起见，我们从 $k = 1$ 开始。

第一道闪电可以向任何怪物发射，因为它总是会扩散到所有怪物身上。我们将继续发射闪电，直到有怪物死亡。当一个或多个怪物死亡时，问题就会分解成几个独立的子问题，因为没有闪电会穿过死亡的怪物。而且我们不管选择什么怪物来发射闪电，分成的子问题都是相同的。这意味着不存在 "最少秒数 "的概念——答案并不取决于发射闪电的怪物的选择。这个结论真的是妙！

那么我们该如何计算这个答案呢？攻击第一个怪物，直到它死亡。这需要 $a_1$ 秒。然后我们继续攻击第二个怪物。如果它的生命值比第一个怪物高，我们就需要额外发射 $a_2 - a_1$ 枚闪电来杀死它。否则，它已经死亡。在这两种情况下，第三个怪物会受到多少伤害？假设它的生命值很高。在第一种情况下，它会受到 $a_2$ 伤害，因为所有的闪电都会击中它。但在第二种情况下，它也会受到 $a_2$ 次伤害。以此类推。这就意味着 $i$ 个怪物需要被 $\max(0, a_i - a_{i - 1})$ 个闪电击中。

那么 $k = 1$ 的答案就等于 $a_1 + \sum\limits_{i = 2}^{n} \max(0, a_i - a_{i - 1})$ 。

如何计算任意 $k$ 的答案呢？事实上，两者的差别并不大。只需将每个怪物的健康值从 $a_i$ 改为 $\lceil \frac{a_i}{k} \rceil$ 即可，而前面所述的整个过程将保持不变。因此，任何 $k$ 的答案都等于 $\lceil \frac{a_1}{k} \rceil + \sum\limits_{i = 2}^{n} \max(0, \lceil \frac{a_i}{k} \rceil - \lceil \frac{a_{i - 1}}{k} \rceil)$ 。

这个结论也真的是妙！对于我来说，很难获得 30 分 $n\leq 5000$ 算法。

继续优化。把 max 拆开，看每一个 $\lceil \frac{a_i}{k} \rceil$ 的系数，取决于两个条件：

如果是 $i = 1$ 或 $a_i \ge a_{i - 1}$ ，则系数增加 $1$ ；
如果是 $i = n$ 和 $a_i < a_{i + 1}$ ，则系数减少 $1$ 。

我们把 $i$ 怪兽的这个系数称为 $c_i$ 。因此，我们需要计算 $\sum\limits_{i = 1}^n c_i \cdot \lceil \frac{a_i}{k} \rceil$ 。注意， $c_i$ 是固定的。

这是什么？数论分块，只不过是向上取整的数论分块，但是我们知道 $\lceil \frac{n}{l} \rceil=\lfloor \frac{n-1}{l} \rfloor+1$ ，所以依然可以转化为下取整。

我们可以考虑每个 $a_i$ 对答案的贡献，比如当前极长 $[l,r]$ 使得 $\lceil\frac{a_i}{l}\rceil=\lceil\frac{a_i}{r}\rceil$ ，那么答案区间 $[l,r]$ 整体就加上 $c_i\times \lceil\frac{a_i}{l}\rceil$ 。这个也 tm 很妙！

#include <bits/stdc++.h>
using namespace std;

#define PII pair<int, int>
#define _for(i, a, b) for (int i = (a); i <= (b); i++)
#define _pfor(i, a, b) for (int i = (a); i >= (b); i--)
#define int long long
const int N = 3e5 + 5;

int n, a[N], maxn, ans[N];

signed main() {
	cin >> n;
	_for(i, 1, n) cin >> a[i], maxn = max(maxn, a[i]);
	_for(i, 1, n) {
		int cnt = 0;
		if (i == 1 || a[i] > a[i - 1]) cnt++;
		if (i < n && a[i + 1] > a[i]) cnt--;
		int l = 1, r;
		while (l <= a[i]) {
			int t = (a[i] - 1) / l;
			if (t) r = (a[i] - 1) / t;
			else r = a[i];
			ans[l] += cnt * (t + 1);
			ans[r + 1] -= cnt * (t + 1);
			l = r + 1; 
		} 
		ans[a[i] + 1] += cnt; // warning!
	}
	_for(i, 1, maxn) ans[i] += ans[i - 1];
	_for(i, 1, maxn) cout << ans[i] << ' ';
}

T4: ARC100E

题目描述

给你一个长度为 $2^n$ 的序列 $a$ ，每个 $1\le K\le 2^n-1$ ，找出最大的 $a_i+a_j$ （ $i \mathbin{\mathrm{or}} j \le K$ ， $0 \le i < j < 2^n$ ）并输出。
$\mathbin{\mathrm{or}}$ 表示按位或运算。 $n\leq 18$ 。

题目思路

求出 $i\mathbin{\mathrm{or}} j\leq K$ 的最大值，等于说是求出等于 $1$ ，等于 $2$ ，一直到 $k$ 的最大值。但是小于 $k$ 的在之前的询问中求过，所以我们只需要把 res 放在外面就求出 $\leq K$ 的最大值。比如：

int res = 0;
for (int i = 1; i < ((1 << n) - 1); i++) {
	res = max(res, or=i的答案);
    cout << res << endl;
}

两个数或起来等于 $K$ ，那么这两个数肯定是 $K$ 二进制表示的子集。定义 $mx_k$ 表示 $k$ 二进制子集中 $a$ 数组的最大值， $mn_k$ 表示 $k$ 二进制子集中 $a$ 数组的次大值。那么答案就是 $mx_K+mn_K$ 。

预处理 mx 数组和 mn 数组，首先外层循环枚举 $k$ ，再枚举 $k$ 的子集，花费 $O(3^n)$ 的时间，足以通过本题，440ms。

signed main() {
	cin >> n;
	_for(i, 0, (1 << n) - 1) a[i] = read();
	_for(i, 0, (1 << n) - 1) {
		for (int j = i; j; j = (j - 1) & i) {
			if (a[j] > tt[i]) tt2[i] = tt[i], tt[i] = a[j];
			else if (a[j] > tt2[i]) tt2[i] = a[j];
		}
		if (a[0] > tt[i]) tt2[i] = tt[i], tt[i] = a[0];
		else if (a[0] > tt2[i]) tt2[i] = a[0];
	}
	int res = 0;
	_for(i, 1, (1 << n) - 1) {
		res = max(res, tt[i] + tt2[i]);
		wr(res); putchar('\n');
	}
}

但是我们可以用一个更高效的方式，类似于 dp（被叫做高维前缀和）。就是 $mx_i$ 可以由 $mx_j$ 转移过来，其中 $j$ 是 $i$ 的子集。当然，快多了，32 ms。

signed main() {
	cin >> n;
	_for(i, 0, (1 << n) - 1) a[i] = read(), tt[i] = a[i];
	_for(j, 0, n - 1) {
		_for(i, 0, (1 << n) - 1) {
			if (i >> j & 1) {
                // mx[i]由子集mx[i^(1<<j)]转移过来
				if (tt[i ^ (1 << j)] > tt[i]) tt2[i] = tt[i], tt[i] = tt[i ^ (1 << j)];
				else if (tt[i ^ (1 << j)] > tt2[i]) tt2[i] = tt[i ^ (1 << j)];	
			}
		}
    }
	int res = 0;
	_for(i, 1, (1 << n) - 1) {
		res = max(res, tt[i] + tt2[i]);
		wr(res); putchar('\n');
	}
}

T5: AGC030F

这个题也出的不错。

题目描述

有一个 $2 N$ 个数的序列 $A$ ，从 $1$ 到 $2 N$ 标号。你要把 $1 \sim 2 N$ 这些数填进去，使它形成一个排列。

但是已经有一些位置强制填了特定的数了，输入时会给出。

最后令长度为 $N$ 的序列 $B$ 为：令 $B_i = \min\{A_{2 i - 1}, A_{2 i}\}$ 。

询问所有方案中能得到的不同的 $B$ 的数量。 $1 \le N \le 300$ 。

题目思路

把这 $2N$ 个数两两配对，然后每一对中的较小数会进到 B 里面去。

把已经确定的配对 $A_{2i-1},A_{2i}≠-1$ ，剩下的是一对中有一个确定了的，和两个都没确定的。

把 $1\sim 2N$ 这些数排成一排，配对的连一条线，那么 $B$ 中的元素就是每条线左端点的值，但是 $B$ 中还有顺序需要进行处理。

考虑：如果某一条线的某一端的值，在 A 中是存在的，也就是说这一对的一端已经是确定的，那么在 $B$ 中的位置也是确定的。

如果这条线两端的值都没有在 $A$ 中，那么我们先不给这条线赋值，等到最后统计完所有方案后，可以发现这样的线的个数是确定的（就等于 $N$ 减去一端在 $A$ 中的数对的数量），假设为 $S$ ，把答案乘以 $S!$ 就行了。

那么，也就是说，我们需要统计连线方案数，两个方案不同当且仅当某个位置在其中一个方案中是线的左端点，而在另一个方案中不是，或者某个左端点所在的线的标号不同（如果这条线的一端在 $A$ 中存在）。

设 $v_i$ 表示值 $i$ 是否在 $A$ 中存在。则从大到小 dp，设状态 $dp(i,j,k)$ 表示考虑了 $\geq i$ 的值，其中有 $j$ 个 $v_x=0$ 的右端点还未配对，有 $k$ 个 $v_x=1$ 的右端点还未配对。

则有转移， $dp(i+1,j,k)$ 可以转移给：

$v_i=1$ ： $dp(i,j-1,k)$ ，表示匹配了一个更大的 $v_x=0$ 的右端点。
$v_i=1$ ： $dp(i,j,k+1)$ ，表示自己变成一个右端点。
$v_i=0$ ： $dp(i,j-1,k)$ ，表示匹配了一个更大的 $v_x=0$ 的右端点。
$v_i=0$ ： $dp(i,j,k-1)$ ，表示匹配了一个更大的 $v_x=1$ 的右端点。注意这里需要乘系数 $k$ ，且每一个带来的这条线的标号都不同。（注意理解）
$v_i=0$ ： $dp(i,j+1,k)$ ，表示自己变成一个右端点。

时间复杂度 $O(n^3)$ 。代码：

#include <bits/stdc++.h>
using namespace std;

#define PII pair<int, int>
#define _for(i, a, b) for (int i = (a); i <= (b); i++)
#define _pfor(i, a, b) for (int i = (a); i >= (b); i--)
#define int long long
const int N = 605, mod = 1e9 + 7;

int n, a[N], vis[N], tot;
int b[N], m, dp[2][N][N];

void add(int &a, int b) {
	a += b;
	if (a > mod) a -= mod;
}

signed main() {
	cin >> n;
	_for(i, 1, 2 * n) cin >> a[i];
	for (int i = 1; i <= 2 * n; i += 2) {
		int cnt = (a[i] == -1) + (a[i + 1] == -1);
		if (cnt == 1) {
			if (a[i] != -1) vis[a[i]] = 1;
			if (a[i + 1] != -1) vis[a[i + 1]] = 1;
		}
		if (cnt == 2) tot++;
		if (cnt == 0) vis[a[i]] = vis[a[i + 1]] = 2;
	}
	_pfor(i, 2 * n, 1) if (vis[i] <= 1) b[++m] = i;
//	cout << m << endl;
//	_for(i, 1, m) cout << b[i] << ' '; puts("");
	dp[0][0][0] = 1;
	_for(i, 1, m) {
		memset(dp[i & 1], 0, sizeof dp[i & 1]);
		_for(j, 0, n) _for(k, 0, n) {
			if (vis[b[i]] == 1) {
				add(dp[i & 1][j][k], dp[i - 1 & 1][j + 1][k]);
				if (k) add(dp[i & 1][j][k], dp[i - 1 & 1][j][k - 1]);
			}
			else {
				if (j) add(dp[i & 1][j][k], dp[i - 1 & 1][j - 1][k]);
				add(dp[i & 1][j][k], dp[i - 1 & 1][j + 1][k]);
				add(dp[i & 1][j][k], dp[i - 1 & 1][j][k + 1] * (k + 1) % mod);
			}
		}
	}
	int res = dp[m & 1][0][0];
	_for(i, 1, tot) res = res * i % mod;
	cout << res << endl;
}

T6: 弹飞绵羊

考试的题目是这题的加强版，只不过我觉得那题十分智慧，数据也十分友情，干脆不补了。

用分块做更简单。定义 $cnt_i$ 表示从 $i$ 开始，跳出 $i$ 这个块的步数， $p_i$ 表示从 $i$ 开始，跳出这个块能跳到的下标。

先对这两个数组进行预处理：

_pfor(i, n, 1) {
	if (i + a[i] > rx[bel[i]]) {
		cnt[i] = 1;
		p[i] = i + a[i];
	}
	else {
		cnt[i] = cnt[i + a[i]] + 1; // 递推
		p[i] = p[i + a[i]];
	}
}

如果是单点修改，那么直接对这个数所在块，仿照上述方法重新更新一遍就行。

while (m--) {
	int op, x, y;
	cin >> op >> x;
	x++; 
	if (op == 1) {
		int res = 0, t = x;
		while (t <= n) {
			res += cnt[t];
			t = p[t];
		}
		cout << res << endl;	
	}
	else {
		cin >> y;
		a[x] = y;
		_pfor(i, rx[bel[x]], lx[bel[x]]) {
			if (i + a[i] > rx[bel[i]]) {
				cnt[i] = 1;
				p[i] = i + a[i];
			}
			else {
				cnt[i] = cnt[i + a[i]] + 1;
				p[i] = p[i + a[i]];
			}
		}
	}
}