在 golang-nuts 邮件列表中，也有一个关于这个问题的讨论，但对 golang 了解不多，或者英文不太好的读者可能会一头雾水。本文会对这个问题的来龙去脉做一个简单易懂的概述。如果有错误，欢迎指正。

背景

最近遇到，总有一小部分实例，内存（RSS）占用比其他实例大。而且和正常的实例相比，经过反复排查也没有看出它们的环境有明显的差异。

后面发现，这些实例的 ballast 都整个地被分配了物理内存，并且是启动、创建 ballast 时就这样。

原因

OS（熟悉者可跳过）

众所周知，现代操作系统，尤其是类 Unix 系统中，虚拟内存机制被广泛使用。用户进程对内存的申请、访问等都是在虚拟地址空间内进行的，当进程访问内存时，才会通过“缺页异常”中断，调入对应的内存分页。

比如，当 Go runtime 申请了一块大小为 1GB 的连续内存时，会在虚拟地址空间中得到一段长度为 1GB 的地址，但在它被访问之前，OS 并不会调入对应的物理内存分页，此时也不会占用 1GB 的物理内存。这是 ballast 的理论基础。

ballast 通常的实现是，申请一个大切片，并设置它 KeepAlive（防止 Go 帮倒忙把它优化掉），然后保持它存在但永不访问它，这样结果就不会占用物理内存，同时会占着堆内存，使得 GC 的触发频率降低。

而事实上却出现了 ballast 占用物理内存的情况，最容易想到的原因是 Go runtime 在创建 ballast 大切片时访问了它。

Go runtime

在 Go 的内存分配机制中，大于 32KB 的内存属于大内存，是通过 mheap 分配的。Go 语言原本对应章节中有提到一个“清零”操作。如果在分配 ballast 的内存时，发生了这个清零操作，结果似乎就是会发生 ballast 吃内存的情况。Go 语言原本里没有介绍如何判断是否需要清零。

关于清零，在开头提到的邮件列表里，Golang 团队的开发者，也是下文将提到的 go1.19 GC 相关新特性的提出者，Michael Knyszek 进行了一段回复（译文）：

runtime 有一个简单的启发式方法来避免清零操作，但它远非完美。 因此，ballast 本质上总是会有一点风险。 在某些平台上尤其如此，例如 Windows，因为无法避免将内存标记为已提交（Windows 可以自由地对范围内的内存使用按需分页，因此整体系统内存压力可能会增加，但您不能避免将其计为特定进程的已提交）。

判断的具体逻辑（Github 地址）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

// allocNeedsZero checks if the region of address space [base, base+npage*pageSize),
// assumed to be allocated, needs to be zeroed, updating heap arena metadata for
// future allocations.
//
// This must be called each time pages are allocated from the heap, even if the page
// allocator can otherwise prove the memory it's allocating is already zero because
// they're fresh from the operating system. It updates heapArena metadata that is
// critical for future page allocations.
//
// There are no locking constraints on this method.
func (h *mheap) allocNeedsZero(base, npage uintptr) (needZero bool) {
	for npage > 0 {
		ai := arenaIndex(base)
		ha := h.arenas[ai.l1()][ai.l2()]

		zeroedBase := atomic.Loaduintptr(&ha.zeroedBase)
		arenaBase := base % heapArenaBytes
		if arenaBase < zeroedBase {
			// We extended into the non-zeroed part of the
			// arena, so this region needs to be zeroed before use.
			//
			// zeroedBase is monotonically increasing, so if we see this now then
			// we can be sure we need to zero this memory region.
			//
			// We still need to update zeroedBase for this arena, and
			// potentially more arenas.
			needZero = true
		}
		// We may observe arenaBase > zeroedBase if we're racing with one or more
		// allocations which are acquiring memory directly before us in the address
		// space. But, because we know no one else is acquiring *this* memory, it's
		// still safe to not zero.

		// Compute how far into the arena we extend into, capped
		// at heapArenaBytes.
		arenaLimit := arenaBase + npage*pageSize
		if arenaLimit > heapArenaBytes {
			arenaLimit = heapArenaBytes
		}
		// Increase ha.zeroedBase so it's >= arenaLimit.
		// We may be racing with other updates.
		for arenaLimit > zeroedBase {
			if atomic.Casuintptr(&ha.zeroedBase, zeroedBase, arenaLimit) {
				break
			}
			zeroedBase = atomic.Loaduintptr(&ha.zeroedBase)
			// Double check basic conditions of zeroedBase.
			if zeroedBase <= arenaLimit && zeroedBase > arenaBase {
				// The zeroedBase moved into the space we were trying to
				// claim. That's very bad, and indicates someone allocated
				// the same region we did.
				throw("potentially overlapping in-use allocations detected")
			}
		}

		// Move base forward and subtract from npage to move into
		// the next arena, or finish.
		base += arenaLimit - arenaBase
		npage -= (arenaLimit - arenaBase) / pageSize
	}
	return
}

注：原子操作 Casuintptr 的作用是，如果 p1 == p2，则 p1 = p3 并 return 1；否则无操作，return 0。

它会去遍历此次分配内存将涉及到的各个 arena（Go 内存分配中的一类大对象，详见 Go 语言原本），分别检查它们的 zeroedBase（值越大说明无需清零的内存越少），判断是否需要清零，并会增大 zeroedBase 的值。即，它的值可以理解为已被分配过、需要清零的值。需要注意的是，只要有一个 arena 符合 arenaBase < zeroedBase，都是整体地返回 true。

可以看出，arena 里已经被分配过又回收的内存，再次分配给 ballast 时，这次分配就会被判断为需要清零，进而出现开头描述的问题。因为 ballast 通常都是在启动早期创建的，在它之前分配的内存很少，所以这是个概率较小的事件，但确实存在。

建议

对于仍在继续使用 ballast 的读者，为了预防此问题，建议考虑以下方案替代它。

memory target

这是 1.19 的新功能，可以设置一个固定数值的，GC 触发的目标堆大小。有两种方法：

• 环境变量 GOMEMLIMIT。设置为数字，单位 byte；也可以用数字加单位如 1MiB，1GiB。
• debug.SetMemoryTarget(limit int64)，单位也是 byte

这个功能是为了替代 ballast 设计的，当它被设置后，runtime 会通过多种方法，包括调整 GC 触发频率、返还内存给操作系统的频率等，尽量使内存不超过它。它测量内存是否达到限制的指标是 go runtime 管理的所有内存，相当于 memStats 中 Sys - HeapReleased 的值。它的效果理论上类似且优于 ballast。

使用它限制内存时，可以关闭按比例的 GC（GOGC=off），或将其比例调大。

不过，它和 ballast 一样，不是硬限制，不要把它的值设置为环境允许的内存占用极限。

gc tuner

对于旧版本的 golang，还有一个方案是由 uber 提出的的。思路是动态地调整 GC 触发的比例。有两个开源实现：cch123/gogctuner、bytedance/gopkg/util/gctuner。

仍然使用 ballast

如果想继续使用 ballast ，我想以下两点可能有助于降低该问题发生的概率：

• 尽量早创建 ballast
• 在创建 ballast 前关闭 GC

而后则是一直拖到2021年7月的沈阳区域赛，这也是我唯一一次飞到现场参加的比赛。沈阳的气候和南方不同，尽管七月的沈阳不至于寒冷，但第一次到北方的我还是不太适应。在比赛现场上，我出现了较大的失误，整体上我们队伍的优势也没有发挥出来，最后只拿到了铜牌。

最后一年，先后有秋招、毕设等比较重要的事。我们除了赛前会集合训练一下以外，大部分时候都是自己练习。我们先后参加了 CCPC 哈尔滨站和 ICPC 济南站，都取得了银牌。2022 年初，一名队友因为保研夏令营退出队伍，我们直到三月初才最终确定了新队员，是一名大一的学弟，高中时是 OI 选手，实力很强。四月我们便参加了今年的第二场 ICPC 区域赛——昆明站，由于我们俩在搞毕设，学弟课程也很多，一起训练的时间仍然有限。尽管如此，我们最后还是拿到了金牌，这也是我们俩的第二块金牌。

拿了金牌之后，我们也获得了 ICPC EC Final 的参赛名额。西安主办方为了线下比赛，把时间一直拖到了7月19-20日，且在七月初，西安出现了疫情，包括数个高风险区。这个时间段已经毕业在家，赛后不久就是我入职时间。综合考虑可能出现的各种风险、主办方允许部分更换队员的情况（按照往年的要求，除了奖励名额外，其余名额是要在今年区域赛中排名靠前的整支队伍参赛的，但今年似乎放宽了要求，可能和疫情有关），我最后选择了退出比赛，更换为一名学弟。可惜的是，最后他们只拿了铜牌。

现在我已没有机会参加 ICPC 区域赛，是时候和 ICPC 说 Goobye 了。回想这几年，经过了大一大二的高度热情和大量训练，我在大三时终于获得了第一块金牌，而后拿了 ICPC 与 CCPC 的数块银牌和第二块金，在此中间也夹杂着省赛、CCCC 等比赛。这些是我大学期间，最重要的经历与回忆，其中既有成功的喜悦，也有失败的遗憾，但无论如何，都不可能再重来。

在 ICPC 生涯结束后，我很快将会成为一名普通的开发。我会在工作上多多努力，不断提升自己。

在赛场上，签到四题的部分共 WA 一发，还算比较稳，但并不快，排名在银区。

然后自然是跟榜看 A、L，但是都没有想出做法，尤其是 A 涉及的矩阵变换等是我最弱的方向。

后来发现有人过 J 题之后，我也开始看，一开始想在反图（原图不存在的所有边组成新图）里找强连通分量来构造，后面发现似乎并不可行。然后我想起了树上可以相邻点异色染色之类的操作，就发现它可以染两种色，同色点之间无边，这样这题一下子就豁然开朗了。很快地过了 J，排名一下子到了 9。

然后就进入了罚坐模式，期间我甚至想提前放弃🌚。A 题过的队越来越多，我们却迟迟找不到做法。由于我矩阵、代数等方面不太行，帮不上忙，便把所有没过的题都看了，然后也没发现有思路的，心态有点炸。A 题队友找到了把等式变形，矩阵按列拆开之后每列算自由度的做法，继而想到高斯消元和线性基。因为高斯消元算各列，总的复杂度是 $O(n^4)$，即 $1.6 \times 10^9$，感觉过不了，然后线性基连板子都没人看得懂，又开始卡。直到最后没办法才尝试用高斯消元去做，结果直接过了。赛后大佬们都说高斯消元本来复杂度就卡不满🌚，另外这题也可以 bitset 优化，不过没优化也过了。

A 题过了之后金牌应该是稳了，我一下子心态好了非常多，然后我们再一起看 L，想到了枚举后面几位的方法，但是只有不到半小时，来不及过了。不过金牌已经有了，这题过了也离出线差一题，所以也没太大影响。

这场我前中期发挥还可以，但在 A 卡题过程中不仅没帮上什么忙，反而因为自己心态不好，对队友心态也有些影响。很感谢他们并没有一起心态爆炸，并且最终过了这题，让我们第一次打 ICPC 就获得了金牌的好成绩。

A Matrix Equation

题意：已知相同大小的 0-1 方阵 $A$ 和 $B$，定义运算 $\times$ 是普通的矩阵乘，所有元素对 2 取模。定义 $\odot$ 为对应位置元素相乘（也就是相与），求使等式 $A \times C = B \odot C$ 成立的 $C$ 的个数，对 998244353 取模。

很显然，$C$ 的一个元素只会影响它所在的那一列，所以可以以列为单位分开考虑。

好像是只考虑一列之后，就可以得出方程组，然后用高斯消元算自由度。这题队友过的，我先溜了🌚。

C Stone Game

题意：有若干堆石头，每堆有最多三个石头，MianKing 想把它们合并为一堆。他每次可以把任意两堆合并为一堆，如果合并前两堆石头各有 $x$、$y$ 个，则代价为 $(x \mod 3) (y \mod 3)$，求最小总代价。

首先，石堆的个数只有模 3 后的部分有意义。模 3 为 0 的石堆，它与任何石堆合并代价为 0，也不会影响其个数模 3 的值，故可以无视。

然后，1 与 2 都有时，把它们两两合并为 0 是最优解，因为如果不这样做，两个 1 变成 2 代价 1，两个 2 变成 1 代价 4，怎么想都是亏的。因此，优先合并为 0，耗尽 1 和 2 中较少的那种。

对于多出的 1 或 2，显然只能合并，然后得到 2 或 1，然后按照上面的结论，优先合并 0。也就是三个 1 或 2 合并得 0，代价是 3 或 6，直至剩下不到三个为止。

上一步如果刚好够或者剩一个，都没有额外代价。剩两个时则还有一次额外的合并。

D Fight against involution

题意：期末论文有一个奇怪的打分规则：一个人的成绩等于全班总人数减去论文字数比他多的人数，不含相等。每个人能写的字数都有一个区间 $[L, R]$ 作为限制。为了拿高分，卷王们自然都会写最多的字数。但是，如果大家都不那么卷，适当减少字数，或许可以让所有人的成绩都不降低。这题要求找到一个这样的方案，在所有人成绩不降低的前提下，让所有人写的字数总和最小。只输出最小总和的值即可。

这个成绩实际上就是排名，并列往高算。

所有人排名不降，也就是排序不能变。因为并列算高，原本不并列的可以变并列，反之则不能。

显然可以贪心，按原字数排序，原字数最少的尽量减（到 $L$），后面的在不比前面的少的情况下尽量减。并列的只能一起减到它们的 $L$ 中的最大值。

具体做法可以把 $R$ map 到对应的最大 $L$，也可以对 $R$ 并列的按 $L$ 从大到小排，等等。

G Xor Transformation

题意：通过最多五次操作把 $x$ 变成 $y$，每次操作是任选满足 $0 \le a < x$ 的 $a$，令 $x = x \oplus a$。保证 $y < x$。

第一次可以把 $x$ 补满成 $2^k-1$ 的形式，第二次则直接变成 $y$。由于允许 $a = 0$，这种做法无需任何特判。

J Tree Constructer

题意：已知一棵无向树，要求为每个点赋值（$[0,2^{60})$），使有连边的两点所赋值按位或结果等于 $2^{60}-1$，无连边的两点所赋值按位或不等于 $2^{60}-1$。输出一种方案即可。

这题一开始往反图方向考虑去了，后面发现这样做位数应该不够。

按染色思路，相邻边异色，染成两色，设较少的颜色为 0，多的为 1，这样显然可以构造互补关系。

先对每个颜色为 0 的点，分配一位，置 0，其它位置 1。再为了防止同色互连，把一个标记位置 0。

这样颜色为 1 的与它互补，标记位置 1，分配给与它相邻的各点的位置 1，其它置 0。

最多 51 位，加上颜色为 1 的各点共同的零（剩下 9 位都是，需要 1 位），共需 52 位。

M Cook Pancakes!

题意：经典问题，平底锅煎煎饼，两面都要煎，3 个饼能同时煎 2 个，最少 3 次可以煎完。求 $n$ 个饼能同时煎 $k$ 个，最少几次能煎完，$n,k > 0$。

现在我们应该很容易想到，$2n/k$ 向上取整的方案肯定是存在的。

然后，当 $n < k$ 时需要煎 2 次，而上面的式子可能会得到 1 的错误答案。

因此，$\max(2, (2n+k-1)/k)$ 即为答案。

由于第一次打比较正式的比赛，之前没有对 codeblocks 等 IDE 进行适应也是一个问题（我日常 Emacs + 大量插件，一个队友日常 VS），感觉时间上面多少吃了些亏。

A A Greeting from Qinhuangdao

签到题，取两个，都是红色，$\frac{C_r^2}{C_{r+b}^2}$ 即可，注意约分，红球少于两个则为 $0$。

C Cameraman

题意：Bob 的房间为矩形，长宽已知；里面有若干私人物品，Bob 自身和私人物品均视为点，位置已知固定。Alex 给 Bob 拍照，位置自选，角度范围自定（可超过 180°）。要求拍到 Bob，不拍到私人物品，求可以拍到的最大墙壁总长度。如下图绿色部分。

这题大清再次背锅，只能靠样例来猜测 Alex 和 Bob 在同一个位置时最优，否则似乎不可做。

然后，利用极角排序，找到一个方向，让直线和它两边的点紧贴，计算出结果。

由于队伍内计算几何比较薄弱，这题虽然不算难但还是在细节上出了不少问题，再加上平台上 C 题的自测是坏的（估计是因为自测没有 spj），导致比赛期间怀疑评测机有问题，浪费了大量时间。

E Exam Results

题意：有若干学生考试，每人有可能获得一高一低两个成绩（可能相等），且无法预测。本次考试的及格线为 $最高分 \times ratio$，求所有情况中，可能的最多及格人数。

对于一个人的成绩 $x$，在最高分不高于 $x/ratio$ 时，他可以及格。当然，最高分不可能低于 $x$，否则他自己的成绩将成为最高分，又因为他可能有两种成绩 $a, b$，所以当最高分位于 $[a,a/ratio]\cup[b,b/ratio]$ 时，他可以及格。

然后，我们把所有人的可能的较低分数取一个最大值，最高分至少等于它，而比它高的每个成绩也都可能作为最高分。然后枚举这个最高分，判断它在多少个人的可及格区间内，找出最大值即为答案。

数区间数量可以用线段树或者树状数组，区间更新+单点查询解决。

由于输入是百分比整数，且所有人成绩是整数，可以成绩乘 $100$（int 溢出警告）再除，向下取整作为右端点。区间范围太大，需要离散化。

本人由于在开始写代码时忘记，“所有人的可能的较低分数取一个最大值，最高分最小时就等于它”的性质，导致耗费大量时间。

F Friendly Group

题意：组内的若干学生参加学术会议。全组的友好值初始为 $0$。组内有若干对朋友，如果一对朋友同时参加，则友好值加 $1$，如果有且仅有其中一人参加，则减 $1$。最后，每个参加的人都会让友好值减 $1$。从中选择任意一部分人（可能一个都不选）参加，求可能的最高友好值。

把学生看作点，关系看作边，则友好值等于 $内部边数-跨内外边数-内部点数$。假如对于一个联通块，我们选了一部分人，那么连通块的其他部分的 $内部点数-内部点数$ 最少为 $-1$，加上它与已选部分之间的边，把整个连通块选进来结果一定不会比只选当前部分差。

因此，可以把整个连通块视为整体，用上面的公式计算，然后根据其值正负决定是否选择，最后对所有正结果取和即可得出最终结果。

G Good Number

题意：不大于 $n$ 的正整数中，有多少个可以被它的 $k$ 次方根（向下取整）整除。

对于每一个数 $i$，$[i^k,(i+1)^k)$ 开根向下取整均为 $i$，所以可以用该区间长度除以 $i$ 即可得到可被 $i$ 整除的个数。由于区间的第一个数就可被整除，所以有余数时向上取整。

由于 $n \leq 10^9$，当 $k \geq 30$ 时，所有数开根都是 $1$。

I Interstellar Hunter

题意：在一个无限制的二维空间内，Alex 一开始在原点，他会不断获得按照一个二维向量进行移动的能力，利用每个能力可以正向或反向移动无限次。询问是否可以到达特定的位置。存在多次询问，获得能力和询问可交替出现，每次询问附带价值，最后输出可到达的询问的价值之和。

对于二维向量 $\boldsymbol a$ 和 $\boldsymbol b$，利用它们能走到的位置，也就是它们的线性组合。进行变换 $\boldsymbol a = \boldsymbol a - \boldsymbol b$，它们的线性组合并不会改变。因此我们可以对它们进行辗转相除。如 $\boldsymbol a = (x_0,y_0), \boldsymbol b = (x_1,y_1)$，对其 $x$ 进行辗转相除，计算（加减乘）时使用整个向量。这样就会得到 $\boldsymbol a = (gcd(x_0,y_0), y_0’), \boldsymbol b = (0,y_1’)$ 。这样我们就可以利用询问的 $x$ 坐标轻易得出 $\boldsymbol a$ 的系数，或是不能整除直接得出不可达，然后再判断 $y$。然后出现新的向量的话，我们先将它与 $\boldsymbol a$ 进行辗转相除，使其 $x$ 为 $0$，再与 $\boldsymbol b$ 对 $y$ 辗转相除，这样它就变成无用的零向量了。

为了使当 $a$ 与新的向量进行辗转相除时在 $y$ 方向上最优，需要在 $y_0’ \geq y_1’$ 时对其相减，也就是取模。另外本题部分写法需要对 $0$ 进行特殊考虑。

K Kingdom’s Power

题意：在一个战略游戏中，地图为树形，国王在根部（点 $1$），有无限的士兵，开始全部在点 $1$。每周可以让一个军队移动到一个相邻点。求他们走一遍所有地区（可重复）至少需要的周数。

首先，对于每个非叶子节点，它都在从根节点到它对应子树的各点的必经之路上。因此只需考虑遍历所有叶子节点。

一个必然可行的方案是，对每个叶子节点，由一支军队从根部走过去。所需时间是所有叶子节点深度之和，以此作为基准值，考虑如何节省时间。

如果对某个有多个子节点的节点 $X$，如果 $X$ 的某个军队在走到了某个叶子节点 $A$ 后回来，再进入 $X$ 下面的另一个子树，则对另一个子树的某一个叶子节点来说，从根（记作 $R$，下同）到 $X$ 的路径 $d_{RX}$ 被替换为了 $d_{AX}$，节省的时间为 $d_{AX} - d_{RX}$。

对于某个节点 $X$，如果它下面的某个子树下有两个叶子节点 $A,B$，有两个军队分别从根部走到 $A,B$ 再回到 $X$，则可节省的时间为 $d_{RX} - d_{AX} + d_{RX} - d_{BX}$。此时，设 $A,B$ 的 LCA 为 $Y$，则改用如下方案：一个士兵走到 $A$ 后回到 $Y$，再进入 $B$，然后回到 $X$，则可节省的时间是 $d_{RY} - d_{AY} + d_{RX} - d_{BX}$。而 $Y$ 在 $X$ 和 $A$ 之间，$d_{AY} < d_{AX}$，$d_{RY} > d_{RX}$，后者节省的时间更多。该情况可类推到更多叶子节点的情况，从而可得到性质：对于每个子树，最多只会有一个军队从它返回到它的根节点的父节点。

然后，对于刚刚的情况，假如都要返回 $X$，则交换 $A,B$ 的位置，总的结果不变。但如果最后不返回 $X$，那么设最后的点为 $B$，设返回 $X$ 的情况下总共节省的时间为 $T$，则不返回的情况就要减去那一部分，则为 $T + d_{BX} - d_{RX}$（$B$ 越深，该值越大），如果它优于 $T$，则不用返回。因此，我们在考虑子树时，把最深的放到最后，在返回父节点的情况下不影响结果，在不返回父节点的情况下结果优于其他顺序。因此，我们应在子树内计算时优先考虑较浅节点，最后把最深节点的深度用于父节点判断是否需要该子树返回。

这样我们可以对整个树进行一次 dfs，dfs 过程中判断军队是否要从当前点下面的各个子树返回到当前点。根据上一段的分析，用各子树的最深节点判断，则在 dfs 过程中获取子节点的高度（叶子为 $1$，记作 height）即可。同时传一个参数表示遍历深度（根为 $0$，记作 dep）。则对于每个子树，如果要返回，节省的时间为 $dep - height$，该值大于 $0$ 则返回，把结果减去该值。

最后，如果某节点下的所有子树都选择返回，则意味着不存在最后进入的叶子节点，这样得到的结果显然是不合理的，需要让某一个不返回。很显然，让减少的时间最少（深度最大）的一个不返回即为最优。

核心部分代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

int dfs(int pos = 1, int dep = 0) {
  if (ch[pos].empty()) {
    ans += dep;
    return 1;
  }
  int height = 0;
  bool flag = 1;
  for (auto p : ch[pos]) {
    auto tmp = dfs(p, dep + 1);
    height = max(height, tmp);
    if (tmp < dep)
      ans -= dep - tmp;
    else
      flag = 0;
  }
  if (flag) ans += dep - height;
  return height + 1;
}

平铺窗口管理器是否好用这个问题就不说了，不喜欢它的用户可能永远用不惯，但喜欢它的用户则很容易对它形成依赖。在 Linux 的各个桌面环境中，KDE 可以说是最受欢迎的一款，无论是外观、功能还是易用性都很出色，全局菜单等功能也做得很好。

但是，KDE 的窗口管理器没有原生的平铺模式。虽然它提供脚本扩展的能力，也有不少实现平铺的脚本可以使用，但效果远远不如一个原生的平铺窗口管理器。经常会有一些情况没有被脚本控制到的情况，且它们的可定制性也远不如其他的 Tiling WM。

本文将介绍我尝试过一些缝合 KDE 和 Tiling WM 的方案，并在最后给出目前使用的 patched i3。

原版 i3 或 i3-gaps

存在问题

说起平铺窗口管理器，最著名的无疑是 i3，在关于 KDE 搭配平铺窗口管理器这个讨论量并不大的话题中，i3 占了大部分。我也曾经使用 KDE + i3 近一年的时间，但存在大量的问题。

KDE 的大量组件在 i3 上不会自动被设置为 floating，需要自己写规则。而部分组建即使 floating 也不行，比如桌面，只能 kill 掉然后用独立的壁纸设置工具（如 feh）代替，再比如往 panel 添加部件的侧边窗口会全屏（除 panel 区域）显示，并有一定几率崩掉，需要 kill plasmashell 再重新运行，等等。

通知窗口的问题最让人头疼，KDE 的通知窗口会被直接显示在屏幕的正中心。通常推荐的方法是设置规则向右上方移动固定的像素，这样做效果可想而知，不同尺寸的通知窗口移动后间距显然不同，特别长的还会超出屏幕，再加上多个窗口有时会叠在一起的问题。而自己写一个脚本处理这些问题的话，对于多个通知窗口的处理也很麻烦。

如果更换通知 daemon，首先目前没有太多独立的通知 daemon，很多都是要么太简陋，要么和桌面环境耦合。好看一点的界面 + 桌面托盘图标 + 少量的自定义都很难满足。一般 i3 常用的是 dunst，它的通知按钮、历史通知等功能都只能通过快捷键。linux_notification_center 看起来不错，但如果尝试在 KDE 上使用的话，由于 KDE 的通知 daemon 无法关闭，只能让其他的通知 daemon 抢占 dbus。而这个工具我试过很多种方法都不能抢占到（dunst 用 systemd user unit 可以）。

bspwm

优缺点

最近我也考虑其他窗口管理器，由于不想去搞我不熟悉的 lua、haskell 等，尝试了配置简单的 bspwm，发现它有以下几个优点：

• 会自动 floating 部分窗口，且对 KDE 的各种窗口有很好的兼容性，无需额外规则，即可正常显示所有窗口，上面提到的几个兼容问题都没有出现
• 有独立的键绑定工具，而且所有操作通过命令实现，你甚至完全可以用别的快捷键工具代替

不过它还是有一些美中不足的地方：

• 全屏后，其他窗口会出现在该窗口之下，桌面之上，影响透明效果。由于我比较喜欢全局透明的效果，所以这个问题对我影响很大
• 调度器中会显示所有虚拟桌面，即使其中没有窗口，导致 panel 中的虚拟桌面控件过长

另外，bspwm 本身很多地方个人觉得是不如 i3 顺手的。不过，如果你不常使用透明，bspwm 也是一个比较可用的方案。下面是具体的使用方法

如何使用 bspwm

基本配置

更换窗口管理器的方法同 i3，把环境变量中 i3 改为 bspwm 即可

bspwm 本身并不需要太多的配置，唯一必要的一条就是根据你的 KDE panel 设置边距。比如用了 28px 的 top panel，那么就需要加入规则 bspc config top_padding 28。值得注意的是，bspwm 的配置全部是命令，它的配置文件就是一个 bash 脚本，因此你可以动态地添加各种规则，经测试之后再加入 bspwmrc。

快捷键

bspwm 的快捷键程序是一个独立的二进制程序 sxhkd。bspwm 的各种功能调用基于命令，你可以不用 sxhkd，改用 KDE 自带的快捷键工具。不过，把这些快捷键一条一跳加到 KDE 的快捷键中工作量很大（不知道有没有方便的方法），所以还是建议 sxhkd，注意把冲突排除掉，否则 sxhkd 可能不生效。

sxhkdrc 的格式非常简洁，基本上看一眼就会知道怎么写。

混成器

推荐使用 picom，具体介绍看 patched i3 部分。

搭配 bspwm 使用时如果出现设置透明后，部分窗口失去焦点就不透明的情况，可设置 mark-ovredir-focused = false。

patched i3

介绍

这是我目前使用的方案，本部分也是本文的最主要部分。

KDE + i3 的主要问题 i3 是不能很好地 handle KDE 的一些窗口，针对这个问题，存在一些 fork，不过没有进入主线（连 gaps 都进不了主线你还想进？），热度也不高。

目前还处于活跃维护状态的分支是 PJK136/i3，它和它之前的 fork 的 kde-master 分支是基于原版 i3 的，PJK136 自己搞了一个合并了 i3-windows-icons 分支（标题栏显示图标等）的分支。

我喜欢无窗口边框的设计，因此间距肯定是必要的。我尝试了合并它和 i3-gaps，目前使用没有发现大问题，使用效果非常好。后面我会尽量维护更新这个分支（绝对不咕.jpg）。

项目地址 h0cheung/i3-gaps-kde，AUR 已打包：i3-gaps-kde-git。当然你也可以使用 PJK136 的版本，他的 kde-wm-icons-master 分支 repo 中提供了 PKGBUILD。

下面是一个简单的使用方法

如何使用 patched i3

基本配置

首先安装 KDE 和 i3，i3 的 patched 版本上面已介绍。

KDE 提供了一个环境变量 KDEWM 来指定窗口管理器，当然默认是 kwin。我们只需在 KDE 桌面启动前设置它为 i3 即可。最简单的方法（per user），写一个设置环境变量的脚本，比如用 sh 就像这样：

1
2

#!/bin/sh
export KDEWM=/usr/bin/i3

给予执行权限，然后在 KDE 的设置 → 开机与关机 → 自动启动中加入该脚本，并设置为在会话启动之前即可。 从 5.20 版本开始，该功能似乎已经被移除，可以根据使用 pam、dm、xinit 等方法设置该环境变量，详见各发行版或相关工具的文档。当然你也可以写一个 session，这样可以在 dm 里面选择是否用 i3。

经过 patch 的 i3 可以直接用于 KDE，不再需要各种 wiki、论坛上推荐的那堆配置，KDE 的桌面壁纸也可正常使用。对于通知等窗口偷焦点等小问题，简单地加入少量配置即可，比如：

1
2
3
4
5
6
7
8

# disable focus
no_focus [class="plasmashell"]
no_focus [window_role="pop-up"]
no_focus [window_type="notification"]

focus_on_window_activation none
focus_follows_mouse no
mouse_warping none

快捷键

i3 的快捷键是直接由 i3 主程序控制的，建议用 i3 设置快捷键，不在 KDE 中设置。

i3 默认的快捷键基本都是比较好用的，像我就只改了 dmenu 为 krunner，方向键设置为 hjkl，再把冲突的 h 处理了一下。

具体可见我的 dotfiles。

混成器

首先，KDE 自带的混成器是集成在 kwin 中的，不用 kwin 就别考虑了。i3 和 bspwm，以及绝大多数 Xorg 下的窗口管理器也都没有自带混成器。（Wayland 下 WM 必须带混成功能）

Linux 下独立的混成器其实并不多，主流的就一个多次被 fork 改名的，它最新最主流的版本叫 picom，这个混成器主要的优势就是自定义较为强大。

个人的设置主要是关闭 shadow，backend 用 glx，设置了一些透明效果的规则（除了一小部分单独设置，其余窗口都 15% 透明），等等。

当然这部分配置个人喜好不同，可以自行找相关资料（关于 compton 的资料也能参考，大部分兼容）并编写自己的配置。

后记

虽然我做了很多折腾，本文中也提到了多种方法，但是最希望出现的情况还是 kwin 可以支持 Tiling 模式。

另外，StumpWM 等窗口管理器据说也可以较好地配合 KDE，可以考虑尝试。

其实 fcitx5 已经被偷偷开发了很久了，但是进度比较缓慢。不过，现在的 fcitx5 也已经基本可用。cn 源里的 fcitx5-config-qt-git 包和官方源里的 kcm-fcitx5 都解决了对 KDE 过度依赖的问题（自己编译的话依赖还是很多）。日常使用也没有太大的问题，有兴趣的可以尝试。

安装使用

Arch Linux 用户可以使用 cn 源里的版本（-git 结尾），或官方源里的版本，前者更新打包极其频繁，后者则相对少一些。另外，后者没有 qt4 模块，cn 源和 AUR 也没有可以和它一起使用的 qt4 模块，或许可以自己改 fcitx5-qt4-git 的依赖试试（那干嘛不直接用前者）。

需要安装的包基本上和 fcitx 的类似，我自己安装了的有 fcitx5-chinese-addons-git，fcitx5-git，fcitx5-gtk-git，fcitx5-qt4-git，fcitx5-qt5-git，fcitx5-rime-git，kcm-fcitx5-git。

主要区别就配置工具换成了 kcm-fcitx5（git 版本非 KDE 用户用 fcitx5-config-qt-git）。

其他发行版用户先看源里有没有，没有的话可以尝试找第三方源，或者自己编译/解包后打包并安装。

装上之后用你喜欢的方式设置如下环境变量（由于漏洞的原因，.pam_environment 将不再默认读取，可以根据你的情况考虑 .xprofile、.profile、.zshenv 等）：

1
2
3

GTK_IM_MODULE=fcitx
QT_IM_MODULE=fcitx
XMODIFIERS=@im=fcitx

拼音输入

fcitx5 的自带拼音有一定改进，同时也提供了 rime。rime 仍然不能使用云拼音。至于想使用搜狗输入法的，建议点击右上角的$\times$。

对于两个拼音输入的比较，个人认为新的自带拼音好于 rime 明月拼音简化字的默认配置，并且也提供了不少常用的自定义选项。如果你不怎么在乎隐私，或者对云拼音提供商（目前支持咕果/咕果CN/百毒）很信任的话，使用云拼音会有不错的体验。不过重度折腾下还是 rime 可定制性最好，并且跨平台同步折腾好之后效果也不错。

拼音推荐设置：

• 启用预测
• 启用颜文字
• 云拼音看自己需要
• Show preedit within application（单行显示）
• 快捷键自己设置
• 词典：可适当导入搜狗词库

rime 的话 fcitx5 提供的额外设置就一个单行显示，建议打开。

主题美化

fcitx5 的主题有一定变化，fcitx 的主题不能直接使用，而 fcitx5 的主题很少。

一种选择是使用 kimpanel，不使用的话，推荐 hosxy/Fcitx5-Material-Color，比较简洁，风格类似微软拼音，配色为 Material，建议配合单行模式，建议打开“按屏幕 DPI 使用”，然后把字体调小到合适的程度。

fcitx5-remote

fcitx5-remote 的行为与 fcitx-remote 没有明显区别，使用此功能的工具只需修改调用的命令即可。如果命令是硬编码的，不想改源码可以直接 ln -s。

需要的工具

要进行全局代理，常见的方式是转发到特定端口、使用 tun 虚拟设备和使用 TPROXY。clash 有 redir port 可以直接转发实现代理，但是只支持 TCP，IPv6 的支持也尚未合并。TPROXY 是 v2ray-core 的推荐方式。而另一种方式则是 tun。本文介绍的是使用 tun 的方式。

要使用这种方式，首先需要一个使用 tun 转发流量的工具，目前 clash 主线并不支持 tun，clash 作者有一个支持 tun 的闭源版本，另外 comzyh 有一个支持 tun 的分支，性能不错，稳定性一般。然后有一个通用的工具 tun2socks，稳定性较好但性能一般。后两者都不错。

comzyh 的 clash 分支

go-tun2socks

需要的知识

基本的路由表、iptables 操作

设置转发路由

首先需要使用 ip tuntap add <tun name> mode tun user <tun user> 创建一个 tun 设备，并使用 ip link set <tun name> up 启用。

然后设置路由 ip address replace <tun address> dev <tun name>，tun address 取一个不常用的 IP 段，比如 kr328 的脚本中使用 172.31.255.253/30，又比如 go-tun2socks 默认的 10.255.0.1/24。

然后设置路由规则

1
2

ip route replace default dev <tun name> table <route table id>
ip rule add fwmark <fwmark id> lookup <route table id>

把有特定 fwmark 标记的流量路由到 tun 其中 fwmark 号和 route 表号可以自行设定（不要和其他的规则重复）。

然后用 iptables 在 mangle 表上，把需要代理的流量打上 fwmark 标记，使用 -j MARK --set-mark <fwmark id> 即可

绕过部分流量

利用 iptables 支持的丰富规则，我们可以灵活地绕过各种流量，列出几个比较常用的：

• -m owner --uid-owner <username or uid> 匹配某个用户的流量，类似的还有 --gid-owner
• -p <'tcp', 'udp' or 'icmp'> 匹配某种类型流量
• --dport <port num> 匹配目的端口，类似的 --sport 匹配源端口，需要和 -p tcp 等连用
• -d <network name, hostname, subnet(IP CIDR) or IP> 匹配目的网络/主机名/子网/IP
• -m set --match-set <ipset name> <'dst' or 'src'> 匹配 ipset，可以用于简化规则，ipset 用法自行搜索
• -m cgroup --cgroup <cgroup id> 匹配 cgroup

有较多规则时可以创建规则链，并把 OUTPUT 或 PREROUTING 链中的流量转入该链（ip6tables 也一样）：

1
2
3

iptables -t mangle -N <chain name>
iptables -t mangle -F <chain name>
iptables -t mangle -I OUTPUT -j <chain name>

然后在规则链上编写规则即可，需要打标记走代理就 -j MARK --set-mark <fwmark id>，需要绕过就 -j RETURN，一般建议先写绕过规则，最后无条件地打标记。注意一定要绕过 clash 的流量（建议 uid/gid 或 cgroup）

使用 cgroup net_cls

cgroup 是 Linux 内核的一个功能，这里需要用到它的 net_cls 子系统。使用起来简单，我们首先运行以下命令创建一个组：

1
2
3

mkdir -p /sys/fs/cgroup/net_cls/<cgroup name>
echo <cgroup id> > /sys/fs/cgroup/net_cls/bypass_proxy/net_cls.classid
chmod 666 /sys/fs/cgroup/net_cls/<cgroup name>/tasks

上述命令可以在开机时运行

这样，如果一个进程的 pid 在 /sys/fs/cgroup/net_cls/<cgroup name>/tasks 中，它就会被 iptables 的 -m cgroup --cgroup <cgroup id> 规则匹配到，并且这些进程的子进程 pid 会自动被添加。如果对安全比较敏感，你可以对该文件进行适当的权限控制。

可以使用一个脚本，以它作为 wrapper 来运行需要的命令

1
2
3

#!/bin/bash
echo $$ > /sys/fs/cgroup/net_cls/<cgroup name>/tasks
exec "$@"

单独转发 DNS

与 v2ray 不同，clash 不能通过其规则把流量转到 clash 的内置 DNS，且 clash 不支持 sni 解析域名，需要内置 DNS 反查域名。

因此，需要使用 nat 表把 DNS 流量转发到 clash 的 DNS 端口，对 UDP 53 端口的流量，设置适当的绕过规则过滤后，-j REDIRECT --to-ports <clash dns port> 即可。

tun 工具配置

comzyh 的 clash 分支需要在配置文件中设置以下内容

1
2
3

tun:
  enable: true
  device-url: dev://<tun name>

go-tun2socks 用以下命令启动

tun2socks -tunName <tun name> -proxyServer <clash socks server> -tunAddr <tun address> -tunGw <tun gateway> -tunMask <tun mask> -tunPersist -blockOutsideDns

选一个不常用的 subnet，并取该 subnet 内两个不同地址作为 tun gateway 和 tun address。

比如要使用 172.31.255.253/30 子网。则 tun mask 为 255.255.255.252，tun gateway 可以用 172.31.255.253，tun address 可以用 172.31.255.254，默认参数对应的子网是 10.255.0.1/24

  训练虽然有时很累，常常下午比赛，晚上学习算法知识，深夜时不时还有codeforces。但我们都一直在坚持，谁都不想让自己和队友付出的努力白费。训练似乎已经成为一种习惯，成为我们这个暑期生活中的一部分。

  但是，和我们一起训练的同学们真的都非常强，很多队伍的成绩都一直在上升，而我们队却似乎有些停滞不前，最为关键的最后一段时间表现也很一般。在倒数第二场训练中，由于对文件输入输出的不熟悉和字符串的软肋等，我们再次垫底。最后我们的排名到了能否拿CCPC资格的边缘。现在我们已经停止了每天一场的训练赛，开始休息和准备后面的几场更为关键的网络赛。

  我在这段时间的集训中，虽然状态有了一些提高，读题切题的速度也有了一些进步，但是自身的很多软肋方面一直进步非常缓慢。像字符串、数论等领域，我虽然最近都在学习，但还是完全处在非常差的水平。对于后面的几场网络赛，我也感到自己已经没有第一轮集训结束时的信心了，但我既然已经走到这一步，无论是为了队友还是自己，都应该尽力把自己能做的事做好。

  其实现在回头想想，从大一下开始学算法，到现在短短不到半年时间就开始接触比赛，这节奏的确非常快，快到让我有些难以接受。也许我还需要时间，去静下心来慢慢学习很多知识、慢慢完善自己，以取得更好的成绩，但对于眼前的训练、比赛，我会拼尽自己的能力，努力做到最好。加油吧，失败不属于我们！

  还好我后面还是参加了暑期前集训，当时每天都在举步维艰地学习各种基础知识，每次都被很多有基础的同学碾压。很多内容对我来说难到让人想要放弃，其中有一部分我到现在都还没有学会。在这个过程中我也常常担心进不了暑期集训，担心自己做过的一切都会付诸东流。这段时间我也开始接触codeforces，刚开始打的时候一直在掉分，好在掉到1375之后终于开始了回升。

  在这个暑假，我顺利地进入了集训，开始了每日的训练赛。我尽力调整好状态，尽量找签到题和自己比较擅长的思维方面的题目入手，有时取得了还算不错的成绩，但有时状态不佳稍有失误就被挤到了40+名，更多的时候则是成绩平平。在整个训练过程中，无论是过题数还是罚时，我都很少能取得优势。这段时间，我几乎每天都很晚睡觉，一方面我有时会一直写题到晚上，另一方面我也开始经常失眠。在这段时间的训练中，我感觉自己解题的思维逐渐变得清晰，编码能力也在逐步提高，codeforces打到了1644，并且还可能继续上涨。我的名次到了中间靠前的位置，我也开始憧憬我以前从来没有敢想的第二轮集训，但与此同时，我开始越来越担心自己会不会最后又掉出去，尤其是最后一场，几乎整个人都在高度紧张中，直到以很低的罚时过了能做的题之后才长舒了一口气。最后，我还是幸运地保持了自己的名次。

  我很高兴自己能够有机会继续参加集训，继续做自己想做的事，继续努力奋斗。我不会再去怀疑自己的能力，也不会再去怀疑自己所做的事。以后的训练也不再是一个人的战斗，而是一个队伍的共同进步。在以前，现在，和以后的训练中，也许最后我们很可能留不下什么成就，也不会被别人记住，但至少对我们自己来说，无论结果如何，这都是青春中一段美好的回忆吧。我曾浑浑噩噩地度过了近一年的时间，ACM训练让我重新燃起了斗志，让我愿意付出自己的时间和努力，去学习，去拼搏。能够进入第二轮的训练，是我最幸运的事，我也很希望我能够走得更长、更远。

注：运行环境为Arch Linux

需要安装的包

• gcc 如果不用pbds等，可以直接用clang编译，和gcc的差异基本上只有少量UB，__int128也是支持的，不过Linux基本上不能不装gcc
• llvm(clang) 除了作为一个编译器之外，还提供强大的自动补全、代码检查、代码格式化等相关工具，clion、qtcreator等都依赖它
• ccls 基于clang的LSP（language server protocol），完成度比clang的类似组件clangd更高。注意：更新clang后需要用新版本的clang重新编译ccls，否则可能会出现各种问题（包括完全挂掉）
• visual-studio-code 体验不错，插件生态非常好的编辑器

插件列表

• ccls 核心插件，提供语法检查、补全、高亮、变量重命名、code lens等等
• clang-format ccls的提供的格式化偶尔会抽风，单独用这个比较稳定
• Code Runner 一键编译运行
• easy-snippet 非常方便的snippet管理工具，可以用来存板子
• CodeLLDB 可选，整合lldb，偏好gdb的用户可以不装
• Vim 可选，vim模拟
• ICIE 拉取codeforces上面的题目和样例，并根据通用模板生成文件，并且可以一键测试，通过后直接submit，现在已经支持直接拉取正在进行或即将进行的比赛，除了hack和看榜之外可以不用打开浏览器
• Better Online Judge 和前者类似，用于vjudge上的比赛，功能较弱，拉取不了样例
• vscode-clangd 备用，比如在睡前更新clang后忘记重编译ccls，第二天开始打了发现ccls炸了，可以把clangd拉出来救急（亲身经历）。目前它的功能略弱于ccls，但毕竟是llvm官方的组件，不排除以后会赶超

注：如果使用第三方调试工具的话，不用安装微软官方的cpptools插件

建议修改的设置

ccls

可以调整自动补全的case sensitivity（大小写敏感）和detailed label（补全时显示标准库函数的详细功能）。高亮部分可以根据自己喜好调整，建议打开type aliases等

Code Runner

可以自己改运行命令，以下供参考：

1
2

"c": "cd $dir && gcc -g $fileName -o /tmp/ctest && time /tmp/ctest",
"cpp": "cd $dir && g++ -g $fileName -o /tmp/cpptest && time /tmp/cpptest",

Vim

VSCode的vim插件功能挺多的，尤其是支持neovim做后端，以下设置供参考

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

"vim.easymotion": true,
"vim.enableNeovim": true,
"vim.sneak": true,
"vim.sneakUseIgnorecaseAndSmartcase": true,
"vim.statusBarColorControl": true,
"vim.autoSwitchInputMethod.enable": true,
"vim.autoSwitchInputMethod.defaultIM": "1",
"vim.autoSwitchInputMethod.obtainIMCmd": "/usr/bin/fcitx-remote",
"vim.autoSwitchInputMethod.switchIMCmd": "/usr/bin/fcitx-remote -t {im}",
"vim.foldfix": true,
"vim.neovimPath": "/usr/bin/nvim",
"vim.useSystemClipboard": true,

ICIE

"icie.template.list"下写你的通用模板的文件路径

Better Online Judge

这个插件的通用模板是硬编码的，直接修改~/.vscode/extensions/yiyangxu.better-oj-<版本号>/out/utils/template.js

这题要求调整部分边的方向，把有环的有向图中部分边反向，使其变成无环图，我们要求的是调整的边的最大权值最小的方案。首先我们要知道一个原理，如果无环图加入$A \to B$会使其变为有环图，那么$B\to A$一定是连通的，那么加入边$B\to A$不会使其成环。那么，我们删掉某些边得到无环图之后，必然可以加回来得到无环图。而如果我们删除权值不大于ans的所有边，我们可以很快地算出是否有环。如果有环，则ans一定小于答案，如果无环，则ans不小于答案。根据这一性质，我们可以二分套判环解决，判环使用拓扑方法，复杂度为$O((m+n)logM)M$可以是最大边权，也可以是边权的中位数（$O(n)$找中位数要多写不少代码，并且这题不必要）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define RST(a) memset(a, 0, sizeof(a))
#define RSTV(a, v) memset(a, v, sizeof(a))
#define FOR(i, a, b) for (auto i = a; i < b; ++i)
struct E {
  int v, w;
};
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  int n, m, M = 0;
  cin >> n >> m;
  vector<E> path[n + 1];
  FOR(i, 0, m) {
    int u, v, w;
    cin >> u >> v >> w;
    M = max(M, w);
    path[u].push_back({v, w});
  }
  int ans = M / 2;
  int tmp[2] = {0, M};
  do {
    vector<E> pathcpy[n + 1];
    int cnt[n + 1];
    RST(cnt);
    FOR(i, 1, n + 1) for (auto p : path[i]) if (p.w > ans) {
      pathcpy[i].push_back(p);
      ++cnt[p.v];
    }
    queue<int> q;
    FOR(i, 1, n + 1) if (!cnt[i]) q.push(i);
    int c = 0;
    while (!q.empty()) {
      ++c;
      int now = q.front();
      q.pop();
      for (auto p : pathcpy[now]) {
        --cnt[p.v];
        if (!cnt[p.v]) q.push(p.v);
      }
    }
    tmp[c == n] = ans + (c != n);//有环时答案大于ans，可以从ans+1开始
    ans = ((ll)tmp[0] + tmp[1]) / 2;
  } while (tmp[1] != tmp[0]);
  cout << ans;
}

B

这题是求免费一条边的最小生成树权值和，以及要使权值和等于该值的情况下，可以选择的免费边的数量。首先，最小生成树的算法这里不再累述，kruskal算法即可。然后根据贪心的思想易知第一个问题的答案为最小生成树总权值-最小生成树上最大边权值。然后难点就在于第二个问题。树上权值最大的边（可能有多条相等）如果能被另一条边替代，那么替代后免费新的边，也能得到相同的结果。所以我们要找到可以替换树上最大边的边。我们可以把最大边去掉（第一次并查集记录最大边条数，第二次并查集参考G题），这样树就出现了中断，然后我们需要寻找能够把中断补上的边。我们沿用kruskal算法的并查集，即可轻松判断一条边是否能补上中断。遍历一遍边即可，由最小生成树的性质，小边不可能替代大边，所以权值小于树上最大边的边可以直接略过。

最大部分的时间复杂度就是kruskal的时间复杂度，即$O(mlogm+mA(n)+n)$，其实复杂度最大的地方就是排序边的O(mlogm)

代码及注释：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define RST(a) memset(a, 0, sizeof(a))
#define RSTV(a, v) memset(a, v, sizeof(a))
#define FOR(i, a, b) for (auto i = a; i < b; ++i)

int fa[100001], depth[100001];
int find(int x) {
  if (fa[x] == x) return x;
  return fa[x] = find(fa[x]);
}
void connect(int u, int v) {
  u = find(u), v = find(v);
  if (depth[u] > depth[v])
    fa[v] = u;
  else {
    fa[u] = v;
    if (depth[v] == depth[u]) ++depth[v];
  }
}
struct E {
  int u = 0, v = 0, w = 0;
  bool operator<(E x) const { return w < x.w; }
};
E edge[200005];
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  int M = 0, n, m, i = 0, cm = 0;
  ll S = 0;
  cin >> n >> m;
  for (int i = 1; i <= n; ++i) fa[i] = i;
  for (int i = 0; i < m; ++i) {
    int u, v, w;
    cin >> u >> v >> w;
    edge[i] = {u, v, w};
  }
  sort(edge, edge + m);
  for (auto p : edge)//第一次并查集
    if (i == n - 1)
      break;
    else if (find(p.u) == find(p.v))
      continue;
    else {
      ++i;
      connect(p.u, p.v);
      S += p.w;
      if (p.w > M) {
        M = p.w;
        cm = 1;
      } else if (p.w == M)
        ++cm;//记录树上最大边的条数
    }
  for (int i = 1; i <= n; ++i) fa[i] = i;
  RST(depth);
  int cnt = i = 0;
  for (auto p : edge)
    if (i == n - 1 - cm)//跳过树上最大边
      break;
    else if (find(p.u) == find(p.v))
      continue;
    else {
      ++i;
      connect(p.u, p.v);
    }
  for (auto p : edge)//如果想进一步优化，可以保留第二次并查集的最后位置，然后从该位置-cm开始
    if (p.w >= M && find(p.u) != find(p.v)) ++cnt;
  cout << S - M << ' ' << cnt;
}

C

该题判断是否有欧拉路径，然后输出字典序最小的欧拉路径。判断欧拉路径根据出入度，所有点入度等于出度则有欧拉回路，入度比出度大一的点和出度比入度大一的点各一个（必须两者都有一个）则有欧拉路径（非回路）。然后是输出部分，如果是回路，要从有路的最小点作为起点。然后可以用一个dfs，从小的边开始搜，回溯的时候即可得到反向的欧拉路径，再反向输出即可。由于路径可能很长，搜索深度可能很深，dfs递归会发生栈溢出，可以加inline内联交给GNU的强大力量去解决（这样写甚至跑起来更快），也可以写非递归版的dfs（码量稍大）。复杂度$O(m)$

代码及注释：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define RST(a) memset(a, 0, sizeof(a))
#define RSTV(a, v) memset(a, v, sizeof(a))
#define FOR(i, a, b) for (auto i = a; i < b; ++i)
int n, m, ans[2000005], pos = 0, cnt = 0;
vector<int> path[1000005];
inline void dfs(int s) {//递归版
  while (!path[s].empty()) {
    int p = path[s].back();
    path[s].pop_back();
    dfs(p);
    ans[cnt++] = p;
  }
}
void dfs(int s) {//非递归版
  int stack[2000005], top = 0;
  stack[++top] = s;
  while (top) {
    int x = stack[top];
    if (path[x].empty()) {
      top--;
      ans[cnt++] = x;
    } else {
      stack[++top] = path[x].back();
      path[x].pop_back();
    }
  }
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cin >> n >> m;
  int i[n + 1], o[n + 1];
  RST(i);
  RST(o);
  FOR(j, 0, m) {
    int u, v;
    cin >> u >> v;
    path[u].push_back(v);
    ++i[v], ++o[u];
  }
  int s = 0, t = 0;
  FOR(j, 1, n + 1) {
    if (o[j] == i[j])
      continue;
    else if (o[j] - i[j] == 1) {
      if (s) goto shame;
      s = j;
    } else if (o[j] - i[j] == -1) {
      if (t) goto shame;
      t = j;
    } else
      goto shame;
  }
  if ((bool)s ^ (bool)t) goto shame;
  for (auto &p : path) sort(p.begin(), p.end(), greater<int>());
  if (!s)
    while (!o[++s])
      ;
  dfs(s);
  //递归版起点要单独输出一下  cout << s << ' ';
  while (cnt) cout << ans[--cnt] << ' ';
  return 0;
shame:
  cout << "What a shame!";
}

F

这题要求的是在一个有向，可能有环的正点权图上获取最大值。如果它是无环的，那么以终点的权作为边权求最长路即可（无环图不会到达一个点多次），因此，我们就考虑怎么处理环。这样就引入了缩点的概念(据说暴力也可以过?)，为了获取最大权，进入环中一个点后必然会把整个环吃完，然后从中选择合适的点出环。根据这一性质，我们可以找到图中的环（不一定是单层的环，标准的名称为强联通分量），把每一个环缩成一个点，权值为各点权值之和，环内点与环外点的路径都加在缩成的点上。实现的方法有Kosaraju、Tarjan（没错，又是这位图灵奖巨佬）等。本题以Kosaraju为例，从起点开始进行一次dfs，回溯时按顺序记录点，再在反向图上，按之前的记录逆序一次dfs，在第i次反向dfs中初次找到的点（当然，正向dfs中不可达的点要排除）就构成了第i个强联通分量。然后建立新图，按一开始说的无环图做法即可，正权图最长路相当于负权图最短路，使用spfa算法求解。Kosaraju的复杂度通常为$O(n+m)$，时间瓶颈在于spfa，复杂度最坏可达$O(mn)$

代码及注释：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define RST(a) memset(a, 0, sizeof(a))
#define RSTV(a, v) memset(a, v, sizeof(a))
#define FOR(i, a, b) for (auto i = a; i < b; ++i)
struct E {
  int v, l;
};
vector<int> path[3001], repath[3001];
int m, n, l[3001], dfn[3001], pos = 0, vis[3001], revis[3001], f[3001], point[3001], s, p[3001], dis[3001];
vector<E> fpath[3001];
inline void dfs(int now) {//正向dfs
  vis[now] = 1;
  for (auto &p : path[now])
    if (!vis[p]) dfs(p);
  dfn[pos++] = now;
}
inline void redfs(int now, int pos) {//反向dfs
  if (!vis[now] || revis[now]) return;
  revis[now] = 1;
  f[now] = pos;
  point[pos] += l[now];
  for (auto &p : repath[now]) redfs(p, pos);
}
void spfa() {
  RST(dis);
  queue<int> q;
  dis[f[s]] = point[f[s]];
  q.push(f[s]);
  bool has[3001] = {0};
  has[f[s]] = 1;
  while (!q.empty()) {
    int now = q.front();
    q.pop();
    has[now] = 0;
    for (auto p : fpath[now])
      if (dis[p.v] < dis[now] + p.l) {
        dis[p.v] = dis[now] + p.l;
        if (!has[p.v]) {
          q.push(p.v);
          has[p.v] = 1;
        }
      }
  }
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cin >> n >> m;
  int u[m], v[m];
  FOR(i, 0, m) {
    cin >> u[i] >> v[i];
    path[u[i]].push_back(v[i]);
    repath[v[i]].push_back(u[i]);//反向图
  }
  FOR(i, 1, n + 1) cin >> l[i];
  int np;
  cin >> s >> np;
  FOR(i, 0, np) cin >> p[i];
  RST(vis);
  dfs(s);
  int tmp = pos;
  pos = 0;
  RST(revis);
  for (int i = tmp - 1; i >= 0; --i) redfs(dfn[i], pos++);
  FOR(i, 0, m)
    if (f[u[i]] != f[v[i]])
      fpath[f[u[i]]].push_back({f[v[i]], point[f[v[i]]]});//建立缩点后的新图
  spfa();
  int M = 0;
  FOR(i, 0, np) M = max(M, dis[f[p[i]]]);
  cout << M;
}

G

这是本次的签到题，解题方法是根据贪心的思想，按权值从小到大取边，同时采用并查集判断边是否可取，这种算法被称为 kruskal算法，复杂度为$O(mlogm+mA(n)+n)$，瓶颈是边排序的$O(mlogm)$

代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#include <bits/stdc++.h>
using namespace std;
int fa[1001], depth[1001];
int find(int x) {
  if (fa[x] == x) return x;
  return fa[x] = find(fa[x]);
}
void connect(int u, int v) {
  u = find(u), v = find(v);
  if (depth[u] > depth[v])
    fa[v] = u;
  else {
    fa[u] = v;
    if (depth[v] == depth[u]) ++depth[v];
  }
}
struct E {
  int u, v, w;
  bool operator<(E x) const { return w < x.w; }
};
E edge[500000];
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  int n, m, k, pos = 0;
  cin >> n >> m >> k;
  for (int i = 1; i <= n; ++i) fa[i] = i;
  for (int i = 0; i < m; ++i) {
    int u, v, w;
    cin >> u >> v >> w;
    edge[i] = {u, v, w};
  }
  sort(edge, edge + m);
  int result = 0;
  for (auto p : edge)
    if (n == k)
      break;
    else if (find(p.u) == find(p.v))
      continue;
    else {
      connect(p.u, p.v);
      --n;
      result += p.w;
    }
  cout << result;
}

H

这题的思路没有什么好说的，很明显的网络流板题。下面简单说一下网络流（以后有时间可能会单独写一篇博客，也很可能会鸽）

网络流是一个有若干条带权（容量）边组成的，固定源点和汇点的有向图。本题要解决的是，从源点产生的流（本题中水流是个很形象的例子），经过各边汇集到汇点，这样的流的最大流量。显然，对于每个点，流入流出的量相等，总流量守恒；同时，每条边上的流量均不能超过该条边的容量。在思考怎么求出最大流的过程中，我们要了解一个非常重要的定理──增广路定理。当我们找到网络流中一条从源点到汇点的通路时，可以把这条通路的各段边的容量减少一个值 $a$，最好的情况下下，这样处理后的网络的最大流就减少了 $a$，这样的网络我们称之为残量（残留容量）网络，当残量网络中没有上述通路时，残量网络的最大流为0，原网络的最大流为$\sum a$，我们可以利用dfs找通路，$a$ 取路径上的最小残量，不断循环得出结果。

然而，这样做会存在一些问题

1.每次找到的路径可以是最好的路连接径吗？似乎不是。这种情况我们在数据结构专题的K题（点此进入）中遇到过，当时我们在删点的时候加入新的点来模拟反悔的操作。这里我们也可以加入反向边来模拟反悔的操作。 2.这样反复的dfs很耗时，可能会反复搜某一条边，尤其是各边容量的极差很大时。该算法称为Ford-Fulkerson算法，复杂度为$O(mC)$，通常只建议用来处理容量很小的图，如单位容量简单网络最大流的快速算法（其实我并不会）的其中部分步骤可以用它。可以采用bfs，即Edmonds-Karp算法来改进，复杂度为$O(nm^2)$。但是EK算法过这题似乎有点紧，有没有更快的做法？dinic、ISAP、等（其实两者原理很像，优化魔改之后界限并不是那么清晰）。

我们把所有的节点根据与源点的距离分层，找增广路时只取依层递进的路径，然后再重新分层，反复循环。复杂度最大为$O(mn^2)$（较松，还能加优化），具体实现如下（注意有注释的地方）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

#include <bits/stdc++.h>
using namespace std;
#define RST(a) memset(a, 0, sizeof(a))
#define RSTV(a, v) memset(a, v, sizeof(a))
#define FOR(i, a, b) for (auto i = a; i < b; ++i)
struct edge {
  int e, c;
};
int n, m, cur[201], tail = 0, depth[201];
bool visited[201];
edge edges[20001];
vector<int> path[201];
inline void addedge(int s, int e, int c) {//建图时把反向边位置也分配好，并且分配到正向边位置^1，便于快速找反向边
  edges[tail] = {e, c};
  path[s].push_back(tail++);
  edges[tail] = {s, 0};
  path[e].push_back(tail++);
}
bool dinic_bfs() {//通过bfs，逐层外扩，实现分层
  RST(depth);
  RST(visited);
  visited[1] = 1;
  queue<int> q;
  q.push(1);
  while (!q.empty()) {
    int now = q.front();
    q.pop();
    for (auto p : path[now]) {
      if (!visited[edges[p].e] && edges[p].c) {
        depth[edges[p].e] = depth[now] + 1;
        q.push(edges[p].e);
        visited[edges[p].e] = 1;
      }
    }
  }
  return visited[n];//如果汇点已不可达，说明已无增广路，则结束循环，否则继续
}
int dinic_dfs(int now, int cap) {
  if (now == n || !cap) return cap;
  for (auto &i = cur[now]; i < path[now].size(); ++i) {//加入cur数组实现当前弧优化，搜到每条点时之前已被搜过的点不会搜出新的增广路路径，因此可以直接跳过。
    auto &p = path[now][i];
    if (depth[edges[p].e] == depth[now] + 1 && edges[p].c) {
      int tmp = dinic_dfs(edges[p].e, min(cap, edges[p].c));
      edges[p].c -= tmp;
      edges[p ^ 1].c += tmp;//反向边加上相同的值，后面可以走这条反向边来反悔之前选的边
      if (tmp) return tmp;//找到有值的增广路，返回
    }
  }
  depth[now] = -1;
  return 0;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cin >> n >> m;
  while (m--) {
    int s, e, c;
    cin >> s >> e >> c;
    addedge(s, e, c);
  }//首先建图
  int result = 0;
  while (dinic_bfs()) {//然后开始跑分层
    RST(cur);
    int tmp;
    while ((tmp = dinic_dfs(1, INT_MAX >> 2))) result += tmp;//再在图中跑符合要求的增广路，找不到了就重新分层
  }
  cout << result;
}

I

这是一道很裸的有向图（无向图拆边，然后做法也一样）K短路问题，我们可以采用一个方向最短路算法初始化（dijkstra，spfa什么的都可以，时间很松），一个方向A*启发式搜索（这类题是$h(x)=h*(x)$的特例）的方法解题。最短路算法不再多说，对于A*算法，我们用一个优先队列，从起点开始，每次扩展其直接可达的边入队，这样的过程中，跑出i次第i短路时，它可以扩展出i+1次第i+1短路，由此，当某条边出队K次时可以终止，此时的路径长度就是第k短路的长度。复杂度（貌似）$O(kmlogm)$

代码及注释

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct edge {
  int v;
  ll w;
};
struct status {
  int p;
  ll l;
  bool operator<(status b) const { return l > b.l; }
};
struct astar {
  int v;
  ll g, f;
  bool operator<(astar b) const { return f == b.f ? g > b.g : f > b.f; }
};
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  int n, m, k, s, t;
  cin >> n >> m >> k >> s >> t;
  vector<edge> path[n + 1], repath[n + 1];
  ll dis[n + 1];
  int visited[n + 1];
  for (int i = 0; i < m; ++i) {//建立正向图和反向图
    int u, v, w;
    cin >> u >> v >> w;
    path[u].push_back({v, w});
    repath[v].push_back({u, w});
  }
  memset(dis, 0x3f, sizeof(dis));
  memset(visited, 0, sizeof(visited));
  priority_queue<status> q;
  dis[t] = 0;
  q.push({t, 0});
  while (!q.empty()) {//反向dijkstra算法求最短路，预处理出h(x)
    status now = q.top();
    q.pop();
    if (visited[now.p]) continue;
    visited[now.p] = 1;
    for (auto &p : repath[now.p]) {
      if (dis[p.v] > dis[now.p] + p.w) {
        dis[p.v] = dis[now.p] + p.w;
        q.push({p.v, dis[p.v]});
      }
    }
  }
  memset(visited, 0, sizeof(visited));
  priority_queue<astar> paths;//然后正向通过A*算法得出结果
  paths.push({s, 0, dis[s]});
  while (!paths.empty()) {
    astar now = paths.top();
    paths.pop();
    if (++visited[now.v] == k && now.v == t) {
      cout << now.f;
      return 0;
    };
    if (visited[now.v] > k) continue;
    for (auto p : path[now.v])
      paths.push({p.v, p.w + now.g, p.w + now.g + dis[p.v]});
  }
  cout << -1;//跑完之后仍找不到，则说明没有
}

J

这道题目给了我们一个二分图，然后希望求一个最小的点的数量，来覆盖这一个二分图的所有边。我们求出最大匹配，在每个匹配的其中一个点上放置一个点即可覆盖，因此该题实际上是求最大匹配数，我们把二分图各边的容量设为1，然后加入源点s并依次连至左边的元素，右边的元素依次连至汇点t，该问题便转化为了一个网络流问题，而且是单位容量的简单网络流。对于这种特殊情况的网络流，可使用Hopcroft算法达到$O(m\sqrt n)$的复杂度，使用常规的dinic算法也可以平稳通过。以下代码为dinic算法（具体做法见H题）

代码及注释：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include <bits/stdc++.h>
using namespace std;
#define RST(a) memset(a, 0, sizeof(a))
#define RSTV(a, v) memset(a, v, sizeof(a))
#define FOR(i, a, b) for (auto i = a; i < b; ++i)
struct edge {
  int e, c;
};
int a, b, m, cur[200002], tail = 0, depth[200002], End;
bool visited[200002];
edge edges[500000];
vector<int> paths[200002];
inline void addedge(int s, int e, int c) {
  edges[tail] = {e, c};
  paths[s].push_back(tail++);
  edges[tail] = {s, 0};
  paths[e].push_back(tail++);
}
bool dinic_bfs() {
  RST(depth);
  RST(visited);
  *visited = 1;
  queue<int> q;
  q.push(0);
  while (!q.empty()) {
    int now = q.front();
    q.pop();
    for (auto p : paths[now]) {
      if (!visited[edges[p].e] && edges[p].c) {
        depth[edges[p].e] = depth[now] + 1;
        q.push(edges[p].e);
        visited[edges[p].e] = 1;
      }
    }
  }
  return visited[End];
}
int dinic_dfs(int now, int cap) {
  if (now == End || !cap) return cap;
  for (auto &i = cur[now]; i < paths[now].size(); ++i) {
    auto &p = paths[now][i];
    if (depth[edges[p].e] == depth[now] + 1 && edges[p].c) {
      int tmp = dinic_dfs(edges[p].e, min(cap, edges[p].c));
      edges[p].c -= tmp;
      edges[p ^ 1].c += tmp;
      if (tmp) return tmp;
    }
  }
  depth[now] = -1;
  return 0;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cin >> a >> b >> m;
  End = a + b + 1;//0为源点，1到a+b为二分图中点，a+b+1为汇点
  while (m--) {
    int s, e;
    cin >> s >> e;
    addedge(s, e + a, 1);
  }
  FOR(i, 1, a + 1) addedge(0, i, 1);
  FOR(i, 1, b + 1) addedge(i + a, End, 1);//建好图，后面就搬H题过来了
  int result = 0;
  while (dinic_bfs()) {
    RST(cur);
    int tmp;
    while ((tmp = dinic_dfs(0, INT_MAX >> 2))) result += tmp;
  }
  cout << result;
}

K

这题求的是免费K条边的最短路。我们的一个容易想到的直观的思路是做分层图，把已经免费的次数作为一个维度建图，但是如果完整的建完整张图，会导致内存超出，而分层图中存在大量的重复边，可以都从第一层取边，然后再加上跨层的边。但我觉得这题更好的思路是，最短路算法本质上是一个一维状态的动态规划（dijkstra偏向于贪心，是bfs的扩展，但其本质上仍然是动态规划的一种），而这题我们需要的是一个二维的动态规划。我们可以按照最短路算法思路，在其基础上使用位置+已免费边数的状态替换位置状态，在状态转移的过程中，由最短路算法的$dis[q]=min{dis[p]+w(p\to q)}$，拓展为$dis[q][h]=min({dis[p][h]+w(p\to q)},{dis[p][h-1]})$，p为所有存在边$p\to q$的点。然后该方程的性质仍然满足dijkstra的要求（转移过程中$dis[q][h]$不小于$dis[p][h]$和$dis[p][h-1]$)，因此可以按照dijkstra的思路，用修改版的dijkstra求解。复杂度$O(kmlogkn)$。spfa的话，直接交貌似会TLE，SLF优化貌似对这种情况效果比较好。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define RST(a) memset(a, 0, sizeof(a))
#define RSTV(a, v) memset(a, v, sizeof(a))
#define FOR(i, a, b) for (auto i = a; i < b; ++i)
int s, t, k;
ll dis[10005][25];
struct status {//原版dijstra是位置+当前位置的最短路，这里增加来b表示免费的次数
  int a = 0, b = 0;
  ll dis;
  bool operator<(status x) const { return dis > x.dis; }//注意这里dis要静态保存，去掉dis然后动态计算(return dis[a][b] > dis[x.a][x.b])会导致顺序出错，WA on 10
};
struct edge {
  int v = 0, w = 0;
};
vector<edge> path[10005];
ll dijkstra() {
  RSTV(dis, 0x7f);
  priority_queue<status> q;
  for (auto &p : dis[s]) p = 0;
  q.push({s, 0});
  bool visited[10005][25];
  while (!q.empty()) {
    status now = q.top();
    q.pop();
    if (visited[now.a][now.b]) continue;
    visited[now.a][now.b] = 1;
    for (auto &p : path[now.a]) {
      if (dis[p.v][now.b] > dis[now.a][now.b] + p.w) {
        dis[p.v][now.b] = dis[now.a][now.b] + p.w;
        q.push({p.v, now.b, dis[p.v][now.b]});
      }//第一种转移，同正常的dijkstra
      if (now.b < k && dis[p.v][now.b + 1] > dis[now.a][now.b]) {
        dis[p.v][now.b + 1] = dis[now.a][now.b];
        q.push({p.v, now.b + 1, dis[p.v][now.b + 1]});
      }//第二种转移，跨层，dis值不增加
    }
  }
  return dis[t][k];
}
signed main() {//建图，跑最短路，输出
  ios::sync_with_stdio(0);
  cin.tie(0);
  int n, m;
  cin >> n >> m >> k >> s >> t;
  while (m--) {
    int u, v, w;
    cin >> u >> v >> w;
    path[u].push_back({v, w});
    path[v].push_back({u, w});
  }
  cout << dijkstra();
}

L

这题有些复杂，购买物品需要花费，购买某个集合的所有物品可获得相应的奖励，答案要求是两者差最大，而不是限制最大花费。这样看起来比动态规划中01背包问题复杂得多。这种问题称为最大权闭合子图问题，我们从源点连接所有的物品，所有集合连向汇点，容量均取正。然后根据包含关系，用无限容量的边连接物品和集合。这样一来，就可以用割去某个物品到源点的边模拟购买此物品，某个集合被买完之后其到终点的流被切断。这样一来我们求一个割，即使得所有的边都被割断，所花费的最小代价，这样对于每个集合，要么获得并且花费了相应的代价，要么放弃了该集合。所有集合的总的压岁钱数量减去此时的割，就是他可以剩下的压岁钱。我们要求最大的剩余压岁钱，就要求最小割。显然，我们按照最大流的路径去割是最佳方案，这样最小割就等于最大流（最大流做法见H题）。复杂度$O((n+m)^2\sum k)$

代码及注释

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define RST(a) memset(a, 0, sizeof(a))
#define RSTV(a, v) memset(a, v, sizeof(a))
#define FOR(i, a, b) for (auto i = a; i < b; ++i)
struct E {
  int e, c;
};
int n, m, t, depth[20002], tail = 0, cur[20002];
E edges[250000];
bool visited[20002];
vector<int> paths[20002];
inline void addedge(int s, int e, int c) {
  edges[tail] = {e, c};
  paths[s].push_back(tail++);
  edges[tail] = {s, 0};
  paths[e].push_back(tail++);
}
bool dinic_bfs() {
  RST(depth);
  RST(visited);
  visited[0] = 1;
  queue<int> q;
  q.push(0);
  while (!q.empty()) {
    int now = q.front();
    q.pop();
    for (auto p : paths[now]) {
      if (!visited[edges[p].e] && edges[p].c) {
        depth[edges[p].e] = depth[now] + 1;
        q.push(edges[p].e);
        visited[edges[p].e] = 1;
      }
    }
  }
  return visited[t];
}
int dinic_dfs(int now, int cap) {
  if (now == t || !cap) return cap;
  for (auto &i = cur[now]; i < paths[now].size(); ++i) {
    auto &p = paths[now][i];
    if (depth[edges[p].e] == depth[now] + 1 && edges[p].c) {
      int tmp = dinic_dfs(edges[p].e, min(cap, edges[p].c));
      edges[p].c -= tmp;
      edges[p ^ 1].c += tmp;
      if (tmp) return tmp;
    }
  }
  depth[now] = -1;
  return 0;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cin >> n >> m;
  FOR(i, 1, m + 1) {
    int tmp;
    cin >> tmp;
    addedge(0, i, tmp);
  }
  t = m + n + 1;
  int sum = 0;
  FOR(i, m + 1, t) {
    int c, k;
    cin >> c >> k;
    sum += c;//计算所有集合的压岁钱数量总和
    addedge(i, t, c);
    while (k--) {
      int tmp;
      cin >> tmp;
      addedge(tmp, i, INT_MAX >> 1);
    }
  }//建图完，0为源点，1到m为物品，m+1到m+n为集合，m+n+1为汇点，然后跑最大流
  int result = 0;
  while (dinic_bfs()) {
    RST(cur);
    int tmp;
    while ((tmp = dinic_dfs(0, INT_MAX >> 1))) result += tmp;
  }
  cout << sum - result;//输出结果
}