P6775 NOI2020 制作菜品

P6775 NOI2020 制作菜品

给定正整数 \(n\)，\(m\)，\(k\)。

有一个 \(m\) 行 \(k\) 列网格，每个网格可以被涂上 \(n\) 种颜色之一，要求：

• 一行最多出现两种颜色。
• 第 \(i\) 种颜色必须恰好被使用 \(a_i\) 次。

\(\{a_i\}\) 给定，保证 \(\sum a_i = m \times k\)。请构造涂色方案或判定不存在。

多测，最多 \(10\) 组数据。\(1 \le n \le 500\)，\(\boldsymbol{n - 2 \le m} \le 5000\)，\(m \ge 1\)，\(1 \le k \le 5000\)。

\(\boldsymbol{m = n - 1}\)

虽然这题是个黑题，但是我们仍然可以发现，\(a\) 的顺序和答案完全无关。两种套路：

• 先对 \(a\) 排序。
• 对 \(a\) 建立权值数组，在权值数组上做。

这里一看就是第一种，那就先对 \(a\) 排个序。

然后我们开始观察这个仅次于暴力的第一档部分分。

首先我们发现，如果没有每行颜色种类限制，只要按照 \(a_i\) 随便涂就可以了。因为有了颜色种类限制，所以如果我们选择把某两个要求使用次数很少的颜色涂在同一行，使得这行没被涂完，就会导致不合法。

因此，对于要求使用次数最少的颜色，我们可以让它和次数最多的颜色一起涂，这样贪心还是比较优秀的。

简单观察不难发现(这里的 \(a_1\) 和 \(a_n\) 是按 \(a\) 不降排序后意义上的)：

• \(a_1 < k\)。
  • 否则 \(\sum a \ge nk > mk = \sum a\) 显然不成立。
• \(a_1 + a_n \ge k\)(\(n \ge 2\) 时)。
  • 反证法。假设 \(a_1 + a_n < k\)，则 \(a_n < k - a_1\)，则 \(\sum a_i < a_1 + (n - 1)(k - a_1) = (2 - n)a_1 + (n - 1)k \le (n- 1)k\)，和 \(\sum a = (n - 1)k\) 矛盾。

注意到上面两条的证明依赖于 \(a_i \ge 0\)，\(a_i\) 可以为 \(0\)。

综上所述，我们可以在第一行直接涂上 \(a_1\) 个颜色 \(1\)，以及 \(k - a_1\) 个颜色 \(n\)。

这样以来，对于第 \(2 \sim m\) 行的涂色，可以看做颜色种类数少了 \(1\)，涂色行数少了 \(1\)，同时仍然有 \(\sum a_i = (n - 1)k\) 的一个子问题。这里，第一种颜色一定会被涂完，我们直接丢弃这种颜色；而第 \(n\) 种颜色可能会被涂完，此时我们也不将第 \(n\) 种颜色丢弃，而是看做 \(a_n = 0\) 的一种颜色，这样也是合法的。于是问题成功归纳。

归纳的边界是 \(n = 1\)，\(m = 0\)，显然此时已经不需要涂色了，问题解决。

(此时剩下的那个颜色 \(a_1\) 一定有 \(a_1 = 0\)。)

\(\boldsymbol{n - 1 \le m \le 5 \times 10^3}\)

其实整道题不难发现，在 \(a_i\) 不变的情况下，\(m\) 越大(对应地 \(k\) 越小)时，涂色越容易。所以这个问题应该是比上面那个问题弱的。

事实上确实如此，直接把颜色数补齐到 \(m + 1\) 就行了。具体来说，就是新建 \(m + 1 - n\) 个 \(a_i = 0\) 的颜色即可。。

到这里已经解决 45 分了。

我们观察一下新建颜色的实质，其实就是让前 \(m + 1 - n\) 次涂色都是将 \(a\) 最大的那个颜色涂完一整行。根据新建颜色，并套用 \(m = n - 1\) 的证明，可以得到在 \(m > n - 1\) 时，\(\max\{a_i\} \ge k\)。当然，这个结论也可以很简单地通过 \(m \ge n\) 时，\(\sum a_i = mk \ge nk\) 所以最大值肯定不小于 \(k\) 得到。

所以代码实现就不用新建颜色了，让头 \(m + 1 - n\) 次颜色都让 \(a\) 最大的颜色涂完一整行，转到 \(m = n - 1\) 的情况即可。

\(\boldsymbol{m = n - 2}\)

到这里没啥思路了，不妨考虑构造最常用的方法：建图。尤其是每行最多涂两个颜色的限制，启发我们对每行所涂的两种颜色连边。

那么题目变成：对 \(n\) 个点连接 \(m = n - 2\) 条边，并把点权按任意非负整数比例分配，贡献给它所连接的边的边权上，使得所有边边权恰好为 \(k\)。显然分配结束后所有点权应恰为 \(0\)。

这里一行颜色全为 \(u\)，可以看做这个颜色点和其它任何一个点 \(v\) 连了一条边，并且 \(v\) 没有给这条边分配权值，只有 \(u\) 给这条边分配了恰好为 \(k\) 的权值。

看起来无从下手，但是其实 \(m \ge n - 1\) 的情况刚刚已经解决，保证给出一组方案了，只要把刚刚的思路放在图上即可，具体如下：

• 对于前 \(m - n + 1\) 条边，我们连接点权最大的点 \(u\) 和任意点 \(v\)，并将 \(u\) 的点权分配 \(k\) 的权值给这条边。(这里分配完权值后，\(u\) 的点权也要动态地减去 \(k\))。
• 对于后 \(n - 1\) 条边，我们连接点权最大的点 \(u\) 和点权最小的 未标记点 \(v\)，然后：
  • 将 \(u\) 的点权分配 \(k - a_v\) 给这条边。
  • 将 \(v\) 的点权 \(a_v\) 全部分配给这条边，并 标记 \(v\)。

这里一个点被标记，等价于之前对 \(m \ge n - 1\) 方案的讨论中，一个颜色种类被丢掉。

那么对于 \(m = n - 2\) 我们如何构造？观察到 \(m = n - 2\) 时如果有解，任何一组解生成的图，一定不连通，即至少有 \(2\) 个以上的连通块。下设全集 \(U = \{1, 2, \ldots, n\}\)，第 \(i\) 个连通块点集为 \(S_i\)，\(n_i = |S_i|\)，并且这个连通块内部边数为 \(m_i\)。有以下发现：

• \(\sum n_i = n\)，\(\sum m_i = m = n - 2\)。
• 根据连通块的连通性，\(m_i \ge n_i - 1\)。
• 第 \(i\) 个连通块内部的点权明显要被这 \(m_i\) 条边分配完(因为其它边不分配这些点权)，所以 \(\sum\limits_{u \in S_i}a_u =m_ik\)。
• 至少存在两个 \(i\) 满足 \(m_i = n_i - 1\)。
  • 否则，若最多存在一个 \(i\) 满足 \(m_i = n_i - 1\)，会得到 \((\sum m_i) \ge (\sum n_i) - 1\)，也即 \(m \ge n - 1\)，矛盾。

因此，\(m = n - 2\) 存在解的一个必要条件是：存在一个 \(S \subseteq U\)，使得 \(\sum\limits_{u \in S}a_u = (|S| - 1)k\)(也即对上面满足 \(m_i = n_i - 1\) 的两个集合之一的描述)。

下面给出找到这样一个 \(S\) 后的构造方案。

因为 \(\sum\limits_{u \in S}a_u = (|S| - 1)k\)，则考虑 \(T = U \setminus S\)，也有 \(\sum\limits_{u \in T}a_u = (|T| - 1)k\)。所以只需要分别对 \(S\) 和 \(T\) 分配 \(|S| - 1\) 和 \(|T| - 1\) 条边，分别构造。对 \(S\) 构造 \(|S| - 1\) 条边的方案是前面已经解决过的问题。

所以存在一个 \(S \subseteq U\)，使得 \(\sum\limits_{u \in S}a_u = (|S| - 1)k\) 不仅是原问题有解的必要条件，也是充分的。接下来只需解决一个问题：如何快速找到这个 \(S\)。

这个问题很类似背包恰满问题，也就是在 \(n\) 个有体积的物品中，找到 \(|S|\) 个物品，恰满容量为 \((|S| - 1)k\) 的背包。

恰满的容量和物品选择的数量有关，不太好处理。可以对 \(\sum\limits_{u \in S}a_u = (|S| - 1)k\) 处理成 \(\sum\limits_{u \in S} a_u - k = -k\)。

也就是 \(n\) 个物品，第 \(i\) 个物品体积为 \(a_i - k\)，求一个恰满体积 \(-k\) 背包的容量组合。那就变成经典的容量恰满问题了。

根据 \(0 \le \sum\limits_{u \subseteq S} a_u \le (n - 2) \times k\)。这里 \(S\) 代表 \(U\) 的任意子集。可得：

\[-nk \le -|S|k \le \sum\limits_{u \subseteq S} a_u - k \le (n - 2 - |S|)k \le (n - 2)k \]

令 \(f(i, j)\) 表示前 \(i\) 个物品能否凑出体积 \(j\)，根据上面的式子，\(j\) 的范围应为 \([-nk, (n - 2)k]\)。

转移是 \(f(i, j) = f(i - 1, j) \lor f(i - 1, j - v_i)\)，其中 \(v_i = a_i - k\)。

可以考虑用 bitset 优化，设 \(f(i)\) 为布尔型数组，第 \(j\) 项为原先的 \(f(i, j)\)。在 bitset 上有：

f[i] = f[i - 1] | (f[i - 1] << v[i])。滚动一下得到 f |= f << v[i]。当然后面要输出方案所以别滚动了。

输出方案：设 \(f(i, j) = \mathrm{true}\)，检查 \(f(i - 1, j)\) 和 \(f(i - 1, j - v_i)\) 哪个是 \(\mathrm{true}\) 即可(这两个肯定有一个是 \(\mathrm{true}\))，如果前者 \(\mathrm{true}\) 就不取第 \(i\) 个物品，转到 \(f(i - 1, j)\)；否则就取第 \(i\) 个物品，转到 \(f(i - 1, j - v_i)\)。如果两个都是 \(\mathrm{true}\) 说明无论取不取第 \(i\) 个物品都行。从 \(f(n, -k)\) 倒推做上面的操作即可。

背包复杂度是物品数量 \(\times\) 物品子集和的值域大小 \(\div\) bitset 优化的常数，即 \(\Theta\left(\dfrac{nt}{w}\right) = \Theta\left(\dfrac{n^2k}{w}\right)\)。这里 \(t\) 表示 \(a_i\) 任意子集的和的值域范围的长度，也即 \([-nk, (n - 2)k]\) 的长度，为 \(\Theta(nk)\) 量级。

然后转化为 \(m \ge n - 1\) 就是取 \(m\) 次 \(a\) 的最大最小值， 直接暴力，复杂度是 \(\Theta(nm)\)。

所以总复杂度 \(\Theta\left(T\left(\dfrac{n^2k}{w} + nm\right)\right)\)，算下来大概 \(2 \times 10^8\)，还可以。

/*
 * @Author: crab-in-the-northeast 
 * @Date: 2023-07-13 10:02:06 
 * @Last Modified by: crab-in-the-northeast
 * @Last Modified time: 2023-07-13 11:10:23
 */
#include <bits/stdc++.h>
inline int read() {
	int x = 0;
	bool f = true;
	char ch = getchar();
	for (; !isdigit(ch); ch = getchar())
		if (ch == '-')
			f = false;
	for (; isdigit(ch); ch = getchar())
		x = (x << 1) + (x << 3) + (ch ^ '0');
	return f ? x : (~(x - 1));
}

const int N = 505;
struct node {
	int val, id;
	bool operator < (node b) {
		if (val != b.val)
			return val < b.val;
		return id < b.id;
	}
};
int n, m, k;
std :: bitset <500 * 5000 * 2> f[N];

inline void easy(std :: vector <node> a) {
	int n = (int)a.size();
	for (int i = 1; i < n; ++i) {
		int x = std :: min_element(a.begin(), a.end()) - a.begin();
		int y = std :: max_element(a.begin(), a.end()) - a.begin();
		int p = a[x].val, q = k - p;
		if (p)
			printf("%d %d %d %d\n", a[x].id, p, a[y].id, q);
		else
			printf("%d %d\n", a[y].id, k);
		a[y].val -= q;
		std :: swap(a[x], a.back());
		a.pop_back();
	}
}

inline void solve() {
	n = read(); m = read(); k = read();
	std :: vector <node> a;
	for (int i = 1; i <= n; ++i)
		a.push_back({read(), i});
	if (m >= n - 1) {
		for (int i = 1; i <= m - n + 1; ++i) {
			int x = std :: max_element(a.begin(), a.end()) - a.begin();
			a[x].val -= k;
			printf("%d %d\n", a[x].id, k);
		}
		easy(a);
	} else {
		f[0].reset();
		f[0].set(n * k);
		for (int i = 1; i <= n; ++i) {
			int v = a[i - 1].val - k;
			if (v > 0)
				f[i] = (f[i - 1] | (f[i - 1] << v));
			else
				f[i] = (f[i - 1] | (f[i - 1] >> (-v)));
		}
		if (!f[n][-k + n * k])
			return void(puts("-1"));
		std :: vector <node> S, T;
		for (int i = n, j = -k + n * k; i; --i) {
			int v = a[i - 1].val - k;
			if (f[i - 1][j])
				T.push_back(a[i - 1]);
			else {
				S.push_back(a[i - 1]);
				j -= v;
			}
		}
		easy(S); easy(T);
	}
	return ;
}

int main() {
	int T = read();
	while (T--)
		solve();
	return 0;
}

如果您是从洛谷题解过来的，觉得这篇题解解决了您的疑惑，帮到了您，别忘了回到洛谷题解区给我题解点个赞！