「做题记录」贪心构造选做
stripe_python
·
2026-03-18 10:47:18
·
算法·理论
先写一些贪心的基本理论,然后做题。
调整法
记 S 为问题的解空间。对于 x\in S ,定义 f(x) 为解 x 的价值。声称集合 T\subseteq S 中的解必为最优解,用调整法证明时需要满足下面两个条件:
这里的有限性必不可少。
邻项交换
对集合 S ,设 a_i 是由 S 中若干不等元素组成的序列,定义序列 a 的得分为 f(a) 。
找到 S 上的二元关系 \prec ,使得对任意 a_i\prec a_{i+1} ,交换 i,i+1 得到序列 b 后,有 f(b)\ge f(a) 。
Exchange Argument 结论:若 \prec 是 S 上的严格全序,则构造序列 a 满足 \forall i,a_i\prec a_{i+1} 可以使得 f(a) 最大化。
称 \prec 是 S 上的严格全序 ,需同时满足以下四个性质:
反自反性:\forall x\in S,\lnot(x\prec x) 。
非对称性:\forall x,y\in S,x\prec y\implies\lnot(y\prec x) 。
连接性:\forall x,y\in S,x\prec y\lor y\prec x 。
传递性:\forall x,y,z\in S,x\prec y,y\prec z\implies x\prec z 。
事实上,由反自反性和传递性可以推出非对称性。
举例:小于 < 是 \mathbb{R} 上的严格全序,但是小于等于 \le 不是,因为其不满足反自反性和非对称性。
:::::info[练习 1]{open}
记字符串 A,B 首尾拼接的结果为 AB ,< 表示字典序比较。定义二元关系 \prec 为:A\prec B\iff AB<BA 。
问:\prec 是否是字符串集合上的严格全序?
::::success[答案]
是。
反自反性:A\prec A\iff A^2<A^2 ,显然不成立;
非对称性:A\prec B\iff AB<BA ,B\prec A\iff BA<AB ,显然 AB<BA 与 BA<AB 不能同时成立;
连接性:A\prec B\iff AB<BA ,B\prec A\iff BA<AB ,由于字符串不同,因此 AB<BA 与 BA<AB 必有一个成立;
传递性:A\prec B\land B\prec C\iff AB<BA\land BC<CB\iff A^{\infty}<B^{\infty}\land B^{\infty}<C^{\infty}\implies A^{\infty}<C^{\infty}\iff AC<CA\iff A\prec C 。
传递性证明中,涉及到了无穷次幂比较字典序的问题,欢迎查看作者的另一篇文章。
:::::
:::::info[练习 2]{open}
设 S 为二元组 (a,b) 构成的集合,定义二元关系 \prec 为:(a_i,b_i)\prec(a_j,b_j)\iff\min(a_i,b_j)<\min(a_j,b_i) 。
问:\prec 是否是 S 上的严格全序?
::::success[答案]
不是。
事实上,\prec 满足反自反性、非对称性、传递性。传递性可以通过分类讨论 \min 取到的位置来证明,比较繁琐,这里不展开。
但是 \prec 不满足连接性。有反例 A=(2,2),B=(3,3) ,显然 A\prec B 和 B\prec A 都不成立。因此 \prec 只是一个严格偏序,而并不是一个严格全序。
这个二元关系曾经是 P2123 皇后游戏题解区的经典错解。上述讨论说明,按照这个 \prec 进行 exchange argument 是错的。
:::::
在 C++ 中,找到这样一个严格全序 \prec ,然后使用 std::sort 对序列进行排序即可。若 \prec 不满足严格全序,则属于未定义行为。
邻项交换是调整法的一种。对于顺序相关的最优化问题,我们尝试调整将其相邻项交换,观察是否更优,从而得到最优解的性质。得到这个性质以后,可以直接贪心或者配合 DP 求解。一种常用的分析角度是考虑 n=2 的特殊情况。
树上邻项交换
用来解决与拓扑序有关的最优化问题。
维护树上的若干连通块,初始时为单点。每轮中取出权值最小的连通块与父亲所在的块合并,并将贡献计入答案。
可以使用堆 / set 来模拟这一过程,并按照某种二元关系 \prec 排序。\prec 需要满足严格全序。
这个 trick 称为树上 exchange argument,关键在于选取正确的 \prec 。
反悔贪心
贪心选择的是局部最优解。如果策略不优,在某个时刻会发现全局最优不能由此策略得到,或者继续按照此策略执行会违反题目限制,需要调整。
反悔贪心中,调整的方法有两种:
整体调整:将平凡贪心直接做完,然后再整体调整 O(n) 轮。
动态调整:用一个数据结构维护之前的决策,通过 O(1) 轮调整使得局部最优变成全局最优。
反悔贪心的题目常常可以被建模为费用流,然后使用模拟费用流解决。从费用流的角度来看,每一次反悔就相当于在残量网络中建立反向边。
模拟费用流
模拟费用流主要有关键点、单 / 双向链两种类型。关键点型的模拟费用流一般也可以用反悔贪心理解。
考察费用流的 SSP 算法,也就是将 EK 或 Dinic 中寻找增广路的算法,替换为用于寻找费用最小路径的最短路算法。
在模拟费用流中,我们通常考察的是 EK 算法。下面复述一遍 EK 求解最小费用最大流的算法流程:
在残量网络中,找到 S\to T 的最小费用路径。
找到这条路径上剩余容量的最小值,作为流量瓶颈 \Delta f 。
在路径上,将正向边的容量减去 \Delta f ,反向边的容量加上 \Delta f 。
在网络图的形态比较特殊时,我们可以用数据结构维护这些过程,这也就是模拟费用流的观点。
上面给出了最小费用最大流的算法。我们再给出如下扩展:
最小费用任意流:EK 增广最短路,直到单次费用为正。
增量意义下,我们只要考虑 S\to T 的负权路径和负环的影响。
负费用最大流:EK 增广最短路,直到总费用为负。
关于费用流的一些经典结论:
费用关于流量有凸性。
增广路不会重复经过某个点。
修改或删去边 (u,v) ,退流 T\to v\to u\to S 。
在 SSP 中,如果初始图无负环,则任意时刻残量网络无负环。
Hall 定理
Hall 定理 对于二分图 G=(X,Y,E) ,对于 W\subseteq X ,记 N(W) 为 W 中所有节点的邻居集合的并集,则 G 存在完美匹配,当且仅当 \forall W\subseteq X,|W|\le|N(W)| 。
在实际应用中,常常要进行图论建模,并且只考察 |N(S)|-S 取得 \min 的所有 S 。这些 S 往往具有很好的结构,如前缀 / 区间等,或对结构进行猜测。
下面给出 Hall 定理的一些推论:
推论 1:二分图 G=(X,Y,E) 的最大匹配数 |M|=|X|-\max\limits_{W\subseteq X}(|W|-|N(W)|) 。
推论 2(正则二分图):若 \forall u\in X,d_u=k 且 \forall v\in Y,d_v=k ,其中 d_u 为节点 u 的度数,则称二分图 G=(X,Y,E) 为 k 正则二分图。任何正则二分图必然存在完美匹配。
扩展:若 \forall u\in X,d_u=k 且 \forall v\in Y,d_v\le k ,则必然存在覆盖 X 的完美匹配。
推论 3(带权 Hall 定理):若左部点 u 需要匹配 a_u 个右部点,右部点 v 需要匹配 b_v 个左部点,且允许匹配重复,则 G 存在完美匹配,当且仅当 \forall W\subseteq X,\sum\limits_{x\in W}a_x\le\sum\limits_{y\in N(W)}b_y 。
应用 1:二分图 G=(X,Y,E) 存在 k 重完美匹配,当且仅当 \forall W\subseteq X,k\times|W|\le|N(W)| 。
应用 2:二分图 G=(X,Y,E) 中至多允许 k 个点失配,存在合法匹配当且仅当 \forall W\subseteq X,|W|-k\le|N(W)| 。
另一个与二分图有关的重要结论:
Kőnig 定理 二分图最大匹配数等于最小点覆盖数。
从线性规划的观点看,这些定理的本质都是对偶原理。
正则二分图
给定 k 正则二分图 G=(X,Y,E) 。
问题 1 找到 G 的一组完美匹配。
KM 可以做到 O(n^3) ,Dinic 可以做到 O(n^{2.5}) ,但都没有利用正则二分图的性质。
若 k=2^d ,则有简单的归纳构造:求 G 的欧拉回路并定向,将所有边按方向分为两组,问题被规约到两个规模为 2^{d-1} 的子问题,递归解决即可。复杂度 O(nk) 。
对一般的 k ,我们有基于随机游走的 GKK 算法:
:::::info[GKK 算法]{open}
维护局部匹配 M ,不断寻找增广路来扩大匹配,直到 |M|=n 。
对残量图 G=(X,Y,E) ,将未匹配边定向为 u\to v ,匹配边定向为 v\to u 。X 中未匹配点作为起点,Y 中未匹配点作为终点。
随机选取一个起点 u ,沿有向边随机游走,即每次在当前点的所有出边中,均匀随机地选取一条并走向它。
在游走过程中,记录走过的路径。
如果游走到之前走过的节点,则立刻执行缩环 操作。具体地,将有向环收缩为一个点,并从该点出发继续游走。
当游走到达终点时,将缩环展开提取出一条增广路,沿增广路翻转边的匹配状态。
:::::
可以证明,GKK 算法的期望复杂度是 O(nk+n\log n) 的。模板题的 submission。
问题 2 将 G 分解为 k 组不交完美匹配,求一组方案。
直接进行归纳构造,每轮用 GKK 求出完美匹配,删去后递归求解,重复 k 轮,复杂度 O(nk^2+nk\log n) 。
还有更优秀的归纳构造手法。对 k 分奇偶讨论:
若 k 是偶数,求出 G 的欧拉回路,将问题变为两个规模为 \frac{k}{2} 的子问题。
若 k 是奇数,用 GKK 求出完美匹配并删去,规约到规模为 k-1 的子问题。
这样分治的复杂度是 O(nk\log k+n\log n\log k) 的。代码可以参考 submission。
Dilworth 定理
称 \preceq 是 S 上的偏序 ,需同时满足以下三个性质:
自反性:\forall x\in S,x\preceq x 。
非对称性:\forall x,y\in S,x\prec y\implies\lnot(y\preceq x) 。
传递性:\forall x,y,z\in S,x\preceq y,y\preceq z\implies x\preceq z 。
请读者注意区分偏序 & 全序。
对于有限偏序集,我们可以用 Hasse 图来表示二元关系。对 x,y \in S ,若 x \preceq y \land \nexists z, x \preceq z \preceq y 则连边 x \to y 。由非对称性可知 Hasse 图一定是 DAG。
对有限偏序集 S 和其上的偏序 \preceq ,对 T \subseteq S :
若 T 中元素两两可比,则称 T 是偏序集上的链 。
若 T 中元素两两不可比,则称 T 是偏序集上的反链 。
Dilworth 定理 有限偏序集最小链覆盖等于最长反链。
Mirsky 定理 有限偏序集最长链等于最小反链覆盖。
上面的说法过于抽象,下面举若干 Dilworth 定理的具体应用:
:::::info[练习 1]{open}
给定序列 a_i ,你需要将 a_i 不重不漏地划分若干不降子序列,最小化划分数。
::::success[答案]
问题等价于求 a_i 的最长上升子序列。
对元素 x_i ,定义偏序关系 x_i \preceq x_j \iff i<j\land a_i \ge a_j 。则原问题是偏序集最小链覆盖。
若元素 x_i,x_j 不可比,则 i<j \land a_i<a_j 。用 Dilworth 定理对偶为最长反链,容易发现这是 LIS 问题。
::::
:::::
:::::info[练习 2(P11231)]{open}
现有 n 个玩家,第 i 个玩家的战斗力为 a_i 。一次操作选择两个存活玩家 i,j ,满足 a_i>a_j ,令玩家 i 攻击玩家 j 并击杀。每个玩家至多攻击一次。最小化最终存活的玩家数并输出。
::::success[答案]
问题等价于求 a_i 中众数的出现次数。
对元素 x_i ,定义偏序关系 x_i \preceq x_j \iff a_i>a_j \lor i=j 。原问题是最小链覆盖,因为存活的玩家相当于链头。
由 Dilworth 定理对偶为最长反链。元素 x_i,x_j 不可比即 a_i=a_j ,故反链的形态为若干相等数字,最长反链就是众数。
::::
:::::
下面列出 DAG 最小链覆盖问题常见的处理手法:
用 Dilworth 定理对偶成最长反链分析。
拆点转二分图匹配后,用网络流解决,或用 Hall 定理转化。
k 优解
形式化地,将一般的 k 优解问题定义为:
设最优化问题的解空间为 \Omega ,代价函数 f:\Omega\to\mathbb{R} 。给定 k ,构造长为 k 的解序列 x_1,x_2,\cdots,x_k\in\mathbb{\Omega} ,满足如下条件:
互异性:\forall1\le i<j\le k,x_i\ne x_j 。
有序性:f(x_1)\le f(x_2)\le\cdots\le f(x_k) 。
最优性:\forall x\in\Omega\setminus\{x_1,x_2,\cdots,x_k\},f(x_k)\le f(x) 。
对于\Omega 和 k 满足特定要求的情形,我们有专门的堆优化搜索算法,称作 Shopping Plans Trick,由使用该算法的经典题目 P6646 得名。
考察如下刻画:建立有向图 G=(\Omega,E) ,满足 \forall(x,y)\in E,f(x)<f(y) ,并且 \forall x\in\Omega ,x_1\to x 可达,找出 x_1 后,离 x_1 前 k 近的点列即为所求的解序列。
此处不妨设 f 值互不相同,对 f 值相同的情形,将节点编号作为第二关键字比较即可。这里的目的是得到 \Omega 上的严格全序。
注意到 G 必为一张 DAG。考虑如下搜索算法:
:::::info[算法 1]{open}
维护小根堆 Q 和集合 S ,初始时令 x_1 入堆。
重复以下流程,直到解序列的长度达到 k 。
弹出 Q 的堆顶元素 x 。若 \mathbf{x \notin S} 则 将 x 加入解序列。
令 S\gets S\cup\{x\} 。
枚举 (x,y)\in E ,令 y 加入 Q 。
:::::
算法 1 等价于在 DAG 上进行 Dijkstra。
注意到算法 1 并不需要显式建出 G 。观察算法 1 的复杂度瓶颈:
枚举 (x,y)\in E 的所有的 y 。
判定 x\in S 是否成立,修改 S\gets S\cup\{x\} 。
一般地,认为可以在 O(1) 内解决问题一。若问题二存在 O(\log|S|) 的高效算法,算法 1 的复杂度即为 O(k\log k) 。
更一般地,认定问题二不存在高效算法。注意到 G 的形态是以 x_1 为根的外向树时,有如下算法成立:
:::::info[算法 2]{open}
维护小根堆 Q ,初始时令 x_1 入堆。
重复以下流程 k 轮。
弹出 Q 的堆顶元素 x 。直接 将 x 加入解序列。
枚举 (x,y)\in E ,令 y 加入 Q 。
:::::
这是 Shopping Plans Trick 的一般性算法。易知复杂度 O(k\log k) 。
我们考察算法 2 的本质。形式化地,我们对全体 x\in\Omega 构造了转移集合 \text{trans}(x) ,且转移满足下列性质:
最优性 :\forall x\in\Omega,\forall y\in\text{trans}(x),f(y)>f(x) 。
覆盖性 :\forall x\in\Omega ,x_1\to x 可达。
唯一性 :\forall x,y\in\Omega\land x\ne y,\text{trans}(x)\cap\text{trans}(y)=\varnothing 。
两种算法都需要满足最优性和覆盖性,算法 2 需要满足唯一性。
进一步,对覆盖性进行扩展:
广义覆盖性 :\exists x_1',x_2',\cdots,x_m'\in\Omega ,\forall x\in\Omega,\exists1\le i\le m ,x_i'\to x 可达。
若 \text{trans} 仍满足最优性和唯一性,有如下算法成立:
:::::info[算法 3]{open}
维护小根堆 Q ,初始时令 x_1',x_2',\cdots,x_m' 入堆。
重复以下流程 k 轮。
弹出 Q 的堆顶元素 x 。直接 将 x 加入解序列。
枚举 (x,y)\in E ,令 y 加入 Q 。
:::::
若 m=O(k) 则复杂度 O(k\log k) 。从图论视角来看,G 的形态是以 x_1',x_2',\cdots,x_m' 为根的外向森林。
实际上,对 k 优解使用 Shopping Plans Trick 后往往转化成构造题。我们需要对每个可行解 x\in\Omega 构造状态 S(x) ,并构造 S 的转移 \text{trans}(S) 满足特定性质,然后使用对应算法解决。
::::::info[练习]{open}
给定两个长为 n 的单调不降序列 a_i,b_i 。设 \Omega=\{a_i+b_j\mid i,j\in[1,n]\} ,求 \Omega 的前 n 小解。
::::success[答案 1]
对可行解 a_i+b_j 构造状态 S=(i,j) ,转移到 (i+1,j) 和 (i,j+1) 。
此时 S(x_1)=(1,1) ,易证最优性和覆盖性成立。
由于上述构造不满足唯一性,使用算法 1 解决。使用 std::set 判重,复杂度 O(n\log n) 。
::::
::::success[答案 2]
对可行解 a_i+b_j 构造状态 S=(i,j) ,若 j\ne1 则仅转移到 (i,j+1) ,否则转移到 (i+1,j) 和 (i,j+1) 。
显见最优性成立,下证覆盖性和唯一性成立:
覆盖性:\forall(i,j)\in\Omega ,构造 (1,1)\to(i,j) 的路径为,先使用 i-1 次 (i,j)\to(i+1,j) 的规则到达 (i,1) ,再使用 j-1 次 (i,j)\to(i,j+1) 的规则到达 (i,j) 。
唯一性:只要证转移图是以 (1,1) 为根的外向树,即 \forall(i,j)\in\Omega\land(i,j)\ne(1,1) ,其存在唯一前驱。
若 j=1\land i>1 ,仅有 (i-1,1)\to(i,1) 。
若 j>1 ,由于 j\ne1 不存在 (i-1,j) 的转移,从而仅有 (i,j-1)\to(i,j) 。
使用算法 2 解决,复杂度 O(n\log n) 。
::::
::::success[答案 3]
对可行解 a_i+b_j 构造状态 S=(i,j) ,仅转移到 (i,j+1) 。
考察转移图的形态,可以发现转移图由 n 条链组成。记 x_i'=(i,1) ,则 x_1'\sim x_n' 满足广义覆盖性。易证最优性和唯一性成立,使用算法 3 解决。复杂度 O(n\log n) 。
::::
::::::
凸优化
凸优化更多说的是 DP 优化。不过有些反悔贪心也是基于凸性。
要研究函数的凸性,首先需要给一个定义。
从连续角度来说,函数 f 是凸函数当且仅当 f' 单调,也即二阶导 f'' 恒大于 0 或恒小于 0 。但是 OI 中研究的一般是离散函数,也就是一个序列。对于离散函数 f ,定义 f 是下凸函数 ,当且仅当
\forall x,f(x)-f(x-1)\le f(x+1)-f(x)
等价表述是,序列 f 的差分单调不降。
类似地,如果序列的差分单调不升,我们就称这是一个上凸函数 。下文中,可能并不会区分函数的上凸 / 下凸,因为我们往往只关心函数是否具有凸性。
实际上,我们往往通过打表等方法,猜测一个函数具有凸性。严谨的证明可以考虑规约 LP 问题,以下列出若干常见的 LP 问题:
最大流对偶最小割。
最短路对偶差分约束模型。
最大匹配对偶最小点覆盖。
最小链覆盖对偶最长反链。
最小 / 大生成树。
需要注意的是,寻找凸函数 f 的最值时,我们可以直接对导数二分,不需要三分等算法。
凸包
平面上有 n 个点 (x_i,y_i) ,求这些点的凸包。
常用的做法是 Andrew 算法。先按 x_i 排序,维护一个单调栈,记最后两点为 A,B ,插入点 C 时,只要判断 A,B,C 三点的凸性。这个可以用叉积判定,合法的充要条件是 \vec{AB}\times\vec{BC}\ge0 ,如果不满足就 pop 掉。
这样只能求出下凸壳,需要反过来再跑一遍。复杂度 O(n\log n) ,瓶颈在排序。
我们通常只需求出下凸壳,也就是维护一个下凸函数,这时 Andrew 只跑一遍即可。
斜率优化
考虑 DP 转移
b_i=\min_{j<i}(y_j-k_i x_j)
其中 b_i,k_i 是仅关于 i 的函数,x_j,y_j 是仅关于 j 的函数。
假设 i 的决策点为 j ,由 b_i=y_j-k_ix_j 移项得 y_j=k_ix_j+b_i 。
转二维平面分析,相当于有若干点对 (x_j,y_j) ,用一条斜率为 k_i 的直线切每个点,最小化截距。
可以发现只有下凸壳上的点可能成为决策点,用数据结构维护下凸壳即可。
如果 k_i 关于 i 单调增,则可以用单调队列维护凸包,复杂度 O(n) 。
对于一般情形,我们可以在凸包上二分导数求决策点。可以使用平衡树 / 李超树在线维护,或者 CDQ 分治整体离线维护。这里的平衡树可能只是一个 std::set。
决策单调性
考虑 DP 转移
f_i=\min_{j<i}w(j,i)
记 i 的决策点为 \text{opt}(i) 。若 \forall i<j,\text{opt}(i)\le\text{opt}(j) ,则称 DP 具有决策单调性 。
四边形不等式给出了决策单调性的充分条件。具体地,若函数 w 满足
\forall a\le b\le c\le d,w(a,c)+w(b,d)\le w(a,d)+w(b,c)
则 w 满足四边形不等式,进而 DP 具有决策单调性。
感性理解一下,四边形不等式实际上说明左图情形是正确的,右图情形是错误的,自然就满足左图所示的决策单调性。
四边形不等式也表明了贪心中的常见性质:相交优于包含 。这也使得有些题目可以直接使用贪心配对解决。
四边形不等式与凸函数的关系参见 OI Wiki。
决策单调性优化 DP,广为人知的做法是决策单调性分治和二分队列。比较通用的算法是 LARSCH 分治,都可以做到 O(n\log n) 。
:::::info[简化 LARSCH]{open}
设分治区间 [l,r] 。假设 [1,l) 的决策处理完毕且贡献到 f_r 。
取区间中点 m ,提取 [l-1,r] 的当前 决策更新 f_m 。
递归 [l,m] 。
提取 [l,m] 的正确 决策更新 f_r 。
递归 (m,r] 。
:::::
WQS 二分
考虑如下问题:现有若干物品,你需要从中选出恰好 k 个,求最小代价。设 f(k) 为问题答案,满足 f 下凸。
引入系数 a 并构造函数 g(x)=f(x)-ax ,则 g 同样具有凸性。我们希望 g 的谷点恰好是 k 。
枚举系数 a 并设法求解出 g 的谷点 k_0 。分析性质:
\begin{aligned}
g(k_0)&<g(k)\\
f(k_0)-ak_0 &<f(k)-ak\\
a&>\dfrac{f(k_0)-f(k)}{k_0-k}
\end{aligned}
若 x_0<x ,同理可得 a<\dfrac{f(k)-f(k_0)}{k-k_0} 。
注意到不等式的右侧正是原函数 f 在 k 和 k_0 之间的割线斜率。因为 f 下凸,k_0 关于 a 单调递增。于是可以转为二分 a 。
最终我们会得到恰当的 a ,使得 g 的谷点就是 k ,移项将 f(k)=g(k)+ak 作为答案即可。
这个算法就叫做 WQS 二分 / Alien's Trick。
还可以从几何角度来理解。考虑将 f 画到二维平面上,用一条斜率为 a 的直线去切下凸壳,最终可以求得 x=k 处的切线斜率。
问题的核心其实是求解 k_0 。注意到 g 的实际意义是,每选择一个物品就会有 a 的额外代价 。此时没有恰好的限制,转化成了另一个相对容易的问题。
Slope Trick
我们研究一些凸函数的变换。
:::::info[非负线性组合]{open}
考虑凸函数 f,g 与非负实数 x,y\ge0 ,可以证明 xf+yg 也是凸函数。进一步,这些函数的差分满足
\Delta(xf+yg)=x\Delta f+y\Delta g
这个性质给出了维护 xf+yg 斜率段的方法。
:::::
:::::info[Minkowski 和]{open}
考虑凸函数 f,g 的 (\min,+) 卷积
h(k)=\min_{i+j=k}(f(i)+g(j))
可以证明 h 具有凸性。
更进一步,h 的差分数组是 f,g 的差分数组归并以后的结果。因此,两个凸函数的 (\min,+) 卷积可以 O(n) 求得。这就是凸优化语境中的 Minkowski 和 。
下面贺一张 OI-Wiki 上的图,帮助读者理解这个结论的几何意义:
:::::
:::::info[(\min,+) 卷积]{open}
考虑凸函数 f 与普通函数 g 的 (\min,+) 卷积
h(k)=\min_{i+j=k}(f(i)+g(j))
枚举 k ,则 i 满足决策单调性,分治即可做到 O(n\log n) 。
:::::
Slope Trick 其实就是根据上述性质,维护凸函数的一类技巧。通常有两组维护方式,一种是维护拐点 ,即斜率的突变点,另一种则是直接维护斜率段 ,即差分数组。
上面的说法比较抽象,读者可能需要借助例题来理解。
构造技巧
写一点基本的做题角度:
根据题目的操作,构造一些更简单的操作;
构造较小的情况后,将一般情况拆分为若干小情况;
归纳构造 / 增量法;
找到答案的上界 / 下界,并断言可以取到,尝试构造;
先给出较为优秀的构造,然后调整法;
构造出平凡状态的解法后,将初始态设法变为平凡态;
设计用于判定的 DP,记录决策点从初始态反推;
考虑 checker 的写法或判定方式;
随机化构造,随机化调整;
忽略部分限制,或人为添加一些限制;
抽屉原理 / 绝对众数等性质;
进制拆分 / 斐波那契倍增;
图论建模,转欧拉回路 / 2-SAT 等;
等等。
ABC137D Summer Vacation
给出 n 个任务 (a_i,b_i) ,每个时刻可以选择一个没有被选过的任务,该任务在 a_i 时间后完成,得分为 b_i 。
给出 m ,求 m 时刻可以获得的最大得分。
:::::success[题解]
我们倒序贪心。枚举当前的截止期限 d ,并且用一个大根堆维护当前可选的任务。则在倒数第 d 个时刻,选择得分最大的任务完成。
严谨的正确性证明,可以考虑任意最优解都能通过对换变成贪心解,讨论一下某种任务的完成情况即可。
复杂度 O(m\log n) 。
启示:正向贪心不可行时,考虑是否是贪心顺序的问题,尝试反向贪心。
:::::info[代码]
const int N = 1e5 + 5;
int n, m;
vector<int> x[N];
void _main() {
cin >> n >> m;
for (int i = 1, a, b; i <= n; i++) {
cin >> a >> b;
x[a].emplace_back(b);
}
priority_queue<int> q;
i64 res = 0;
for (int d = 1; d <= m; d++) {
for (int i : x[d]) q.emplace(i);
if (!q.empty()) res += q.top(), q.pop();
} cout << res;
}
:::::
B3930 [GESP202312 五级] 烹饪问题
给出一个长为 n 的序列 a_i ,求出 \max\limits_{1\le i<j\le n}(a_i\text{ and }a_j) 。\text{and} 为二进制按位与。
:::::success[题解]
注意到只有前 \log V 大的数是有用的。
从高位向低位考虑,当且仅当仅有 1 个 1 时前 \log V 大的数会被改变一次。这个调整最多发生 \log V 次。
因此取出前 \log V 大数后直接暴力枚举即可。复杂度 O(n\log n+\log^2 V) 。
:::::info[代码]
const int N = 1e6 + 5;
int n, a[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1, greater<int>());
int res = 1;
for (int i = 1; i <= min(n, 30); i++) {
for (int j = 1; j <= min(n, 30); j++) {
if (i != j) res = max(res, a[i] & a[j]);
}
} cout << res;
}
:::::
P13219 [GCJ 2015 #1B] Noisy Neighbors
你需要在 n\times m 的网格上选择 k 个格子。定义一种选择方案的代价为:被至少两个选的格子共用的边界数目。最小化代价并输出。
多测,T\le10^3 ,n m\le10^4 ,10 秒,1024 MB。
:::::success[题解]
考虑黑白染色。对于格子 (x,y) ,若 x+y 为偶数则染成黑色,否则染成白色。同色格子之间不会产生代价。当 k 不超过黑格数目 \lceil\frac{n\times m}{2}\rceil 时,答案即为 0 。
否则,考虑先选所有黑格,此时每个白格产生的额外代价可以确定,直接贪心选出前 k-\lceil\frac{n\times m}{2}\rceil 小即可。同理可以算出先选白格再选黑格的代价,二者取 \min 作为答案。
应该可以推一些柿子 O(1) 计算,但这个题直接模拟就能通过,单组数据复杂度 O(nm\log nm) 。
:::::info[代码]
int n, m, k;
void _main() {
cin >> n >> m >> k;
cout << "Case #" << kase << ": ";
if (k <= (n * m + 1) / 2) return cout << 0 << '\n', void();
int x = (n * m + 1) / 2, y = n * m / 2;
vector<int> a, b;
for (int x = 1; x <= n; x++) for (int y = 1; y <= m; y++) {
int v = (x >= 2) + (x <= n - 1) + (y >= 2) + (y <= m - 1);
if ((x + y) & 1) a.emplace_back(v);
else b.emplace_back(v);
}
sort(a.begin(), a.end()), sort(b.begin(), b.end());
cout << min(accumulate(a.begin(), a.begin() + k - x, 0),
accumulate(b.begin(), b.begin() + k - y, 0)) << '\n';
}
:::::
QOJ6544 Cooperation Game
给出一个长为 n 的序列 a_i 。一次操作选择下标 i,j ,满足 i<j\land a_i=a_j ,然后删去 a_i,a_j 并获得 j-i 的得分,直到无法操作。最大化得分并输出。
多测,T\le48 ,n\le3\times10^5 ,\sum n\le7\times10^6 ,1\le a_i\le n ,3 秒,1024 MB。
:::::success[题解]
考虑求出每个值出现的位置,设为 i_1,i_2,\cdots,i_k ,则 (i_1,i_k),(i_2,i_{k-1}),\cdots 这样首尾配对为最优。这样处理后,我们获得了 O(n) 个区间。
不妨将操作描述为:每次选择区间 [l,r] ,获得 r-l-f(l,r) 的得分,然后将端点 l,r 标记。这里的 f(l,r) 即 [l,r] 中被标记的数的数目。
用简单的 exchange argument 确定操作顺序。对于 l_1,r_1,l_2,r_2 ,若区间之间存在包含关系 [l_1,r_1]\subseteq[l_2,r_2] ,则必须先进行 [l_2,r_2] 。否则,总得分是相同的,任意顺序执行即可。
找到任意一种严格偏序,如按区间长度降序 / 左端点升序 / 右端点降序都是合法的。排序后模拟,用线段树 / 树状数组维护 f ,复杂度 O(n\log n) 。
:::::info[代码]
const int N = 3e5 + 5;
int n, a[N];
list<int> pos[N];
using node = pair<int, int>;
vector<node> vec;
#define ls (rt << 1)
#define rs (rt << 1 | 1)
int sum[N << 2];
void pushup(int rt) {sum[rt] = sum[ls] + sum[rs];}
void build(int l = 1, int r = n, int rt = 1) {
sum[rt] = 0;
if (l == r) return;
int mid = (l + r) >> 1;
build(l, mid, ls), build(mid + 1, r, rs);
}
void update(int x, int c, int l = 1, int r = n, int rt = 1) {
if (l == r) return sum[rt] = c, void();
int mid = (l + r) >> 1;
if (x <= mid) update(x, c, l, mid, ls);
else update(x, c, mid + 1, r, rs);
pushup(rt);
}
int ask(int tl, int tr, int l = 1, int r = n, int rt = 1) {
if (tl <= l && r <= tr) return sum[rt];
int mid = (l + r) >> 1, res = 0;
if (tl <= mid) res += ask(tl, tr, l, mid, ls);
if (tr > mid) res += ask(tl, tr, mid + 1, r, rs);
return res;
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) pos[i].clear();
vec.clear(), build();
for (int i = 1; i <= n; i++) cin >> a[i], pos[a[i]].emplace_back(i);
for (int i = 1; i <= n; i++) {
while (pos[i].size() > 1) {
int l = pos[i].front(), r = pos[i].back();
pos[i].pop_front(), pos[i].pop_back();
vec.emplace_back(l, r);
}
}
sort(vec.begin(), vec.end(), [](const node& a, const node& b) -> bool {
return a.second - a.first > b.second - b.first;
});
i64 res = 0;
for (auto [l, r] : vec) {
res += r - l - ask(l, r);
update(l, 1), update(r, 1);
}
cout << res << '\n';
}
:::::
P8266 [USACO22OPEN] Photoshoot B
给出一个长为 n 的串,字符集为 \{\tt{H},\tt{G}\} 。一次操作可以对偶数长度的前缀翻转。
在偶数下标上的 \tt{G} 的数目尽可能多的前提下,最小化操作次数并输出。
:::::success[题解]
01 串邻位 trick。我们将相邻的字符配对,对偶数长的前缀翻转,就转化为每个组合内部翻转。对每个组合讨论:
这样转化以后,我们得到一个长为 m 的 01 串。问题转化为:每次翻转 01 串的一个前缀,使得 01 串全为 1 的最小操作次数。
倒着做每一次操作,每次遇到 0,就做一次前缀翻转。可以打一个标记来表示当前位的翻转次数,O(1) 得到当前数字。最后特判是否需要整体翻转。
:::::info[代码]
const int N = 2e5 + 5;
int n, m, a[N];
char s[N];
void _main() {
cin >> n >> (s + 1);
for (int i = 1; i <= n; i += 2) {
if (s[i] == 'H' && s[i + 1] == 'G') a[++m] = 1;
if (s[i] == 'G' && s[i + 1] == 'H') a[++m] = 0;
}
int cnt = 0, x = 0, st = 0;
for (int i = m; i >= 1; i--) {
if ((a[i] ^ st) == 0) x = 1;
else if (x) st ^= 1, cnt++;
}
cout << cnt + (a[1] ^ st ^ 1);
}
:::::
TC8721 Removing Digits
给出长为 n 的字符串 S 和长为 m 的字符串 T 。对于 T 中的每一个字符,你需要在 S 中找到一个对应字符并删除。最大化最终的 S 的字典序,并输出最终的 S 。
:::::success[题解]
典型的字典序贪心。考虑从左到右枚举答案的每一位 k ,再从高到低枚举这一位上的字符 d ,判定可行性。
现在刻画可行的充要条件。开一个桶记录每个字符的当前频次,和答案中出现的频次。则不可行当且仅当选走 d 后,后面的字符无法满足条件,可以对每个后缀开一个桶来判断。
如果 d 还需要保留,我们找到其在 S 中上一次选择的位置之后的第一个出现位置,然后枚举每个字符判断。
复杂度 O(n^2|\Sigma|^2) ,可以对后缀处理一个位置数组优化到 O(n|\Sigma|^2) 。
:::::
:::::info[代码]
const int N = 105;
string s, t;
int cnt[10], suf[N][10];
void _main() {
cin >> s >> t;
for (char c : s) cnt[c ^ 48]++;
for (char c : t) cnt[c ^ 48]--;
int n = s.size(), m = t.size();
for (int i = n - 1; i >= 1; i--) {
copy(suf[i + 1], suf[i + 1] + 10, suf[i]);
suf[i][s[i] ^ 48]++;
}
int last = -1;
for (int k = 0; k < n - m; k++) {
for (int d = 9; d >= 1; d--) {
if (cnt[d] == 0) continue;
int pos = s.find(d + '0', last + 1);
if (pos == string::npos) continue;
bool ok = true;
for (int i = 1; i <= 9; i++) {
if (suf[pos + 1][i] < cnt[i] - (i == d)) {
ok = false;
break;
}
}
if (ok) {
cout << d, cnt[d]--, last = pos;
break;
}
}
}
}
:::::
P10051 [CCO 2022] Rainy Markets
数轴上有 n 个点,点有容量 a_i ,两点之间的边有容量 b_i 。每个点上有 c_i 个人。
每个人需要选择移动到左侧边、原点、或右侧边,不得超过容量限制。每种方案的代价为留在原点的人数之和。你需要最小化代价,给出一种方案或报告无解。
:::::success[题解]
设 x_i,y_i,z_i 为去左边、去右边、留在原点的人数。
进行三次扫描:
从右向左确定每个位置 y_i 的上限 f_i 。由于 i,i+1 共享一条边,这里的 y_i 受到右侧约束。可以通过递推算出。
从左向右检查可行性。考虑左侧节点输送了一些人,当前节点的一些人被迫向右走,如果向右的人数超过了 f_i ,则无解。贪心地,我们希望向右人数最小。
从左向右开始分配。此时假定左侧已经安排完成,优先将人向左分配填 x_i 。由于我们希望最小化 z_i ,接下来确定 y_i 并尽量达到 f_i 的上界。
正确性比较显然,如果当前不用完代价也不会消失,而用完并不会改变后续代价。
:::::info[代码]
#define int long long
const int N = 1e6 + 5;
int n, a[N], b[N], c[N], d[N], f[N], x[N], y[N], z[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) cin >> b[i];
for (int i = 1; i < n; i++) cin >> c[i], d[i] = max(0LL, b[i] - c[i]);
f[n - 1] = min(a[n], b[n - 1]);
for (int i = n - 2; i >= 1; i--) {
f[i] = min(b[i], a[i + 1] - max(0LL, d[i + 1] - f[i + 1]));
}
int cur = 0;
for (int i = 1; i < n; i++) {
cur = max(0LL, d[i] + cur - a[i]);
if (cur > f[i]) return cout << "NO", void();
}
for (int i = 1; i < n; i++) {
x[i] = min(b[i], max(0LL, a[i] - y[i - 1]));
y[i] = min(b[i] - x[i], f[i]);
z[i] = b[i] - x[i] - y[i];
}
cout << "YES\n" << accumulate(z + 1, z + n, 0LL) << '\n';
for (int i = 1; i < n; i++) cout << x[i] << ' ' << z[i] << ' ' << y[i] << '\n';
}
:::::
ABC312F Cans and Openers
现有 n 个物品,物品有三种类型:
你需要恰好选择 m 个物品,最大化价值并输出。
:::::success[题解]
求出 A,B,C 集合后,考虑枚举选择 i 个 A 类物品,则一定选择价值最大的 i 个。故将 A 降序排序并做前缀和。
考虑 B,C 选择 m-i 个的最大价值。记 B 类物品选择 x 个,此时 C 类物品应当选择 m-i-x 个用于解锁。
贪心地,将 C 降序排序并做前缀和,容易判定答案 x 是否合法。于是二分 x ,此时 B 类的价值也由最大的 x 个决定。
排序 + 枚举套二分,复杂度均为 O(n\log n) 。
:::::info[代码]
#define int long long
const int N = 2e5 + 5;
int n, m;
vector<int> a, b, c;
void _main() {
cin >> n >> m;
for (int i = 1, t, x; i <= n; i++) {
cin >> t >> x;
if (t == 0) a.emplace_back(x);
else if (t == 1) b.emplace_back(x);
else c.emplace_back(x);
}
sort(a.begin(), a.end(), greater<int>());
sort(b.begin(), b.end(), greater<int>());
sort(c.begin(), c.end(), greater<int>());
int s1 = a.size(), s2 = b.size(), s3 = c.size();
a.insert(a.begin(), 0), b.insert(b.begin(), 0), c.insert(c.begin(), 0);
for (int i = 1; i <= s1; i++) a[i] += a[i - 1];
for (int i = 1; i <= s2; i++) b[i] += b[i - 1];
for (int i = 1; i <= s3; i++) c[i] += c[i - 1];
int res = 0;
for (int i = 0; i <= min(m, s1); i++) {
int l = 0, r = min(m - i, s2), p = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (c[min(s3, m - i - mid)] >= mid) p = mid, l = mid + 1;
else r = mid - 1;
}
chkmax(res, a[i] + b[p]);
}
cout << res;
}
:::::
P14954 520
给出一个长度为 n 的字符串 s_i ,字符集为 \{\tt{5},\tt{2},\tt{0}\} 。你可以插入 a 个 \tt{5} ,b 个 \tt{2} ,c 个 \tt{0} ,最大化最终字符串中 \tt{520} 子串的数目并输出。
多测,T\le10^3 ,n\le10^3 ,a,b,c\le10^9 ,1 秒,512 MB。
:::::success[题解]
首先先找出初始的 \tt{520} 子串,这部分我们不动,算入答案后删去。
接下来统计 \tt{52},\tt{50},\tt{20} 子串的数目,并且将其删去。最后统计孤立的单字符数目。
接下来,我们消耗单字符来匹配双字符的子串。这里需要贪心地进行匹配:找出当前最稀缺的单字符,然后尽量消耗其他两种字符。这一部分可以直接模拟,因为字符数目是 O(n) 的。
模拟完成后,将剩下的字符原地配对即可,总复杂度 O(Tn) 。
:::::
:::::info[代码]
#define int long long
const int N = 1005;
int n, a, b, c;
char s[N];
bool vis[N];
void _main() {
cin >> n >> a >> b >> c >> (s + 1);
int c520 = 0, c52 = 0, c20 = 0, c50 = 0, c5 = 0, c2 = 0, c0 = 0;
memset(vis, 0, sizeof(vis));
for (int i = 1; i + 2 <= n; i++) {
if (vis[i] || vis[i + 1] || vis[i + 2]) continue;
if (s[i] == '5' && s[i + 1] == '2' && s[i + 2] == '0') {
vis[i] = vis[i + 1] = vis[i + 2] = true;
c520++;
}
}
int res = c520;
for (int i = 1; i < n; i++) {
if (vis[i] || vis[i + 1]) continue;
if (s[i] == '5' && s[i + 1] == '2') c52++, vis[i] = vis[i + 1] = true;
if (s[i] == '5' && s[i + 1] == '0') c50++, vis[i] = vis[i + 1] = true;
if (s[i] == '2' && s[i + 1] == '0') c20++, vis[i] = vis[i + 1] = true;
}
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
if (s[i] == '5') c5++;
if (s[i] == '2') c2++;
if (s[i] == '0') c0++;
}
vector<tuple<int, int, int>> vec;
while (c52--) vec.emplace_back(0, 0, 1);
while (c50--) vec.emplace_back(0, 1, 0);
while (c20--) vec.emplace_back(1, 0, 0);
for (auto [x, y, z] : vec) {
a -= x, b -= y, c -= z;
if (a < 0 || b < 0 || c < 0) a += x, b += y, c += z;
else res++;
}
while (true) {
int mn = min({a, b, c});
if (mn == a) {
if (c5 == 0 || b == 0 || c == 0) break;
c5--, b--, c--, res++;
} else if (mn == b) {
if (c2 == 0 || a == 0 || c == 0) break;
c2--, a--, c--, res++;
} else {
if (c0 == 0 || a == 0 || b == 0) break;
c0--, a--, b--, res++;
}
}
cout << res + min({a, b, c}) << '\n';
}
:::::
AGC008B Contiguous Repainting
给出 n 个整数 a_i 。初始有 n 个数 c_i=0 ,一次操作选择一个长为 k 的子区间,将区间内所有 c_i 置为 0 或 1 。你的得分定义为 \sum\limits_{i=1}^n c_ia_i ,最大化得分并输出。
:::::success[题解]
注意到可以从两侧向中心收缩,若干次操作后,除了中间长为 k 的一段区间必须纯色,两侧的数都可以任意决策。
于是预处理前后缀正数和,以及子区间和即可。复杂度 O(n) 。
:::::
:::::info[代码]
#define int long long
const int N = 1e5 + 5;
int n, k, a[N], s[N], pre[N], suf[N];
void _main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i]; s[i] = s[i - 1] + a[i];
pre[i] = pre[i - 1] + max(0LL, a[i]);
}
for (int i = n; i >= 1; i--) suf[i] = suf[i + 1] + max(0LL, a[i]);
int res = 0;
for (int i = 1; i + k - 1 <= n; i++)
chkmax(res, max(0LL, s[i + k - 1] - s[i - 1]) + pre[i - 1] + suf[i + k]);
cout << res;
}
:::::
AGC008C Tetromino Tiling
有如图所示的方块各 a_1\sim a_7 个。
你需要从中选出 k 个方块拼成一个 2\times2k 矩形。方块可以旋转,但不能翻转。最大化 k 并输出。
:::::success[题解]
注意到第 3,6,7 类方块是不能选择的,证明考虑将矩形黑白染色。
同时,我们发现 2 类方块总是可以贡献,且不影响其他方块,先将 a_2 加入答案。
现在只要决策 1,4,5 类。事实上,这三种方块的拼法只有两类:
注意到内部匹配的数目与奇偶性相关,故只要算出 1,4,5 组合一次的答案,与不组合的答案取 \max ,这样就覆盖了所有奇偶性。
复杂度 O(1) 。
:::::
:::::info[代码]
#define int long long
const int N = 1e5 + 5;
int a1, a2, a3, a4, a5, a6, a7;
void _main() {
cin >> a1 >> a2 >> a3 >> a4 >> a5 >> a6 >> a7;
int r1 = a2 + a1 / 2 * 2 + a4 / 2 * 2 + a5 / 2 * 2, r2 = 0;
if (a1 > 0 && a4 > 0 && a5 > 0) {
a1--, a4--, a5--;
r2 = a2 + a1 / 2 * 2 + a4 / 2 * 2 + a5 / 2 * 2 + 3;
}
cout << max(r1, r2);
}
:::::
P14607 [NWRRC 2025] High Score
你需要玩一个 2048 游戏,具体地,你持有一个多重集,每次选择如下两种操作之一:
加入一个 2 或 4 。
选择两个相同数 x ,将其删除并加入它们的和 2x ,你的得分增加 2x 。
给定 k ,要求在操作过程中,多重集大小始终不超过 k 。给你一个数 x ,你需要构造一个使得最终得分为 x 的最终多重集,或报告无解。
多测,T\le10^4 ,k\le16 ,2 秒,1024 MB。
:::::success[题解]
首先有一个观察,最小能选的数就是 2 ,而 2+2=4 ,所以得分一定是 4 的倍数,不是的话直接无解。
假设在集合中留下一个数 2^i ,我们希望求出合成 2^i 的得分上下界,可以如下分析:
最低分通过全部用 4 来合成,得分为 (i-2)2^i 。
最高分通过全部用 2 来合成,得分为 (i-1)2^i 。
只要通过把两次加入的 2 换成一个 4 ,就能让得分减少 4 分,从而使得得分覆盖 \left[(i-2)2^i,(i-1)2^i\right] 中所有 4 的倍数。
上述过程忽略了空位的限制。设当前有 s 个空位,全 2 合成显然可以得到 2^s ,而如果使用全 2 合成 2^{s+1} ,空间就不够用了,所以只能将两个 2 用一个 4 代替,最大得分变成 2^{s+1}-4 。
理清上述思路后贪心即可,求出当前情况所能得到的最大得分,将最大幂次加入答案集合,然后继续求解。
:::::info[代码]
#define int long long
int n, k, x;
void _main() {
cin >> n >> k;
while (n--) {
cin >> x;
if (x % 4) {cout << -1 << '\n'; continue;}
int s = k;
vector<int> res;
while (x > 0) {
if (s == 0) break;
int p = 2;
for (int i = 2; i <= s + 1; i++) {
if ((i - 2) * (1LL << i) <= x) p = i;
}
int val = (p - 1) * (1LL << p);
if (p == s + 1) val -= 4;
x -= min(x, val), res.emplace_back(1LL << p), s--;
}
if (x != 0) {
cout << -1 << '\n';
} else {
cout << res.size() << ' ';
for (int i : res) cout << i << ' ';
cout << '\n';
}
}
}
:::::
CF1661D Progressions Covering
给出一个长为 n 的序列 b_i 。你初始持有一个序列 a_i 且全为 0 。一次操作选择一个长为 k 的区间 [l,r] ,将区间中的数依次加上 1,2,\cdots,k 。求使得 \forall i,a_i\ge b_i 的最小操作次数。
:::::success[题解]
注意到 r 位置加的数字最大。于是我们考虑倒序扫描并依次贪心。具体地,我们枚举 r 并令 a_r 满足条件,再考虑 a_{r-1} 及之前。
有一种感性理解:因为后面的位置都满足了,把最大的一项给当前位不劣。
严谨的证明考虑调整法,证明任意最优解都可以调整到这个策略且不劣。这里是 Gemini 给出的严格证明,有兴趣的读者可以阅读。
基于此,只需实现区间加等差数列 & 单点查询。容易用线段树维护差分数组 O(n\log n) 实现。
事实上,我们有更优秀的解法。因为 a_i 随扫描过程中动态更新且查询位置单调,可以直接维护二阶差分做到 O(n) 。
:::::info[代码]
#define int long long
const int N = 3e5 + 5;
int n, k, a[N], b[N];
void _main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> b[i];
int res = 0, sum = 0, cur = 0;
for (int r = n; r >= 1; r--) {
int l = max(1LL, r - k + 1), len = r - l + 1;
if (b[r] > sum) {
int x = (b[r] - sum + len - 1) / len;
res += x, sum += x * len, cur += x, a[l] += x;
}
sum -= cur, cur -= a[r];
} cout << res;
}
:::::
HDU5501 The Highest Mark
给出 n 个任务 (a_i,b_i,c_i) 和一个时刻上限 m 。你可以在任意时刻开始完成一个任务,完成任务需要花费 c_i 的时间。若在 t 时刻完成且 t\le m ,则获得 a_i-t\times b_i 的得分。
不允许同时进行多个任务,可以以任意顺序完成任务。最大化得分并输出。
多测,T\le10 ,n\le1000 ,m\le3000 ,1 秒,128 MB。
:::::success[题解]
邻项交换确定 DP 顺序模板题。
如果我们可以确定一个做题顺序,就可以顺着做 01 背包。设 f_j 为前 j 时刻内的最大得分,加入任务 i 则做转移
f_j\gets f_{j-c_i}+a_i-j\times b_i
考虑做 exchange argument 来确定 DP 顺序。设当前用时为 t ,两个任务分别为 i,j :
先 i 后 j 的得分为 X=a_i-(t+c_i)b_i+a_j-(t+c_i+c_j)b_j ;
先 j 后 i 的得分为 Y=a_j-(t+c_j)b_j+a_i-(t+c_i+c_j)b_i 。
作差得
X-Y=c_jb_i-c_ib_j
所以定义 \prec 为 c_ib_j<c_jb_i 。另外发现 c_ib_j<c_jb_i\iff\dfrac{c_i}{b_i}<\dfrac{c_j}{b_j} ,所以是 \prec 是一个严格全序。
:::::info[代码]
const int N = 3005;
int n, m;
struct node {
int a, b, c;
} a[N];
i64 f[N];
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i].a >> a[i].b >> a[i].c;
sort(a + 1, a + n + 1, [](const node& x, const node& y) {
return 1LL * x.c * y.b < 1LL * y.c * x.b;
});
fill(f, f + m + 1, 0);
for (int i = 1; i <= n; i++)
for (int j = m; j >= a[i].c; j--)
f[j] = max(f[j], f[j - a[i].c] + a[i].a - 1LL * j * a[i].b);
cout << *max_element(f, f + m + 1) << '\n';
}
:::::
ABC366F Maximum Composition
给出 n 个一次函数 f_i(x)=k_ix+b_i 。你需要选出 k 个两两不同的函数 i_1,i_2,\cdots,i_k ,最大化 (f_{i_1}\circ f_{i_2}\circ\cdots\circ f_{i_k})(1) 并输出。
:::::success[题解]
考虑用 exchange argument 确定 DP 顺序。
记当前函数值为 x ,考虑 n=2 的局部情况。此时
\begin{aligned}
(f_2\circ f_1)(x)&=k_1k_2 x+k_1b_2+b_1\\
(f_1\circ f_2)(x)&=k_1k_2 x+k_2b_1+b_2
\end{aligned}
钦定前者更优,则 k_1b_2+b_1>k_2b_1+b_2\iff\frac{k_1-1}{b_1}<\frac{k_2-1}{b_2} 。这是一个严格全序。
然后直接做 DP 即可,dp_{i,j} 表示考虑到第 i 个函数,选了 j 个的最大函数值,讨论选不选 f_i 进行转移:
不选 f_i :dp_{i+1,j}\gets dp_{i,j} ;
选 f_i :dp_{i+1,j+1}\gets f_i(dp_{i,j}) 。
:::::info[代码]
const int N = 2e5 + 5;
int n, k;
struct func {
i64 k, b;
i64 operator() (i64 x) const {return k * x + b;}
bool operator< (const func& a) const {
return (k - 1) * a.b < b * (a.k - 1);
}
} f[N];
i64 dp[N][15];
void _main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> f[i].k >> f[i].b;
sort(f + 1, f + n + 1);
for (int i = 1; i <= n; i++) {
dp[i][0] = 1;
for (int j = 0; j <= k; j++) {
chkmax(dp[i + 1][j], dp[i][j]);
chkmax(dp[i + 1][j + 1], f[i](dp[i][j]));
}
}
cout << dp[n + 1][k];
}
:::::
ABC308F Vouchers
现有 n 个物品,第 i 个物品的价格为 a_i 元。有 m 张优惠券 (l_i,d_i) ,可以分配给至多一个物品,满足 a_i\ge l_i 后将价格变为 a_i-d_i 。最小化购买所有物品的代价并输出。
:::::success[题解]
考虑求出 \sum\limits_{i=1}^n a_i 作为初始代价,问题转化为最大化优惠价值。
将优惠券按 d_i 降序排序。我们维护一下可用的物品集合 S ,然后对优惠券进行扫描,找到满足 a_i\ge l_i 的最小的 a_i 将两者配对,随后从 S 中删去。
正确性显然,考虑最优解中使用的优惠券集合不会改变,只是使用顺序不同。
用 multiset 维护 S ,视 n,m 同阶复杂度 O(n\log n) 。
:::::info[代码]
#define int long long
const int N = 2e5 + 5;
using node = pair<int, int>;
int n, m;
multiset<int> a;
node b[N];
void _main() {
cin >> n >> m;
int res = 0;
for (int i = 1, x; i <= n; i++) cin >> x, res += x, a.emplace(x);
for (int i = 1; i <= m; i++) cin >> b[i].second;
for (int i = 1; i <= m; i++) cin >> b[i].first;
sort(b + 1, b + m + 1, greater<node>());
for (int i = 1; i <= m; i++) {
auto [w, lim] = b[i];
auto it = a.lower_bound(lim);
if (it == a.end()) continue;
a.erase(it), res -= w;
}
cout << res;
}
:::::
P4801 [CCO 2015] 饥饿的狐狸
给出 n 个物品 a_i ,你初始持有一个正整数 x\gets m 。你可以以任意顺序扫描物品并进行如下操作:令 x\gets m 或者不操作,然后获得 |a_i-x| 的得分,并令 x\gets a_i 。
分别最小化 & 最大化得分并输出。
:::::success[题解]
弱化题目,先假定没有 x\gets m 的操作。
根据绝对值几何意义,其满足四边形不等式 a\le b\le c\le d\implies|a-b|+|c-d|\le|a-c|+|b-d| 。根据 exchange argument 的理论,我们将 a_i 排序,顺次选择就是最小化得分,最大最小交替选择就是最大化得分。
现在加入 x\gets m 这个操作。对于最大化的情形,我们直接在选择时,判断一下加入操作是否会使得局部贡献变化。但是最小化这样做是不对的。
考虑最小化时的特殊性质,如果直接排序选择答案不会有变化。考虑将 m 插入到序列中,则序列被分为 m 之前和 m 之后两段,可以对两段分别跑上述算法。
形式化地,我们先完成 a_i\ge m 的元素,然后令 x\gets m ,再完成 a_i\le m 的元素。
:::::info[代码]
const int N = 1e5 + 5;
int n, m, a[N], b[N];
i64 workmx(int st) {
i64 res = 0, last = m;
for (int i = 1, j = n; i <= j; st ^= 1) {
if (st) res += max<i64>(abs(a[i] - last), abs(a[i] - m)), last = a[i++];
else res += max<i64>(abs(a[j] - last), abs(a[j] - m)), last = a[j--];
} return res;
}
i64 workmn() {
int p = lower_bound(a + 1, a + n + 1, m) - a;
i64 res = 0, last = m;
for (int i = p; i <= n; i++) res += abs(a[i] - last), last = a[i];
last = m;
for (int i = p - 1; i >= 1; i--) res += abs(a[i] - last), last = a[i];
return res;
}
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
cout << workmn() << ' ' << max(workmx(0), workmx(1));
}
:::::
AGC004D Teleporter
给出长为 n 的正整数序列 a_i ,再给出一个正整数 k 。你可以修改一些 a_i ,要求每个数在执行恰好 k 次 i\gets a_i 后 i=1 。最小化修改次数并输出。
保证初始给出的序列中,执行若干次 i\gets a_i 可以使得 i=1 。
:::::success[题解]
连边 i\to a_i ,题目给出的是一棵内向基环树。
观察到一个关键性质:若 a_1=1 ,即 1 处为自环,则题目限制弱化为基环树上两点距离 \le k 。容易发现令 a_1\gets1 总是不劣。
此时 1 处是一个自环,其余部分就是一棵根向树。我们建反边,改成一棵叶向树。
自顶向下贪心是错误的,容易构造反例。考虑自底向上贪心。设当前子树的最大高度为 h ,若 h=k-1 且子树不直接连向 1 ,则再向上一层就会导致深度超过 k ,故修改连边。
:::::info[代码]
const int N = 1e5 + 5;
int n, k, ans, a[N];
vector<int> e[N];
int dfs(int u) {
int ht = 0;
for (int v : e[u]) ht = max(ht, dfs(v) + 1);
if (u != 1 && ht == k - 1 && a[u] != 1) ans++, ht = -1;
return ht;
}
void _main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
ans = (a[1] != 1);
for (int i = 2; i <= n; i++) e[a[i]].emplace_back(i);
dfs(1), cout << ans;
}
:::::
CF1373F Network Coverage
现有 n 个元素形成一个环,第 i 个元素具有 a_i 的得分需求。另有 n 个物品,第 i 个物品可以给元素 i,i+1 提供得分,提供的得分之和不超过 b_i 。特别地,第 n 个物品可以给元素 n,1 提供得分。
判定是否所有元素的得分需求都能被满足。
多测,\sum n\le10^6 ,2 秒,250 MB。
:::::success[题解]
考虑根据元素—物品关系建立二分图,则问题变为一个带权二分图完美匹配的存在性问题。
注意到 Hall 定理推论 3,并且容易发现 \sum b_y-\sum a_x 取得 \min 的 W 只可能是一段区间。因此问题转化为:判定 \forall l\le r,\sum\limits_{i=l}^r a_i\le\sum\limits_{i=l-1}^r b_i 是否成立。
移项得 b_{l-1}+\sum\limits_{i=l}^r(b_i-a_i)\ge0 ,记 p_i 为 b_i-a_i 前缀和,条件即 b_{l-1}+p_{r}-p_{l-1}\ge0\iff p_r\ge p_{l-1}-b_{l-1} 。考虑枚举 l ,只需求出最小的 p_r 进行判定,因此对 p 做一个后缀 \min 。
环容易处理,断环为链将 a,b 复制一倍即可,复杂度 O(n) 。
:::::info[代码]
#define int long long
const int N = 2e6 + 5, inf = 1e18;
int n, a[N], b[N], p[N], s[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
if (accumulate(a + 1, a + n + 1, 0LL) > accumulate(b + 1, b + n + 1, 0LL))
return cout << "NO\n", void();
copy(a + 1, a + n + 1, a + n + 1), copy(b + 1, b + n + 1, b + n + 1);
for (int i = 1; i <= 2 * n; i++) p[i] = p[i - 1] + b[i] - a[i];
s[2 * n] = p[2 * n];
for (int i = 2 * n - 1; i >= 1; i--) s[i] = min(s[i + 1], p[i]);
for (int i = 1; i <= n; i++) {
if (s[i + 1] < p[i] - b[i]) return cout << "NO\n", void();
}
cout << "YES\n";
}
:::::
CF1208C Magic Grid
给出 n ,保证 4\mid n ,要求构造一个 n\times n 的矩阵,矩阵中的元素构成一个 0\sim n^2-1 的排列,且每行每列的异或和相等。
:::::success[题解]
注意到 n\equiv0\pmod4\implies n^2-1\equiv3\pmod4\implies\bigoplus\limits_{i=0}^{n^2-1}i=0 。于是断言异或和都为 0 有解。
我们充分发扬人类智慧,发现如下矩阵是 4\times4 的一组解:
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
并且这里的合法性只与低 4 位有关。更高位能被异或消掉,于是将矩阵分成若干 4\times4 的块,每块内如上构造即可。
:::::info[代码]
const int N = 1005;
int n, a[N][N];
void _main() {
cin >> n;
int tot = 0;
for (int i = 1; i <= n; i += 4)
for (int j = 1; j <= n; j += 4)
for (int x = 0; x < 4; x++)
for (int y = 0; y < 4; y++)
a[i + x][j + y] = tot++;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cout << a[i][j] << ' ';
cout << '\n';
}
}
:::::
P13570 [CCPC 2024 重庆站] 连方
给出长为 n 的串 a,b ,字符集为 \{\tt{\#},\tt{.}\} 。构造一个 7\times n 的网格图,仅包含 # 和 .,满足:
网格第 1 行与 a 相同,第 7 行与 b 相同。
# 的极大四连通连通块均为实心矩形;
所有 # 八连通。
构造方案或报告无解。
多测,\sum n\le2\times10^5 ,1 秒,512 MB。
:::::success[题解]
当 a,b 其中之一为全 # 时,唯一合法的构造为网格全部填 #,特判掉这个 corner case。
考虑如下构造:将第 2,6 行分别设为 1,7 的补。问题转化为通过 3,4,5 行将上下连通。
一个简单的构造是在 3,5 行放一个单点,单点需要满足第 2,6 行的对应位置为空,且两侧存在一个 #。
最后考虑第 4 行。可以将单点间拉一条链来连通,注意特判单点水平距离 \le1 的情形。复杂度 O(n) 。
:::::info[代码]
const int N = 1e5 + 5;
int n;
char a[N], b[N], s[8][N];
void _main() {
cin >> n >> (a + 1) >> (b + 1);
bool all1 = count(a + 1, a + n + 1, '#') == n, all2 = count(b + 1, b + n + 1, '#') == n;
if (all1 || all2) {
if (all1 ^ all2) return cout << "No\n", void();
cout << "Yes\n";
for (int i = 1; i <= 7; i++) cout << string(n, '#') << '\n';
return;
}
cout << "Yes\n";
copy(a + 1, a + n + 1, s[1] + 1), copy(b + 1, b + n + 1, s[7] + 1);
for (int i = 1; i <= n; i++) s[2][i] = a[i] == '#' ? '.' : '#';
for (int i = 1; i <= n; i++) s[6][i] = b[i] == '#' ? '.' : '#';
fill(s[3] + 1, s[3] + n + 1, '.'), fill(s[4] + 1, s[4] + n + 1, '.'), fill(s[5], s[5] + n + 1, '.');
int p1 = -1, p2 = -1;
s[2][n + 1] = '.', s[6][n + 1] = '.';
for (int i = 1; i <= n; i++) {
if (s[2][i] == '.' && (s[2][i - 1] == '#' || s[2][i + 1] == '#')) {
s[3][i] = '#';
p1 = i; break;
}
}
for (int i = 1; i <= n; i++) {
if (s[6][i] == '.' && (s[6][i - 1] == '#' || s[6][i + 1] == '#')) {
s[5][i] = '#';
p2 = i; break;
}
}
if (p1 > p2) swap(p1, p2);
if (p2 - p1 <= 1) s[4][p1] = '#';
else fill(s[4] + p1 + 1, s[4] + p2, '#');
for (int i = 1; i <= 7; i++) {
for (int j = 1; j <= n; j++) cout << s[i][j];
cout << '\n';
}
}
:::::
AGC050A AtCoder Jumper
构造一个 n 个点的有向图,每个点的出度至多为 2 ,要求任意两点间可达且最短路 \le10 。
:::::success[题解]
容易想到构造一棵完全二叉树。如果出度为 3 ,分别构造 i\to\lfloor\frac{i}{2}\rfloor,i\to2i,i\to2i+1 即可。
回到原题,考虑去掉返祖边,并在叶子处连两条向上的边。
注意到 i\to2i\bmod n+1,i\to(2i+1)\bmod n+1 符合要求。原因是 10 次操作后可达的点同余于 2^{10}x+y ,这构成一个模 n 的剩余系。
:::::info[代码]
int n;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cout << (2 * i) % n + 1 << ' ' << (2 * i + 1) % n + 1 << '\n';
}
:::::
P6155 修改
给出长为 n 的正整数序列 a_i,b_i 。你可以任意重排 b_i 。一次操作花费 b_i 的代价,令 a_i\gets a_i+1 ,目标为所有 a_i 不等,求最小代价,对 2^{64} 取模。
:::::success[题解]
我们有如下两个观察:
确定每个位置的代价 f_i 后,由于要最小化代价,我们希望 f_i,b_i 反序配对。本质是排序不等式,反序和 < 乱序和 < 同序和。
根据直觉,我们希望 f_i 两极分化而不是集中。这个形式很类似 Karamata 不等式,可用 Abel 变换证明。
根据上述结论模拟即可。这里我的实现使用了一个大根堆,设目标位置为 x ,我们尽量将大的花费 x-a_i 分给当前位置,得到后续差值 x'-a_i 。复杂度 O(n\log n) 。
启示:出现 \sum a_i b_i 的最优化问题考虑排序不等式;对于研究的对象,考虑其分布均匀 / 分散是否更优。
:::::info[代码]
const int N = 1e6 + 5;
int n, a[N], b[N];
vector<int> f;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
priority_queue<int> q;
for (int i = 1, x = 0; i <= n || !q.empty(); ) {
if (q.empty()) x = a[i];
for (; i <= n && a[i] <= x; i++) q.emplace(a[i]);
f.emplace_back(x - q.top()); q.pop(), x++;
}
for (int i = 1; i <= n; i++) cin >> b[i];
sort(b + 1, b + n + 1), sort(f.begin(), f.end(), greater<int>());
u64 res = 0;
for (int i = 0; i < (int)f.size(); i++) res += (u64)b[i + 1] * (u64)f[i];
cout << res;
}
:::::
QOJ12212 Best Subsequence
给出一个长为 n 的序列 a_i 。你需要选出一个长为 k 的子序列 b_0\sim b_{k-1} ,最小化 \max\limits_{i=0}^{k-1}(b_i+b_{(i+1)\bmod k}) 并输出。
:::::success[题解]
转换视角,变成删去 n-k 个数。
我们找到原序列中邻项和最大的一对数,并删去两个数中较大的那个。这是因为只有删掉这对数中的一个才能减小答案,并且删较大数不劣。
用大根堆和链表维护即可,复杂度 O(n\log n) 。
:::::
:::::info[代码]
const int N = 2e5 + 5;
int n, k, a[N], L[N], R[N];
bool del[N];
struct node {
int sum, u, v;
bool operator< (const node& a) const {return sum < a.sum;}
node(int a = 0, int b = 0, int c = 0) : sum(a), u(b), v(c) {}
};
priority_queue<node> q;
void _main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
L[i] = (i - 1 + n) % n, R[i] = (i + 1) % n;
q.emplace(a[i] + a[R[i]], i, R[i]);
}
for (int T = n - k; T > 0; ) {
auto [sum, u, v] = q.top(); q.pop();
if (del[u] || del[v] || R[u] != v) continue;
if (a[u] < a[v]) swap(u, v);
del[u] = true, R[L[u]] = R[u], L[R[u]] = L[u];
q.emplace(a[L[u]] + a[R[u]], L[u], R[u]), T--;
}
int res = 0;
for (int i = 0; i < n; i++)
if (!del[i]) chkmax(res, a[i] + a[R[i]]);
cout << res;
}
:::::
:::::success[另解 1]
考虑二分答案 x 转判定。
我们注意到原序列中最小的数一定会被保留,所以可以从最小值处断环为链。判定使用反悔贪心,动态调整,能选即选,不能选就换掉最后一个数即可。
复杂度 O(n\log V) 。
:::::
:::::success[另解 2]
仍然考虑二分答案 x 转判定。将 \le\lfloor\frac{x}{2}\rfloor 的数称为小数,反之称为大数。
在最终的子序列中,如果有相邻的大数则不合法,如果全为小数则合法,否则需要判定小数与大数的和是否超过 x 。
这样一来,我们先选择所有小数,再判定两个小数之间能否插入大数即可。复杂度 O(n\log V) 。
:::::
:::::success[另解 3]
仍然考虑二分答案 x 转判定,并从最小值处断环为链。
考虑 DP,记 f_i 为前缀 [1,i] 中合法的最长子序列长度。转移为
f_i=1+\max_{j<i\land a_i+a_j\le x}f_j
直接做是 O(n^2) 的,用权值树状数组维护,支持单点修改和前缀 \max ,总复杂度就是 O(n\log n\log V) 。可能会被卡常。
:::::
CF549G Happy Line
给出长为 n 的序列 a_i 。一次操作选择一个 i ,令 a_i\gets a_i-1,a_{i+1}\gets a_{i+1}+1 ,然后交换 a_i,a_{i+1} 。
问是否能通过上述操作使得 a_i 单调不降。若能则需要构造出最终序列。
:::::success[题解]
小清新贪心构造题。
如果你的做法需要涉及到操作本身,那么复杂度至少是 O(n^2) 的,显然无法通过。
对着操作本身做是困难的,这是因为每个数都在变。本题的关键在于寻找不变量。
考虑 a_i 移动到位置 j 时,a_i 的值变为 a_i-(j-i)=a_i+i-j 。将关于 i 的部分单独提出,令 a_i\gets a_i+i ,则题目转化为重排 a 使得 0\le a_1-1\le a_2-2\le\cdots\le a_n-n 。
根据 a_i 是非负整数,上述条件等价于 0<a_1<a_2<\cdots<a_n 。故直接将 a 排序,无解当且仅当有重复数字。否则输出 a_i-i 。
复杂度 O(n\log n) ,可以用基数排序优化复杂度。
:::::info[代码]
const int N = 2e5 + 5;
int n, a[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], a[i] += i;
sort(a + 1, a + n + 1);
for (int i = 1; i < n; i++) {
if (a[i] == a[i + 1]) return cout << ":(", void();
}
for (int i = 1; i <= n; i++) cout << a[i] - i << ' ';
}
:::::
CF1110E Magic Stones
给出两个长为 n 的序列 a_i,b_i 。一次操作选择下标 i\in(1,n) ,令 a_i\gets a_{i+1}+a_{i-1}-a_i 。判断是否能将 a 变成 b 。
:::::success[题解]
首先判掉 a_1\ne b_1 或 a_n\ne b_n 的情形。
寻找操作的不变量。令差分数组 d_i=a_{i+1}-a_i ,在操作后
\begin{aligned}
d'_i=a_{i+1}-(a_{i+1}+a_{i-1}-a_i)=a_i-a_{i-1}&=d_{i-1}\\
d'_{i-1}=(a_{i+1}+a_{i-1}-a_i)-a_{i-1}=a_{i+1}-a_i&=d_i
\end{aligned}
因此,这个操作的本质是交换差分 。
容易说明,邻项交换的操作可以得到原数组的任意排列,于是判定两个序列的差分构成的多重集是否相同即可。
:::::
:::::info[代码]
const int N = 1e5 + 5;
int n, a[N], b[N], x[N], y[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
if (a[1] != b[1] || a[n] != b[n]) return cout << "No", void();
for (int i = 1; i < n; i++) x[i] = a[i + 1] - a[i], y[i] = b[i + 1] - b[i];
sort(x + 1, x + n), sort(y + 1, y + n);
for (int i = 1; i < n; i++) if (x[i] != y[i]) return cout << "No", void();
cout << "Yes";
}
:::::
P3524 [POI 2011] IMP-Party
给出一个 n 个点,m 条边的无向图,保证 3\mid n 。保证图中存在一个点数为 \frac{2n}{3} 的团,要求找到一个点数为 \frac{n}{3} 的团。
:::::success[题解]
取补图,将团变成独立集,这样更好思考。
考虑每次选择一条边,然后删去边的两个端点,以及这两个节点延伸出去的所有边。
因为每组匹配里,至少有一个点不在独立集中,根据题目约束这样的匹配至多有 \frac{n}{3} 组,因此删去以后一定可以得到一个大小 \ge\frac{n}{3} 的独立集。
这里我们也能看到一个实际意义:\frac{2n}{3} 本质是 n-k ,而 \frac{n}{3} 本质是 n-2k 。
:::::info[代码]
const int N = 3005;
int n, m, tag[N];
bitset<N> a[N];
void _main() {
cin >> n >> m;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
a[u][v] = a[v][u] = 1;
}
for (int u = 1; u <= n; u++)
for (int v = u + 1; v <= n; v++) {
if (a[u][v] || tag[u] || tag[v]) continue;
tag[u] = 1, tag[v] = 1; break;
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (!tag[i]) cnt++, cout << i << ' ';
if (cnt == n / 3) break;
}
}
:::::
CF1198C Matching vs Independent Set
给出一个 3n 个点 m 条边的无向图,找到一个大小为 n 的匹配,或者找到大小为 n 的独立集。输出构造。
多测,\sum n\le10^5 ,\sum m\le5\times10^5 ,1 秒,250 MB。
:::::success[题解]
维护一个点集 S=\{1,2,\cdots,3n\} ,对于每条边 (u,v)\in E ,将 u,v 从 S 中删去。操作后若 S 非空,则 S 必然构成一个点独立集。
否则有 |S|<n ,则 u,v 的总数目 >2n ,将 (u,v) 加入匹配中,匹配的边数必然 \ge n 。
注意在删去 u,v 前要判断 u\in S\land v\in S 是否成立。复杂度 O(n+m) 。
:::::info[代码]
const int N = 5e5 + 5;
int n, m, tag[N];
void _main() {
cin >> n >> m;
fill(tag + 1, tag + 3 * n + 1, 1);
vector<int> e;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
if (tag[u] && tag[v]) tag[u] = tag[v] = 0, e.emplace_back(i);
}
if (count(tag + 1, tag + 3 * n + 1, 1) >= n) {
cout << "IndSet\n";
int cnt = 0;
for (int i = 1; i <= 3 * n; i++) {
if (tag[i]) cout << i << ' ', cnt++;
if (cnt >= n) break;
}
cout << '\n';
} else {
cout << "Matching\n";
for (int i = 0; i < n; i++) cout << e[i] << ' ';
cout << '\n';
}
}
:::::
CF1325F Ehab's Last Theorem
给出一个 n 个点 m 条边的连通无向图,找到一个大小为 \lceil\sqrt{n}\rceil 的独立集,或者一个大小不小于 \lceil\sqrt{n}\rceil 的环,输出构造。
:::::success[题解]
考虑拉出一棵 DFS 生成树,如果存在一条返祖边,其端点深度差 \ge\lceil\sqrt{n}\rceil-1 ,那么就找到了一个满足要求的环,直接输出即可。
反之考虑按深度模 \lceil\sqrt{n}\rceil-1 分成若干同余类,由于返祖边的性质,这些同余类一定都是独立集。感性理解一下,所有集合中必然存在至少一个满足要求的集合,于是做完了。
:::::info[代码]
const int N = 1e5 + 5;
int n, m, k, fa[N], vis[N], dep[N];
vector<int> e[N], g[N];
void dfs(int u) {
vis[u] = true;
for (int v : e[u]) {
if (v == fa[u]) continue;
if (vis[v]) {
if (dep[u] - dep[v] + 1 < k) continue;
cout << 2 << '\n';
vector<int> vec = {v};
for (int i = u; i != v; i = fa[i]) vec.emplace_back(i);
cout << vec.size() << '\n';
for (int i : vec) cout << i << ' ';
exit(0);
} else {
dep[v] = dep[u] + 1, fa[v] = u, dfs(v);
}
}
}
void _main() {
cin >> n >> m; k = ceil(sqrt(n));
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
e[u].emplace_back(v), e[v].emplace_back(u);
}
dfs(1);
for (int i = 1; i <= n; i++) g[dep[i] % (k - 1)].emplace_back(i);
for (int i = 0; i < k - 1; i++) {
if ((int)g[i].size() < k) continue;
cout << 1 << '\n';
for (int j = 0; j < k; j++) cout << g[i][j] << ' ';
break;
}
}
:::::
CF476D Dreamoon and Sets
给出正整数 k ,称正整数集合 S 是好的,当且仅当 |S|=4 且 \forall i,j\in S\land i\ne j,\gcd(i,j)=k 。现给定 n ,求出最小的 m 使得可以用 [1,m] 中的整数构造 n 个好的集合,且每个整数至多出现一次。输出最小的 m 和构造。
:::::success[题解]
记集合 S=\{a,b,c,d\} ,构造集合 S'=\left\{\frac{a}{k},\frac{b}{k},\frac{c}{k},\frac{d}{k}\right\} ,则 S 是好集合等价于 S' 中元素两两互质。故我们求解出 k=1 的情形后,将所有元素乘上 k 输出即可。
对于任意好集合,其至多存在一个偶数,则至少有三个奇数,于是答案的下界为 6(n-1)+5=6n-1 。
注意到 \{1,2,3,5\} 的结构很好,考虑构造若干组 \{i,i+1,i+2,i+4\} 的集合,其中 i\bmod6=1 。作差易得两两互质。
这个构造取到了下界。于是做完了,复杂度 O(n) 。
:::::info[代码]
int n, k;
void _main() {
cin >> n >> k;
cout << (6 * n - 1) * k << '\n';
for (int i = 1, j = 1; j <= n; i += 6, j++)
printf("%d %d %d %d\n", i * k, (i + 1) * k, (i + 2) * k, (i + 4) * k);
}
:::::
ARC163C Harmonic Mean
给出 n ,构造一个值域为 [1,10^9] 的整数集合 S ,使得 \sum\limits_{i\in S}\frac{1}{i}=n 。输出构造或报告无解。
多测,T\le500 ,n\le500 ,2 秒,1024 MB。
:::::success[题解]
注意到 \dfrac{1}{x(x+1)}=\dfrac{1}{x}-\dfrac{1}{x+1} ,移项得
\dfrac{1}{x}=\dfrac{1}{x+1}+\dfrac{1}{x(x+1)}
考虑归纳构造。得到 n 的构造后根据上述式子拆掉一个分数,即可得到 n+1 的构造。基本构造为 n=3 时 1=\dfrac{1}{2}+\dfrac{1}{3}+\dfrac{1}{6} 。
在实现时,我们用 set 来维护当前构造,每次拆掉最小的分母,如果新的构造不合法就找次小,以此类推。经过验证,在 n\le500 时该做法的最大元素为 267806 ,满足要求。
注意特判 n=1 和 n=2 的情形。
:::::info[代码]
int n;
void _main() {
cin >> n;
if (n == 1) return cout << "Yes\n1\n", void();
if (n == 2) return cout << "No\n", void();
cout << "Yes\n";
set<int> q = {2, 3, 6};
int c = 3;
while (c < n) {
int x = *q.begin(); q.erase(q.begin());
if (q.count(x + 1) || q.count(x * (x + 1))) {
cout << x << ' ';
continue;
}
q.emplace(x + 1), q.emplace(x * (x + 1)), c++;
}
for (int i : q) cout << i << ' ';
cout << '\n';
}
:::::
P7840 「C.E.L.U-03」重构
现有 n 个节点,第 i 个节点的点权为 a_i 。你需要将 n 个节点连成一棵树,最小化 \sum\limits_{i=1}^n d_i^2 a_i 并输出。其中 d_i 为节点 i 的度数。
:::::success[题解]
一个关键结论是,若 \forall1\le i\le n,d_i\in[1,n) 且 \sum\limits_{i=1}^n d_i=2n-2 ,则度数序列 d_i 可以构造一棵树。
这允许我们考察 d_i 的形态。考虑调整法,先令 d_i\gets1 并做 n-2 轮调整,令 d_i\gets d_i+1 。这一操作对答案的影响为 \Delta_i=(d_i+1)^2a_i-d_i^2a_i=(2d_i+1)a_i 。
我们希望最小化答案。注意到 \Delta_i 关于 d_i 单增,故直接用小根堆维护 (\Delta_i,i) 的二元组,每次取出 \Delta_i 最小的 i 后,令 d_i\gets d_i+1 即可。复杂度 O(n\log n) 。
:::::info[代码]
#define int long long
const int N = 3e5 + 5;
using node = pair<int, int>;
int n, a[N], d[N];
priority_queue<node, vector<node>, greater<node>> q;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i], d[i] = 1;
q.emplace(3 * a[i], i);
}
int res = accumulate(a + 1, a + n + 1, 0LL);
for (int T = n - 2; T--; ) {
auto [w, u] = q.top(); q.pop();
res += w, d[u]++;
q.emplace((2 * d[u] + 1) * a[u], u);
}
cout << res;
}
:::::
:::::success[另解]
仍然用 \forall1\le i\le n,d_i\in[1,n) 且 \sum\limits_{i=1}^n d_i=2n-2 的等价条件刻画。
设 f(x) 为 \sum\limits_{i=1}^n d_i=x 时 \sum\limits_{i=1}^n d_i^2 a_i 的 \min ,感性理解 f 是下凸函数,故考虑 WQS 二分求 f(2n-2) 。
二分切线斜率 a ,问题转化为求 g(x)=f(x)-ax 的谷点 x_0 。
这相当于每 1 个度数带上了 a 的额外代价,只要最小化 \sum\limits_{i=1}^n(d_i^2a_i-d_ia) 。而求和式中的 d_i^2a_i-d_ia 是关于 d_i 的二次函数,可以算出最值。于是 x_0 为所有取到 \min 的 d_i 之和。
复杂度 O(n\log n) 。
:::::
CF1437E Make It Increasing
给出一个长为 n 的数组 a_i ,再给出一个下标集合 S 。一次操作选择一个 i\notin S ,将 a_i 改为任意整数。
求使得数组 a_i 严格递增的最小操作次数,或报告无解。
:::::success[题解]
套路地令 a_i\gets a_i-i ,将严格递增转为单调不降。
我们考虑不能被修改的位置,这些位置形成了对序列的一个划分,每段的值必须在端点之间,且段内单调不降。因此,如果 S 对应子序列不是不降的,则必然无解。
判掉无解以后考虑每一段。不妨将问题变成最大化保留的数的数目,容易发现我们只要求最长不降子序列。注意处理上下界的限制。
使用二分 / 树状数组优化即可,复杂度 O(n\log n) 。
启示:递增和不降的相互转化可以通过 \pm i 实现。
:::::info[代码]
const int N = 5e5 + 5, inf = 1e9;
int n, k, a[N], b[N];
void _main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], a[i] -= i;
a[0] = -inf, a[n + 1] = inf;
for (int i = 1; i <= k; i++) cin >> b[i];
b[0] = 0, b[k + 1] = n + 1;
int res = 0;
for (int x = 0; x <= k; x++) {
int l = b[x], r = b[x + 1], lo = a[l], hi = a[r];
if (lo > hi) return cout << -1, void();
vector<int> st;
for (int i = l + 1; i <= r - 1; i++) {
if (a[i] < lo || a[i] > hi) continue;
auto it = upper_bound(st.begin(), st.end(), a[i]);
if (it == st.end()) st.emplace_back(a[i]);
else *it = a[i];
}
res += st.size();
} cout << n - k - res;
}
:::::
CF2140D A Cruel Segment's Thesis
给出 n 条线段 [l_i,r_i] 。你持有一个集合 S 且初始 S=\varnothing 。你需要重复执行以下操作直到无法进行:
选择两条线段 [l_i,r_i],[l_j,r_j] ,满足 [l_i,r_i]\notin S\land[l_j,r_j]\notin S 。任取 l_k\in[l_i,r_i],r_k\in[l_j,r_j] ,然后将 [l_i,r_i],[l_j,r_j],[l_k,r_k] 全部加入 S 。
最大化操作结束后 \sum\limits_{[l,r]\in S}(r-l) 的值并输出。
多测,\sum n\le2\times10^5 ,2 秒,250 MB。
:::::success[题解]
不难发现每条线段的初始贡献 r_i-l_i 一定会被计算,下面忽略这个部分。
由简单贪心,每次一定选 l_k=l_i,r_k=r_j 最大化贡献。因此问题的实质为将线段两两配对,最大化 \sum(r_j-l_i) 。
记 L 为提供 l_i 的线段集合,R 为提供 r_j 的线段集合,最终要求 |L|=|R|=\lfloor\frac{n}{2}\rfloor 且 L\cap R=\varnothing 。
我们初始将 n 条线段全部归入 L ,然后考虑调整:将线段 i 放到 R 的贡献差为 r_i-(-l_i)=l_i+r_i 。故按这个式子降序排序,选择前 |R| 大即可。
若 n 为偶数,此时 L,R 均符合条件,直接计算。
若 n 为奇数,我们需要删去一条线段。贪心地,如果删除 L 中的线段,应当删去 \max L 。如果删除 R 中的线段,应当删去 \min R 。
:::::info[代码]
const int N = 2e5 + 5;
int n;
struct node {
int l, r;
} a[N];
void _main() {
i64 sum = 0;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].l >> a[i].r, sum += a[i].r - a[i].l;
if (n == 1) return cout << sum << '\n', void();
sort(a + 1, a + n + 1, [](const node& x, const node& y) -> bool {
return x.l + x.r > y.l + y.r;
});
if (n & 1) {
i64 x = 0, y = 0, ml = 0, mr = 2e18;
for (int i = 1; i <= n / 2 + 1; i++) x += a[i].r, mr = min<i64>(mr, a[i].r);
for (int i = n / 2 + 2; i <= n; i++) x -= a[i].l;
for (int i = 1; i <= n / 2; i++) y += a[i].r;
for (int i = n / 2 + 1; i <= n; i++) y -= a[i].l, ml = max<i64>(ml, a[i].l);
cout << sum + max(x - mr, y + ml) << '\n';
} else {
for (int i = 1; i <= n / 2; i++) sum += a[i].r;
for (int i = n / 2 + 1; i <= n; i++) sum -= a[i].l;
cout << sum << '\n';
}
}
:::::
P15379 字符串博弈 / bo1
A & B 两人进行博弈,A 得到一个字符可重集 S ,B 得到一个可重集 T ,A 需要选择一个 A\subseteq S\land A\ne\varnothing 的可重集 A 告诉 B,B 选择可重集 B\subseteq T 并得到可重集 C=A\cup B ,然后按一定顺序将 C 中所有字符排列为字符串。若字符串回文则 B 胜利,否则 A 胜利。
假定两人绝顶聪明,求出 A 是否必胜。若必胜,输出字典序最小的 S 的排列。
多测,1\le\sum|S|,\sum|T|\le10^6 ,1 秒,512 MB。
:::::success[题解]
考虑 C 可以被重排为回文串的条件:至多存在一个字符在 C 中出现奇数次。
考虑 A 应当满足的条件:若 x\in A\land x\in T ,则 B 总是能通过不加 / 加入 x 的方法调整 x 出现次数的奇偶性。因此至少存在两个字符 x,y\in A 且 x,y\notin T 为 A 合法的充要条件。
不妨记 x<y ,则 A 集合实际上被 x,y 分为若干段。由于最小化字典序的要求,使用如下构造:
考虑如何确定 x,y 。我们正序扫描每个字符 c ,若 x\in S\land x\notin T ,则考虑用 c 替换已经确定的 x,y 。
事实上,当 x 在 S 中出现偶数次时,令 x\gets y,y\gets c 较优。原因是原本的构造中 x 没有全部输出,而现在 x 可以多输出一次,字典序更小。容易说明其他情况下的替换都不优。
复杂度 O(n+|\Sigma|) 。
:::::
:::::info[代码]
const int N = 1e6 + 5;
int a[26], b[26];
string s, t;
void _main() {
fill(a, a + 26, 0), fill(b, b + 26, 0);
cin >> s >> t;
for (char c : s) a[c - 'a']++;
for (char c : t) b[c - 'a']++;
deque<int> q;
for (int i = 0; i < 26; i++) {
if (a[i] == 0 || b[i] != 0) continue;
if (q.size() < 2) q.emplace_back(i);
else if (a[q.front()] % 2 == 0) q.pop_front(), q.emplace_back(i);
}
if (q.size() < 2) return cout << -1 << '\n', void();
for (int i = 0; i <= q[1]; i++) {
if (i == q[0]) cout << string(a[i] - (a[i] & 1 ^ 1), i + 'a');
else if (i == q[1]) cout << string(1, i + 'a');
else cout << string(a[i], i + 'a');
} cout << '\n';
}
:::::
P2619 [国家集训队] Tree I
给出一张 n 个点 m 条边的无向带权连通图,每条边有黑白两色。求恰好有 k 条白色边的生成树中,边权和最小的生成树,并输出答案。
:::::success[题解]
我们声称答案关于 k 下凸。
考虑 WQS 二分斜率 a ,相当于给每条白边带 +a 的额外代价。此时求出最小生成树中的白边数目,即可决策二分方向。
注意到二分时只要合并黑边和白边两个有序数组,可以归并优化,做到 O(m\alpha(n)\log V) 。
类似题目是 P5633。两个题的注意事项可以参见讨论区。
:::::
:::::info[代码]
const int N = 1e5 + 5;
int n, m, k, c0, c1, fa[N];
int find(int x) {return x == fa[x] ? x : fa[x] = find(fa[x]);}
struct edge {
int u, v, w, col;
bool operator< (const edge& e) const {
return w != e.w ? w < e.w : col < e.col;
}
} a[N], b[N], c[N];
void _main() {
cin >> n >> m >> k;
for (int i = 1, u, v, w, c; i <= m; i++) {
cin >> u >> v >> w >> c; u++, v++;
if (c == 0) a[++c0] = {u, v, w, c};
else b[++c1] = {u, v, w, c};
}
sort(a + 1, a + c0 + 1), sort(b + 1, b + c1 + 1);
int l = -100, r = 100, res = -1;
while (l <= r) {
int mid = (l + r) >> 1, sum = 0, cnt = 0;
auto check = [&]() -> void {
iota(fa + 1, fa + n + 1, 1);
for (int i = 1; i <= c0; i++) a[i].w += mid;
merge(a + 1, a + c0 + 1, b + 1, b + c1 + 1, c + 1);
for (int i = 1; i <= m; i++) {
int fu = find(c[i].u), fv = find(c[i].v);
if (fu == fv) continue;
fa[fu] = fv, sum += c[i].w;
if (c[i].col == 0) cnt++;
}
for (int i = 1; i <= c0; i++) a[i].w -= mid;
};
check();
if (cnt >= k) l = mid + 1, res = sum - k * mid;
else r = mid - 1;
}
cout << res;
}
:::::
P11232 [CSP-S 2024] 超速检测
有一个长为 L 的数轴,第 i 个点从 d_i 开始做加速度恒定的运动。初速度为 v_i ,加速度为 a_i 。当某点速度为 0 时,认为其停止运动。
现有 m 个监控,第 i 个监控位于第 p_i 个位置。若监控捕捉到某个点经过该监控位置的瞬时速度大于 V ,则将该点标记。求出:
有多少点会被标记;
在保证点被标记的数目不变的前提下,最多可以删除多少个监控。
多测,T\le20 ,n,m\le10^5 ,L\le10^6 ,1\le V,v_i\le10^3 ,-10^3\le a_i\le10^3 ,2 秒,512 MB。
:::::success[题解]
观察性质:每辆车有且仅有一段超速区间。
考虑把这段区间处理出来,根据物理知识,我们分类讨论:
若 a=0 :
若 v>V ,该车一直超速,超速区间 [d,L] ;
若 v\le V ,该车不超速。
若 a>0 :
若 v>V ,该车一直超速,超速区间 [d,L] ;
若该车在 L 处速度 v'\le V ,该车不超速;
否则,超速区间 \left[d+\left\lfloor\dfrac{V^2-v^2}{2a}\right\rfloor,L\right] 。
若 a<0 :
若 v\le V ,该车不超速。
若该车在 L 处速度 v'>V ,该车一直超速,超速区间 [d,L] ;
否则,超速区间 \left[d,\min\left(L,d+\dfrac{V^2-v^2}{2a}\right)\right) 。
将坐标离散化,第一问差分一下即可解决。
下面解决第二问:将所有区间按右端点降序排序,并顺次扫描每个区间。若当前区间内还未添加监控,就加入最右侧的监控。模拟即可。
:::::info[代码]
int n, m, l0, v0, p[N], d[N], pre[N];
struct car {
int d, v, a, l, r;
int get(int s) {return v * v + 2 * a * s;}
void calc() {
d++;
if (a == 0) { // 匀速
if (v > v0) l = d, r = l0;
else l = r = -1;
} else if (a > 0) { // 匀加速
if (v > v0) l = d, r = l0;
else if (get(l0 - d) <= v0 * v0) l = r = -1;
else l = d + (v0 * v0 - v * v) / (2 * a) + 1, r = l0;
} else { // 匀减速
if (v <= v0) l = r = -1;
else if (get(l0 - d) > v0 * v0) l = d, r = l0;
else l = d, r = min<int>(l0, ceil(d + 1.0 * (v0 * v0 - v * v) / (2 * a) - 1));
}
}
} a[N];
void _main() {
read(n, m, l0, v0); l0++;
for (int i = 1; i <= n; i++) read(a[i].d, a[i].v, a[i].a), a[i].calc();
for (int i = 1; i <= m; i++) read(p[i]), d[i] = ++p[i];
sort(d + 1, d + m + 1);
int tot = unique(d + 1, d + m + 1) - d - 1;
for (int i = 1; i <= m; i++) p[i] = lower_bound(d + 1, d + tot + 1, p[i]) - d;
for (int i = 1; i <= m; i++) pre[p[i]]++;
for (int i = 1; i <= m; i++) pre[i] += pre[i - 1];
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (a[i].l == -1) continue;
a[i].l = lower_bound(d + 1, d + tot + 1, a[i].l) - d;
a[i].r = upper_bound(d + 1, d + tot + 1, a[i].r) - d - 1;
if (pre[a[i].r] - pre[a[i].l - 1]) cnt++;
}
cout << cnt << ' ';
sort(a + 1, a + n + 1, [](const car& a, const car& b) -> bool {
return a.r < b.r;
});
int res = 0;
for (int i = 1, last = 0; i <= n; i++) {
if (a[i].l == -1 || pre[a[i].r] - pre[a[i].l - 1] == 0) continue;
int l = a[i].l, r = a[i].r;
if (last < l) res++, last = r;
} cout << m - res << '\n';
memset(a, 0, sizeof(a)), memset(d, 0, sizeof(d)), memset(p, 0, sizeof(p));
}
:::::
:::::success[另解]
可以用差分约束解决第二问。
对选 / 不选的 01 序列用前缀和刻画,设前缀和序列为 s_i ,对于被标记的区间有 s_r-s_{l-1}\ge1 。同时加入 01 序列本身的约束 0\le s_i-s_{i-1}\le1 。
用 SPFA 来求解这个问题,理论复杂度 O(Tn^2) ,实际得分 80 分。
P9166 [省选联考 2023] 火车站
在数轴上有 n 个点和 m 条线段 [l_i,r_i] ,你初始位于点 x 并选取一条覆盖 x 的线段向一个方向运动。若两条线段有交,则可以转到另一条线段上,但禁止变向。求所有可达的线段端点。
:::::success[题解]
将线段按左端点升序排序,然后顺次扫描。对于当前线段,我们需要知道它与前面的线段是否有交,记一下可达的 $r_{\max}$ 即可。
由于可达的位置具有单调性,因此直接模拟就有正确性。复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
using node = pair<int, int>;
int n, m, x, vis[N];
node a[N];
void _main() {
cin >> n >> m >> x;
for (int i = 1; i <= m; i++) cin >> a[i];
sort(a + 1, a + m + 1);
for (int i = 1, to = x; i <= m && a[i].first <= to; i++) {
int r = a[i].second;
if (r > x) chkmax(to, r), vis[r] = 1;
}
sort(a + 1, a + m + 1, [](const node& a, const node& b) -> bool {
return a.second > b.second;
});
for (int i = 1, to = x; i <= m && a[i].second >= to; i++) {
int l = a[i].first;
if (l < x) chkmin(to, l), vis[l] = 1;
}
for (int i = 1; i <= n; i++) if (vis[i]) cout << i << ' ';
}
```
:::::
:::::success[另解]
我 vp 时的魔怔做法。
仍然以向右为例。考虑可行性 DP,记 $f_i$ 为点 $i$ 是否可达。考虑转移,将线段按左端点升序排序并顺次扫描,若当前线段内存在 $f_i=1$ 的点就将线段内所有点的 $f$ 值设为 $1$,并加入线段的右端点。
使用区间加 / 区间 max 的线段树维护,复杂度 $O(n\log n)$。[提交记录](https://www.luogu.com.cn/record/263313371)。
:::::
## [P11628 [WC2025] 猫粮](https://www.luogu.com.cn/problem/P11628)
> 现有 $n$ 只猫,每只猫必须吃 $m$ 克猫粮。你的手上有 $n$ 袋优质猫粮和普通猫粮。
>
> 若打开优质猫粮,猫粮可能被任意未吃饱的猫抢走;若打开普通猫粮,猫粮只会被指定的猫吃掉。这两种情况下,猫粮都会被吃光。
>
> 给出每袋优质猫粮的重量 $a_i$ 和普通猫粮的重量 $b_i$。保证 $\sum a_i+\sum b_i=nm$ 且 $a_i,b_i\in[1,m)$。
>
> 判断是否有在任何情况下都可以喂饱所有猫的方案。
>
> 多测,$T\le50$,$n\le5\times10^4$,$m\le10^5$,1 秒,512 MB。
:::::success[题解]
首先观察性质:
- 由于猫粮重量总和为 $nm$,食物不能浪费,每只猫吃的猫粮必须恰好为 $m$ 克。
- 由于 $a_i,b_i<m$,每只猫至少吃两袋猫粮。
- 猫粮总袋数为 $2n$,故每只猫必须精确地分到 $2$ 袋猫粮。
因此,我们需要将 $2n$ 袋猫粮两两配对,满足每一对的和均为 $m$,且防止优质猫粮的随机性。分析配对方法:
- 普通 + 普通:这是绝对安全的。
- 优质 + 普通:先给出优质猫粮,对于抢到的猫,再将手里的普通猫粮拿出配对。
- 优质 + 优质:这是危险的。对于这种策略,我们在下文分类讨论部分展开说明。
通过上述分析,本题的贪心策略即:尽量消耗优质猫粮。为此,我们先做完所有优质 + 普通的配对。
此时,优质 + 普通已经无法配对,我们处理普通 + 普通的配对。若无法配对,则无解。
最后我们要处理优质 + 优质的情况。设此时剩下 $u$ 袋优质猫粮,分类讨论:
- 若 $u=2$,只需剩下的猫粮重量之和为 $m$。
- 若 $u>2$,则必须所有猫粮的重量都是 $\dfrac{m}{2}$。
用一个桶统计,注意特判若干 corner case。复杂度 $O(T(n+m))$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, m, a[N], b[N], x[N], y[N];
void _main() {
cin >> n >> m;
fill(x + 1, x + m + 1, 0), fill(y + 1, y + m + 1, 0);
for (int i = 1; i <= n; i++) cin >> a[i], x[a[i]]++;
for (int i = 1; i <= n; i++) {
cin >> b[i];
if (x[m - b[i]] >= 1) x[m - b[i]]--;
else y[b[i]]++;
}
int u = accumulate(x + 1, x + m + 1, 0), v = accumulate(y + 1, y + m + 1, 0);
if (u == 0 && v == 0) return cout << "Yes\n", void();
for (int i = 1; i <= m; i++) {
if (y[i] == 0) continue;
y[i]--;
if (y[m - i] == 0) return cout << "No\n", void();
y[m - i]--;
}
if (u == 2) {
for (int i = 1; i <= m; i++) {
if (x[i] == 0) continue;
if (x[i] == 2) return cout << "Yes\n", void();
if (x[i] == 1 && x[m - i] == 1) return cout << "Yes\n", void();
return cout << "No\n", void();
}
}
if (m % 2 == 0 && x[m / 2] == u) return cout << "Yes\n", void();
cout << "No\n";
}
```
:::::
## [P10537 [APIO2024] 九月](https://www.luogu.com.cn/problem/P10537)
> 给出一棵有 $n$ 个节点的有根树,根节点编号为 $0$。给出 $m$ 个序列 $s_i$,你需要将每个 $s_i$ 划分为若干段,满足:
>
> - 划分的位置相同;
> - 划分后,每个序列的对应段数字构成的集合相同;
> - 删去每段对应的节点,剩余的结构仍是一棵树,此操作不独立。
>
> 最大化划分的段数并返回。
>
> 多测,$n\le10^5$,$m\le5$,$\sum nm\le8\times10^5$,1 秒,1000 MB。
:::::success[题解]
依旧观察性质,我们发现:一个节点必然排在它所有后代的后面。如果相反,那么它们属于同一段。
基于此,容易得到 $m=1$ 的贪心策略:
顺序扫描 $s_i$,对于当前节点 $u$,找到位置最偏右的后代,则当前段至少要延伸到最右位置才可能合法。如果扫描的下标正好追上了当前段所需的最远位置,我们就可以贪心地把前面划开。
对于一般情况,我们加入了集合相同的约束。一个巧妙的办法是,我们将节点 $u$ 的最右侧位置,定义为它及其所有后代在所有序列中出现的最大下标。
可以通过自底向上递推得到这个位置,然后重复 $m=1$ 的算法流程。由于给出的 $F$ 数组满足 $F_i\le i-1$,所以我们可以直接按拓扑序转移,不用建图递归,代码非常简洁。
复杂度 $O(nm)$。
:::::
:::::info[代码]
```cpp line-numbers
int solve(int N, int M, vector<int> F, vector<vector<int>> S) {
vector<int> mx(N, 0);
for (int i = 0; i < M; i++) {
for (int j = 0; j < N - 1; j++) chkmax(mx[S[i][j]], j);
}
vector<int> to(mx.begin(), mx.end());
for (int i = N - 1; i >= 1; i--) {
if (F[i] >= 1) chkmax(to[F[i]], to[i]);
}
int res = 0, cur = 0;
for (int k = 0; k < N - 1; k++) {
chkmax(cur, to[S[0][k]]);
if (k == cur) res++;
} return res++;
}
```
:::::
## [P7913 [CSP-S 2021] 廊桥分配](https://www.luogu.com.cn/problem/P7913)
> 给出两个线段集合 $S_1,S_2$ 和总颜色数 $n$。对于集合 $S$,将其中线段按左端点升序处理,为其分配一种颜色,要求该颜色未被与其重叠的线段占用。若无法分配则无颜色。保证线段左端点不同。
>
> 你需要将 $n$ 种颜色分配给两个集合,使得两集合按上述规则操作后,分配到颜色的线段数目之和最大。输出这个最大值。
>
> $n,|S_1|,|S_2|\le10^5$,1 秒,512 MB。
:::::success[题解]
设 $f(i)$ 为将 $i$ 种颜色分配给 $S_1$ 后,分配到颜色的线段数目,同理定义 $g(i)$。题目所求即
$$
\max_{i=0}^n\left(f(i)+g(n-i)\right)
$$
考虑如何求出 $f$。我们发现,对于多出一种颜色的情况,原来分配的颜色不会改变,因此 $f(i)$ 从 $f(i-1)$ 转移而来。
又根据左端点升序的原则,我们可以维护没有颜色的线段集合 $S$,并以 $l_x$ 为关键字升序排序。左端点最小的线段 $x$ 即为该轮分配颜色的线段。
取出这条线段后,我们发现还有其他线段 $y$ 也可以分配颜色 $i$,其满足的条件为 $l_y\ge r_x$。于是继续模拟操作,形成一条 $x\to y\to\cdots$ 的分配链。由于线段总数是 $O(n)$ 的,模拟的复杂度正确。
使用 std::set 维护集合 $S$,可以递推求出 $f,g$,然后合并答案。视 $n,|S_1|,|S_2|$ 同阶复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
using node = pair<int, int>;
int n, x, y, f[N], g[N];
set<node> a, b;
int nxt(set<node>& st) {
int cnt = 0, last = 0;
while (!st.empty()) {
auto it = st.lower_bound(node(last, last));
if (it == st.end()) break;
cnt++, last = it->second, st.erase(it);
} return cnt;
}
void _main() {
cin >> n >> x >> y;
for (int i = 1, u, v; i <= x; i++) cin >> u >> v, a.emplace(u, v);
for (int i = 1, u, v; i <= y; i++) cin >> u >> v, b.emplace(u, v);
for (int i = 1; i <= n; i++) f[i] = f[i - 1] + nxt(a);
for (int i = 1; i <= n; i++) g[i] = g[i - 1] + nxt(b);
int res = 0;
for (int i = 0; i <= n; i++) chkmax(res, f[i] + g[n - i]);
cout << res;
}
```
:::::
## [P7915 [CSP-S 2021] 回文](https://www.luogu.com.cn/problem/P7915)
> 给出一个长为 $2n$ 的序列 $a_i$,其中 $1\sim n$ 恰好出现两次。你初始持有空序列 $b_i$,有如下两种操作:
>
> - `L` 操作:将 $a$ 的开头元素加入 $b$ 的结尾,然后将其删除;
> - `R` 操作:将 $a$ 的结尾元素加入 $b$ 的结尾,然后将其删除。
>
> 目标为将 $b_i$ 变为回文数列。构造字典序最小的方案,或报告无解。
>
> 多测,$\sum n\le5\times10^5$,1 秒,512 MB。
:::::success[题解]
不妨设为第一步取出 $a_1$。在 $(1,n]$ 中找到唯一的 $a_p=a_1$,则 $a_p$ 必须被取走。这说明,在 $(1,p)\cup(p,n]$ 中的元素必须先被取走。
此时,$a_i$ 被分为两段。我们维护外侧指针 $L,R$ 和内侧指针 $l,r$。

将 $b_i$ 视为双端,那么:
- 对于 $b_i$ 的前端,只能从外侧 $L,R$ 取;
- 对于 $b_i$ 的后端,只能从内侧 $l,r$ 取。
因此,我们维护这四个指针,分类讨论指针上字符相同的情况,可以得到构造。若所有字符都不相同,则无解。
由于要求最小化字典序,我们要按照 $L\to l$,$L\to r$,$R\to l$,$R\to r$ 的顺序依次配对。注意配对时的越界判断。
上述操作默认了第一次取出 $a_1$。如果第一次取出 $a_{2n}$,做法是完全一致的。因此跑两遍指针即可,复杂度 $O(n)$。
**启示:对于具有可逆性的操作,考虑在时间轴上正反同时构造,形成归纳结构。**
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e6 + 5;
int n, a[N];
vector<char> q1, q2;
void LL() {q1.emplace_back('L'), q2.emplace_back('L');}
void LR() {q1.emplace_back('L'), q2.emplace_back('R');}
void RL() {q1.emplace_back('R'), q2.emplace_back('L');}
void RR() {q1.emplace_back('R'), q2.emplace_back('R');}
void out(char c) {
cout << c;
for (int i = 0; i < (int)q1.size(); i++) cout << q1[i];
for (int i = q2.size() - 1; i >= 0; i--) cout << q2[i];
cout << "L\n";
}
bool solve(int L, int l, int r, int R) {
q1.clear(), q2.clear();
int T = n - 1;
while (T--) {
if (L < l && a[L] == a[l]) LL(), L++, l--;
else if (L <= l && r <= R && a[L] == a[r]) LR(), L++, r++;
else if (L <= l && r <= R && a[R] == a[l]) RL(), R--, l--;
else if (r < R && a[R] == a[r]) RR(), R--, r++;
else return false;
}
return true;
}
void _main() {
cin >> n;
for (int i = 1; i <= 2 * n; i++) cin >> a[i];
int p1 = find(a + 2, a + 2 * n + 1, a[1]) - a;
if (solve(2, p1 - 1, p1 + 1, 2 * n)) return out('L'), void();
int p2 = find(a + 1, a + 2 * n, a[2 * n]) - a;
if (solve(1, p2 - 1, p2 + 1, 2 * n - 1)) return out('R'), void();
cout << -1 << '\n';
}
```
:::::
## [P11361 [NOIP2024] 编辑字符串](https://www.luogu.com.cn/problem/P11361)
> 给出四个长为 $n$ 的 01 串 $s_1,s_2,t_1,t_2$。
>
> 一次操作可以在 $s_1$ 或 $s_2$ 中交换两个相邻且允许参与交换的字符。若 $t_1$ 中某个位为 $0$,则表示 $s_1$ 的该位不能参与交换,反之可以参与交换。$t_2$ 同理。
>
> 最大化 $s_{1,i}=s_{2,i}$ 的 $i$ 的数目并输出。
>
> 多测,$T\le10$,$n\le10^5$,1 秒,512 MB。
:::::success[题解]
观察性质起手:
- 允许交换的位置必然形成若干连续段,在段内任意重排均可实现。
- 从一侧开始扫描,尽量匹配当前位置的字符,这至多会导致后面一对字符不匹配。
其实分析到这里做法就出来了:从左到右扫描,尝试匹配当前字符。但是实现并不简单,所以仔细分析一下:
我们先求出连续段,记录段内 0/1 的数目,和每个下标所属的段编号。然后根据是否固定分成三类:
- 若两个字符串的该位置都固定,直接统计答案;
- 若恰有一个字符串该位置不固定,需查询当前连通块中是否存在另一个字符串的该位置字符,若有,则匹配;
- 若两个字符串该位置都不固定,钦定其中一个字符串的该位为 0/1,转化为上一种情形。当然我们仍需判断当前连通块是否存在这个字符。
按照上述做法模拟,复杂度 $O(n)$。
**启示:“能操作就操作”是很多题目的关键性质。**
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, l1, l2, p1[N], p2[N], c1[2][N], c2[2][N];
char s1[N], s2[N], t1[N], t2[N];
void _main() {
cin >> n >> (s1 + 1) >> (s2 + 1) >> (t1 + 1) >> (t2 + 1);
memset(c1, 0, sizeof(c1)), memset(c2, 0, sizeof(c2));
memset(p1, 0, sizeof(p1)), memset(p2, 0, sizeof(p2));
l1 = l2 = 0;
for (int i = 1; i <= n; i++) {
if (t1[i] != t1[i - 1]) p1[i] = ++l1;
else p1[i] = p1[i - 1];
c1[s1[i] ^ 48][p1[i]]++;
}
for (int i = 1; i <= n; i++) {
if (t2[i] != t2[i - 1]) p2[i] = ++l2;
else p2[i] = p2[i - 1];
c2[s2[i] ^ 48][p2[i]]++;
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (t1[i] == '0' && t2[i] == '0') {
if (s1[i] == s2[i]) res++;
} else if (t1[i] == '0') {
if (c2[s1[i] ^ 48][p2[i]]) c2[s1[i] ^ 48][p2[i]]--, res++;
} else if (t2[i] == '0') {
if (c1[s2[i] ^ 48][p1[i]]) c1[s2[i] ^ 48][p1[i]]--, res++;
} else {
if (c1[0][p1[i]] && c2[0][p2[i]]) c1[0][p1[i]]--, c2[0][p2[i]]--, res++;
else if (c1[1][p1[i]] && c2[1][p2[i]]) c1[1][p1[i]]--, c2[1][p2[i]]--, res++;
}
}
cout << res << '\n';
}
```
:::::
## [P9755 [CSP-S 2023] 种树](https://www.luogu.com.cn/problem/P9755)
> 给定一棵节点树为 $n$ 的有根树,根节点为 $1$。每个节点上有一个任务。每个时刻,你可以标记一个节点,要求这个节点为根或其父亲已被标记。
>
> 对于被标记的节点,在第 $x$ 个时刻任务的完成度将会增加 $\max(1,b_i+x\times c_i)$。目标为所有节点 $i$ 上任务的完成度 $\ge a_i$。初始时任务完成度均为 $0$。
>
> 求完成所有任务的最小时间。
>
> $1\le n\le10^5$,$1\le a_i\le10^{18}$,$1\le b_i\le10^9$,$-10^9\le c_i\le10^9$,保证答案 $\le10^9$,1 秒,512 MB。
:::::success[题解]
考虑特殊性质 A,即 $c_i=0$ 的情形。此时可以求出完成每个任务所需的时间 $t_i=\lceil\frac{a_i}{b_i}\rceil$。考虑如下贪心:将节点按照 $t_i$ 升序排序,依次扫描每个节点,将对应的根链全部标记。
由于答案取决于每个任务的最晚完成时间,因此考虑调整后一定不优,可以说明这个做法的正确性。
上述算法直观的实现是树剖线段树,复杂度 $O(n\log^2 n)$。但是这个过于魔怔了,考虑直接暴力,由于每个点最多被标记一次,跳父亲一共只有 $O(n)$ 次,因此复杂度正确。
接下来考虑特殊性质 B,即链的情形。考虑二分答案 $x$,对于每个点求出 $f(x,l,r)$,表示节点 $x$ 在时间段 $[l,r]$ 完成度的变化量,即可进行 check。下面讲解 $f$ 的计算。
- 若 $c_x\ge0$,此时增长量单调增,套等差数列求和即得 $f(x,l,r)=(r-l+1)\times b_x+\frac{(r-l+1)(l+r)}{2}c_x$。
- 否则需要分类讨论。列不等式 $b_x+k\times c_x\le1$ 得 $k_{\min}=\lfloor\frac{1-b_x}{c_x}\rfloor$,表示在时刻 $[k,+\infty)$ 中增长量恒为 $1$。
- 若 $k<l$,则增长量恒为 $1$,此时 $f(x,l,r)=r-l+1$;
- 若 $k>r$,则增长量恒为等差数列,与 $c_x\ge0$ 的式子相同:$f(x,l,r)=(r-l+1)\times b_x+\frac{(r-l+1)(l+r)}{2}c_x$;
- 若 $k\in[l,r]$,则增长量分为等差数列段和常数段。分段计算知 $f(x,l,r)=(k-l+1)\times b_x+\frac{(k-l+1)(l+k)}{2}c_x+r-k$。
可以做到 $O(1)$ 求解。注意计算 $f$ 的过程需要 int128。
考虑将 A & B 的做法结合起来。我们二分答案 $x$ 转判定,判定时再对每个节点二分一次,通过 $f$ 求出每个节点最晚完成任务的时间 $t_i$。
按照 $t_i$ 升序排序,使用 A 性质的均摊 $O(n)$ 做法即可,复杂度 $O(n\log n\log V)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, fa[N], tag[N];
vector<int> e[N];
void dfs(int u) {
for (int v : e[u]) if (v != fa[u]) fa[v] = u, dfs(v);
}
i64 a[N], b[N], c[N], t[N];
i128 f(int x, i128 l, i128 r) {
if (c[x] >= 0) return (r - l + 1) * b[x] + (r - l + 1) * (l + r) / 2 * c[x];
i64 k = (1 - b[x]) / c[x];
if (k < l) return r - l + 1;
if (k > r) return (r - l + 1) * b[x] + (r - l + 1) * (l + r) / 2 * c[x];
return (k - l + 1) * b[x] + (k - l + 1) * (l + k) / 2 * c[x] + r - k;
}
bool check(int x) {
for (int i = 1; i <= n; i++) {
if (f(i, 1, x) < a[i]) return false;
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) >> 1;
if (f(i, mid, x) >= a[i]) l = mid + 1, t[i] = mid;
else r = mid - 1;
}
}
fill(tag + 1, tag + n + 1, 0);
vector<int> vec(n); iota(vec.begin(), vec.end(), 1);
sort(vec.begin(), vec.end(), [](int x, int y) -> bool {
return t[x] < t[y];
});
int cur = 0;
for (int i : vec) {
if (tag[i]) continue;
stack<int> st;
for (int j = i; j != -1 && !tag[j]; j = fa[j]) st.emplace(j);
while (!st.empty()) {
int u = st.top(); st.pop();
if (++cur > t[u]) return false;
tag[u] = true;
}
} return true;
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i] >> c[i];
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
e[u].emplace_back(v), e[v].emplace_back(u);
}
fa[1] = -1, dfs(1);
int l = 0, r = 1e9, res = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) res = mid, r = mid - 1;
else l = mid + 1;
} cout << res;
}
```
:::::
## [P11833 [省选联考 2025] 推箱子](https://www.luogu.com.cn/problem/P11833)
> 数轴上有 $n$ 个箱子,第 $i$ 个箱子在 $0$ 时刻时位于坐标 $a_i$ 处,你的目标为在时刻 $t_i$ 以及之后的所有时刻,这个箱子位于坐标 $b_i$ 处。保证 $a_i,b_i$ 单调递增。
>
> 每个时刻,你可以将某个箱子移动一个单位长度,也可以放弃操作。任意时刻每个点上都只有一个箱子。
>
> 判断是否存在一种操作方法同时满足 $n$ 个要求。
>
> 多测,$T\le6$,$n\le2\times10^5$,2 秒,512 MB。
:::::success[题解]
观察性质 B,显然按 $t_i$ 升序排序最优。
考虑扩展到一般情形,直觉告诉我们仍应当按 $t_i$ 升序排序。考虑证明这一发现。
首先假定存在合法方案。此时在箱子 $u$ 到达 $b_u$ 的路上,对箱子 $v$ 产生推挤,容易发现这一次推挤一定使得 $v$ 离目标 $b_v$ 更近,也就是总体工作量单调减少。
接下来我们考虑局部,用 exchange argument 证明这一点。设两个箱子 $i,j$ 满足 $t_i\le t_j$,独立完成 $i$ 所需时间为 $c_i$,独立完成 $j$ 所需时间为 $c_j$。
- 若先 $i$ 后 $j$,需满足 $c_i\le t_i$ 且 $c_i+c_j\le t_j$。
- 若先 $j$ 后 $i$,需满足 $c_j\le t_j$ 且 $c_i+c_j\le t_i$。
由于 $t_i\le t_j$,策略二一定不优。因此我们说明了按 $t_i$ 升序排序即为最优。
接下来我们可以写出一个暴力,顺次扫描每个箱子将其推到终点,如果路上有别的箱子就递归下去一起推,复杂度 $O(n^2)$。
可以使用 ODT 优化这一过程。当几个箱子连成一体时,我们将其视为同一个连续段一同平移。
普通的 ODT 维护的是一个颜色段,但本题中 ODT 维护的是一个等差数列。设计三元组 $[l,r,v]$ 表示连续段左右端点为 $[l,r]$,左端点的坐标为 $v$。
在平移时,直接暴力扫描连续段计算代价即可。由于每个连续段至多产生一次且至多销毁一次,均摊复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 2e5 + 5;
int n, a[N], b[N], t[N], id[N];
struct node {
int l, r;
mutable int v;
node(int x = 0, int y = 0, int z = 0) : l(x), r(y), v(z) {}
bool operator< (const node& a) const {return l < a.l;}
};
set<node> odt;
auto split(int x) {
auto it = odt.lower_bound(node(x, 0, 0));
if (it != odt.end() && it->l == x) return it;
it--; int l = it->l, r = it->r, v = it->v;
odt.erase(it), odt.emplace(l, x - 1, v);
return odt.emplace(x, r, v + x - l).first;
}
int ask(int x) {
auto it = odt.lower_bound(node(x + 1, 0, 0));
it--; return it->v + x - it->l;
}
void _main() {
odt.clear();
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i] >> t[i], odt.emplace(i, i, a[i]);
iota(id + 1, id + n + 1, 1), sort(id + 1, id + n + 1, [&](int x, int y) -> bool {
return t[x] == t[y] ? x < y : t[x] < t[y];
});
int cur = 0;
for (int i = 1; i <= n; i++) {
int u = id[i], pos = ask(u);
if (pos < b[u]) {
auto itl = split(u), itr = itl;
int to = u - 1;
for (; itr != odt.end(); itr++) {
auto [l, r, v] = *itr; int v0 = b[u] + l - u;
if (v >= v0) break;
cur += (r - l + 1) * (v0 - v), to = r;
}
odt.erase(itl, itr), odt.emplace(u, to, b[u]);
}
if (pos > b[u]) {
auto itr = split(u + 1), itl = prev(itr);
int to = u + 1;
while (true) {
auto [l, r, v] = *itl; int v0 = b[u] - u + l;
if (v <= v0) {itl++; break;}
cur += (r - l + 1) * (v - v0), to = l;
if (itl == odt.begin()) break;
itl--;
}
odt.erase(itl, itr), odt.emplace(to, u, b[u] - u + to);
}
if (cur > t[u]) return cout << "No\n", void();
}
cout << "Yes\n";
}
```
:::::
## [QOJ14716 K-Coverage](https://qoj.ac/problem/14716)
> 给定数轴非负半轴上 $n$ 条长度为 $L$ 的线段,第 $i$ 条线段覆盖 $[l_i,l_i+L-1]$。你可以移动至多一条线段,问最多有多少个整点被覆盖恰好 $k$ 次。
>
> 多测,$\sum n\le2\times10^5$,$L,k\le n$,$l_i\le2n$,1 秒,1024 MB。
:::::success[题解]
用差分先跑出整点 $i$ 被覆盖的次数 $d_i$,此时可得初始答案。只需最大化答案的变化量。
定义 $a_i$ 表示在 $i$ 处,移除一条覆盖该点的线段所造成的变化,$b_i$ 表示在 $i$ 处,添加一条覆盖该点的线段所造成的变化,根据定义
$$
\begin{aligned}
a_i&=[d_i=k+1]-[d_i=k]\\
b_i&=[d_i=k-1]-[d_i=k]
\end{aligned}
$$
由于平移线段后,有贡献的部分是一段区间,因此将 $a_i,b_i$ 变为其前缀和。
接下来,我们分类讨论新线与原线是否有交。下文以向右平移为例,向左同理。
- 当新线与原线无交时:此时两侧贡献独立:

红线的代价为 $g_i=a_{l_i+L}-a_{l_i}$,绿线的代价为 $f_j=b_{l_j+L}-b_{l_j}$。对 $f$ 做一个后缀 $\max$ 即可得到答案。
- 当新线与原线有交时:此时贡献被分为三段:

两侧各有 $a_i,b_i$ 的贡献,中间段贡献抵消。设新位置为 $l'$,则贡献变化为 $h_{l'}-h_{l}$,其中 $h_i=a_i+b_{i+L}$。我们需要最大化 $h_{l'}-h_{l}$。
由于 $h_l$ 恒定,因此我们只需在 $l'\in[l+1,l+L-1]$ 之间最大化 $h_{l'}$。由于区间长度恒定,可以用单调队列解决。
根据上述讨论,求出贡献后取 $\max$ 即可。视 $n,l_i,L$ 同阶,复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 8e5 + 5, inf = 1e9;
int n, len, k, m, l[N], d[N], a0[N], b0[N], a[N], b[N], f[N], pre[N], suf[N];
int hl[N], hr[N], hd, tl, q[N], al[N], ar[N];
void _main() {
cin >> n >> len >> k, m = 4 * n;
fill(d, d + m + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> l[i];
d[l[i]]++, d[l[i] + len]--;
}
for (int i = 1; i <= m; i++) d[i] += d[i - 1];
int cnt = 0;
for (int i = 0; i <= m; i++) {
if (d[i] == k) cnt++;
a0[i] = (d[i] == k + 1) - (d[i] == k);
b0[i] = (d[i] == k - 1) - (d[i] == k);
}
fill(a, a + m + 1, 0), fill(b, b + m + 1, 0), fill(f, f + m + 1, -inf);
for (int i = 0; i <= m; i++) a[i + 1] = a[i] + a0[i], b[i + 1] = b[i] + b0[i];
for (int i = 0; i + len <= m; i++) f[i] = b[i + len] - b[i];
fill(pre, pre + m + 1, -inf), fill(suf, suf + m + 1, -inf);
pre[0] = f[0], suf[m - len] = f[m - len];
for (int i = 1; i + len <= m; i++) pre[i] = max(pre[i - 1], f[i]);
for (int i = m - len - 1; i >= 0; i--) suf[i] = max(suf[i + 1], f[i]);
fill(hl, hl + m + 1, 0), fill(hr, hr + m + 1, 0);
for (int i = 0; i + len <= m; i++) hl[i] = a[i + len] + b[i], hr[i] = a[i] + b[i + len];
fill(al, al + m + 1, inf), fill(ar, ar + m + 1, -inf);
hd = 1, tl = 0; // 左 [i-len+1, i-1] min
for (int i = 0; i + len <= m; i++) {
while (hd <= tl && q[hd] < i - len + 1) hd++;
if (hd <= tl && q[hd] < i) al[i] = hl[q[hd]];
while (hd <= tl && hl[i] <= hl[q[tl]]) tl--;
q[++tl] = i;
}
hd = 1, tl = 0; // 右 [i+1, i+len-1] max
for (int i = m - len; i >= 0; i--) {
while (hd <= tl && q[hd] > i + len - 1) hd++;
if (hd <= tl && q[hd] > i) ar[i] = hr[q[hd]];
while (hd <= tl && hr[i] >= hr[q[tl]]) tl--;
q[++tl] = i;
}
int res = 0;
for (int i = 1; i <= n; i++) {
int g = a[l[i] + len] - a[l[i]];
int a1 = l[i] >= len ? pre[l[i] - len] + g : -inf; // 左不交
int a2 = suf[l[i] + len] + g; // 右不交
int a3 = ar[l[i]] - hr[l[i]]; // 右交
int a4 = hl[l[i]] - al[l[i]]; // 左交
chkmax(res, max({a1, a2, a3, a4}));
} cout << cnt + res << '\n';
}
```
:::::
## [P14361 [CSP-S 2025] 社团招新](https://www.luogu.com.cn/problem/P14361)
> 给出 $n$ 个元素 $(a_i,b_i,c_i)$,保证 $n$ 为偶数。现有三个集合 $A,B,C$,你需要将每个元素分配一个集合,每次分配产生对应的得分。
>
> 要求 $|A|,|B|,|C|\le\frac{n}{2}$。最大化得分并输出。
>
> $n\le10^5$,1 秒,512 MB。
:::::success[题解]
反悔贪心,整体调整。
忽略集合大小的限制,一个平凡的贪心是将所有元素分配到得分最高的集合。不妨先做完这个贪心再调整。
注意到 $\frac{n}{2}$ 的限制具有很好的性质:若 $|A|$ 超过了限制,则 $|B|,|C|$ 一定不会超过。这允许我们调整到 $|A|=\frac{n}{2}$ 而不用担心不合法。
对于调整策略,可以定义一个损失函数,按照最大减去次大排序,损失较小的优先调整。
复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 1e5 + 5;
int n;
struct node {
pair<int, int> v[4];
void init() {
for (int i = 1; i <= 3; i++) cin >> v[i].first, v[i].second = i;
sort(v + 1, v + 4, greater<pair<int, int>>());
}
int loss() const {return v[1].first - v[2].first;}
bool operator< (const node& a) const {
return loss() < a.loss();
}
} a[N];
vector<node> vec[4];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) a[i].init();
for (int i = 1; i <= 3; i++) vec[i].clear();
int res = 0;
for (int i = 1; i <= n; i++) vec[a[i].v[1].second].emplace_back(a[i]), res += a[i].v[1].first;
for (int i = 1; i <= 3; i++) {
if ((int) vec[i].size() < n / 2) continue;
sort(vec[i].begin(), vec[i].end());
for (int j = 0; j < (int) vec[i].size() - n / 2; j++) res -= vec[i][j].loss();
} cout << res << '\n';
}
```
:::::
:::::success[另解]
考虑模拟费用流,先建立一个最大费用最大流模型:
- 建立超级源点 $S$ 和汇点 $T$。同时新建 $A,B,C$ 表示集合。
- $S$ 向每个元素连一条容量为 $1$,费用为 $0$ 的边。
- 每个元素向 $A,B,C$ 连一条容量为 $1$,费用为 $a_i,b_i,c_i$ 的边。
- $A,B,C$ 向 $T$ 连一条容量为 $\dfrac{n}{2}$,费用为 $0$ 的边。
直接 SSP 可以获得 55pts。考虑网络图的形态记为特殊,我们可以直接模拟费用流的求解过程。
不妨先将所有流安排到最大费用边,然后退流。设集合 $D$ 溢出,流量 $f>\dfrac{n}{2}$,则 $D\to T$ 的边超流,需要退掉。
根据 $\dfrac{n}{2}$ 这一类似于绝对众数的性质,其他点的容量不会随着退流而溢出。在残量网络上,剩余边不会有容量瓶颈。于是我们可以直接用独立贪心来选择。
定义损失函数为:最大费用减去次大费用。按照损失排序,依次退流即可。实现出来和上面的逻辑是一样的。
:::::
## [AGC018B Sports Festival](https://www.luogu.com.cn/problem/AT_agc018_b)
> 给出 $n\times m$ 的矩阵 $a_{i,j}$。现有长为 $m$ 的序列 $c_i$,你可以选择禁用 $c_i$ 中的若干位置。然后对 $i=1,2,\cdots,n$ 执行如下操作:
>
> 找到第一个未被禁用的位置 $a_{i,j}$,令 $c_{a_{i,j}}\gets c_{a_{i,j}}+1$。
>
> 最小化操作结束后的 $\max\limits_{i=1}^m c_i$ 并输出。
>
> $n,m\le300$,2 秒,256 MB。
:::::success[题解]
反悔贪心,整体调整。
首先,我们不禁用任何位置。这样会得到一个初始序列 $c_i$。
考虑一种调整策略:选择 $\max c_i$ 出现的位置,将其禁用,然后继续循环。这是正确的,因为不删掉这个位置,在这个位置上的元素就不会被释放。这时我们如果禁用其他位置,是没有意义的。
直接模拟复杂度即 $O(n^2 m)$ 可以通过。对行维护 set 或者链表可以优化到 $O(nm\log n)$ 到 $O(nm)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 305;
int n, m, a[N][N], cnt[N];
bool vis[N];
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cin >> a[i][j];
}
int T = m, res = 1e9;
while (T--) {
fill(cnt + 1, cnt + m + 1, 0);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!vis[a[i][j]]) {cnt[a[i][j]]++; break;}
}
}
int* p = max_element(cnt + 1, cnt + m + 1);
res = min(res, *p), vis[p - cnt] = true;
}
cout << res;
}
```
:::::
## [CF1526C2 Potions (Hard Version)](https://www.luogu.com.cn/problem/CF1526C2)
> 给出 $n$ 个整数 $a_i$。你初始持有一个数字 $x=0$,顺次经过 $i=1,2,\cdots,n$。你可以选择令 $x\gets x+a_i$ 并获得 $1$ 的得分,也可以跳过该位置。
>
> 在 $x$ 始终 $\ge0$ 的前提下,最大化得分并输出。
>
> $n\le2\times10^5$,1 秒,250 MB。
:::::success[题解]
反悔贪心,动态调整。
平凡贪心为无脑全部选上。对于 $x<0$ 的时刻做动态调整。
对于 $a_i\ge0$ 没有不选的道理。对于 $a_i<0$ 的情形,我们先加入选择中。若此选择导致 $x<0$,则找到最小的选过的负数扔掉。显然这样可以复活。
使用一个小根堆模拟,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, a[N];
priority_queue<int, vector<int>, greater<int>> q;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
i64 cur = 0, cnt = 0;
for (int i = 1; i <= n; i++) {
cur += a[i], cnt++;
if (a[i] < 0) q.emplace(a[i]);
if (cur < 0) cur -= q.top(), q.pop(), cnt--;
} cout << cnt;
}
```
:::::
## [P3545 [POI 2012] HUR-Warehouse Store](https://www.luogu.com.cn/problem/P3545)
> 你初始持有一个正整数 $x\gets0$,现有 $n$ 个时刻,第 $i$ 个时刻中首先令 $x\gets x+a_i$,然后你可以选择 $x\gets x-b_i$ 并获得 $1$ 的得分,或者不操作。要求始终有 $x\ge0$。最大化得分,并输出一组方案。
>
> $n\le2.5\times10^5$,$0\le a_i,b_i\le10^9$,1 秒,125 MB。
:::::success[题解]
反悔贪心,动态调整。
平凡贪心仍然是无脑全选。顺序扫描每个时刻,如果当前 $x<b_i$,考虑在 $[1,i)$ 所有选择中找到最大的 $b_i$ 然后反悔掉,将 $b_i$ 加入选择。若不合法则不操作。
用大根堆维护即可,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2.5e5 + 5;
int n, a[N], b[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
priority_queue<pair<i64, int>> q;
i64 cur = 0;
for (int i = 1; i <= n; i++) {
cur += a[i];
if (cur >= b[i]) {
cur -= b[i], q.emplace(b[i], i);
} else if (!q.empty() && q.top().first > b[i]) {
cur += q.top().first; q.pop();
cur -= b[i], q.emplace(b[i], i);
}
}
cout << q.size() << '\n';
while (!q.empty()) cout << q.top().second << ' ', q.pop();
}
```
:::::
:::::success[另解]
反悔贪心从时间的角度来处理,我们也可以从需求的角度来处理。
忽略所有 $b_i$,求出 $a_i$ 的前缀和 $x_i$,表示当前第 $i$ 天持有的数字。
考虑将所有需求按 $b_i$ 升序排序,能满足则一定满足。若 $b_i\ge\min\limits_{j=i}^n x_j$,则 $b_i$ 可被满足,此时对 $x_j\sim x_n$ 减去 $b_i$,然后继续扫描。
每次是一个后缀 $\min$ 后缀减法的形式,用线段树维护即可做到 $O(n\log n)$。
:::::
## [P4053 [JSOI2007] 建筑抢修](https://www.luogu.com.cn/problem/P4053)
> 给出 $n$ 个元素 $(a_i,b_i)$。你初始持有一个整数 $x=0$,每次可以选择一个没选过且 $x\le b_i$ 的元素,令 $x\gets x+a_i$ 并获得 $1$ 的得分。最大化得分并输出。
>
> $n\le1.5\times10^5$,1 秒,128 MB。
:::::success[题解]
反悔贪心,动态调整。
和上一题不同地方在于选择的顺序不定。考虑一个平凡贪心:按照紧急程度排序,即按 $b_i$ 升序排序。
钦定一个维度后,我们就可以使用和上一题相同的做法:维护一个大根堆表示已选择的元素中 $a_i$ 的最大值。若当前元素不可选择,就放弃这个选择。复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1.5e5 + 5;
int n;
struct node {
int a, b;
} a[N];
priority_queue<int> q;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].a >> a[i].b;
sort(a + 1, a + n + 1, [](const node& a, const node& b) -> bool {
return a.b < b.b;
});
i64 x = 0, res = 0;
for (int i = 1; i <= n; i++) {
x += a[i].a, q.emplace(a[i].a);
if (x <= a[i].b) res++;
else x -= q.top(), q.pop();
} cout << res;
}
```
:::::
## [CF865D Buy Low Sell High](https://www.luogu.com.cn/problem/CF865D)
> 给出 $n$ 个正整数 $a_i$,表示每支股票第 $i$ 天的价格。每天只能选择买入一支、卖出一支、不操作。允许持有多只股票,要求最终时刻手上不持有股票。最大化收益并输出。
>
> $n\le3\times10^5$,2 秒,250 MB。
:::::success[题解]
反悔贪心,动态调整,延后调整。
考虑平凡贪心:用一个小根堆维护所有买入机会,如果当前价格大于堆顶,就直接卖出这只股票。
发现这个贪心假掉的原因是,我们钦定当前位置为卖出点。但是买入的股票可能会在更后面卖掉,或者当前位置作为买入点更合适。
本题的信息具有良好的“买卖抵消”性质,因此可以使用延后调整的 trick。考虑一个下图所示的结构,箭头表示“卖出—买入”关系:

在中间点,我们再把 $a_i$ 入堆。这样我们选择第二次卖出—买入时,两次标红的决策会合并为上面标蓝的决策,就形成了正确的卖出—买入关系。
按照上述做法模拟即可,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 3e5 + 5;
int n, a[N];
priority_queue<int, vector<int>, greater<int>> q;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
i64 res = 0;
for (int i = 1; i <= n; i++) {
if (!q.empty() && q.top() < a[i]) res += a[i] - q.top(), q.pop(), q.emplace(a[i]);
q.emplace(a[i]);
} cout << res;
}
```
:::::
:::::success[另解]
考虑 DP。用 $f_{i,j}$ 表示第 $i$ 天持有 $j$ 支股票的最大收益,刷表法转移:
- 买入一支:$f_{i,j}-a_i\to f_{i,j+1}$。
- 卖出一支:$f_{i,j}+a_i\to f_{i,j-1}$。
- 不操作:$f_{i,j}\to f_{i+1,j}$。
答案为 $f_{n,0}$,复杂度 $O(n^2)$。
令序列 $g_{-1}=a_i,g_0=0,g_1=-a_i$,一次转移的本质是将 $f_i$ 与 $g$ 求 $(\max,+)$ 卷积。
显然 $g$ 具有凸性,由 Minkowski 和归纳得 $f_i$ 也是凸的。
考虑 Slope Trick 维护**斜率段**,或者说维护差分序列。对 $g$ 作一个偏移 $g_{0}=a_i,g_1=0,g_2=-a_i$,每轮卷积将 $\Delta g=[-a_i,-a_i]$ 与 $\Delta f_i$ 归并得到 $\Delta f_{i+1}$。为还原偏移还要将 $\Delta f_{i+1,0}$ 删除。
用大根堆维护 $\Delta f_i$ 并用一个变量维护 $f_{i,0}$。每轮转移中,先插入两个 $-a_i$ 并令 $f_{i,0}$ 加上 $a_i$,再令 $f_{i,0}$ 加上堆的 $\max$ 然后 pop 掉。最终的 $f_{n,0}$ 即为答案,复杂度 $O(n\log n)$。[submission](https://codeforces.com/contest/865/submission/380873333)。
:::::
## [CF730I Olympiad in Programming and Sports](https://www.luogu.com.cn/problem/CF730I)
> 给定 $n$ 个物品 $(a_i,b_i)$。你需要选择两个物品集合 $S_1,S_2$,满足 $|S_1|=k_1$,$|S_2|=k_2$,且 $S_1\cap S_2=\varnothing$。得分定义为 $\sum\limits_{i\in S_1}a_i+\sum\limits_{i\in S_2}b_i$,最大化得分并输出构造。
>
> $n\le3\times10^3$,2 秒,500 MB。
:::::success[题解]
可以从反悔贪心的角度理解,此处介绍模拟费用流的观点。
考虑二分图建模:
- 物品 $i\to S_1$,表示将 $i$ 归入 $S_1$,容量 $1$,费用 $a_i$。
- 物品 $i\to S_2$,表示将 $i$ 归入 $S_2$,容量 $1$,费用 $b_i$。
补上超级源点 $S$ 和汇点 $T$ 转化为最大费用流:
- $S\to i$,容量 $1$,费用 $0$。
- $S_1\to T$,容量 $k_1$,费用 $0$。
- $S_2\to T$,容量 $k_2$,费用 $0$。
答案即为 $S\to T$ 的最大费用最大流。
考察 EK 算法所求的增广路形态,并对应到其实际意义,可以得到如下四种决策:
- 增广路 $S\to i\to S_1\to T$,对应 $i$ 无归属,归入 $S_1$。
- 增广路 $S\to i\to S_2\to T$,对应 $i$ 无归属,归入 $S_2$。
- 增广路 $S\to i\to S_1\to j\to S_2\to T$,对应 $ i$ 归入 $S_1$,已归入 $S_1$ 的 $j$ 改为归入 $S_2$。
- 增广路 $S\to i\to S_2\to j\to S_1\to T$,对应 $ i$ 归入 $S_2$,已归入 $S_2$ 的 $j$ 改为归入 $S_1$。
四种决策必然取当前得分最大的,故使用四个大根堆维护即可。注意后两种情形维护的是差值。进行决策时分类讨论,细节见代码。
复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 3005, inf = 1e9;
int n, x, y, a[N], b[N], bel[N];
using node = pair<int, int>;
priority_queue<node> q1, q2, q3, q4;
void _main() {
cin >> n >> x >> y;
for (int i = 1; i <= n; i++) cin >> a[i], q1.emplace(a[i], i);
for (int i = 1; i <= n; i++) cin >> b[i], q2.emplace(b[i], i);
while (x > 0 || y > 0) {
while (!q1.empty() && bel[q1.top().se] != 0) q1.pop();
while (!q2.empty() && bel[q2.top().se] != 0) q2.pop();
while (!q3.empty() && bel[q3.top().se] != 1) q3.pop();
while (!q4.empty() && bel[q4.top().se] != 2) q4.pop();
int t1 = q1.empty() ? -inf : q1.top().fi, t2 = q2.empty() ? -inf : q2.top().fi,
t3 = q3.empty() ? -inf : q3.top().fi, t4 = q4.empty() ? -inf : q4.top().fi;
int h1 = x ? t1 : -inf, h2 = y ? t2 : -inf, h3 = y ? t1+t3 : -inf, h4 = x ? t2+t4 : -inf;
int h = max({h1, h2, h3, h4});
if (h == h1 || h == h3) {
int i = q1.top().se; q1.pop();
bel[i] = 1, q3.emplace(b[i] - a[i], i), x--;
if (h == h3) {
int i = q3.top().se; q3.pop();
bel[i] = 2, q4.emplace(a[i] - b[i], i), x++, y--;
}
} else {
int i = q2.top().se; q2.pop();
bel[i] = 2, q4.emplace(a[i] - b[i], i), y--;
if (h == h4) {
int i = q4.top().se; q4.pop();
bel[i] = 1, q3.emplace(b[i] - a[i], i), y++, x--;
}
}
}
int res = 0;
vector<int> u, v;
for (int i = 1; i <= n; i++) {
if (bel[i] == 1) u.emplace_back(i), res += a[i];
if (bel[i] == 2) v.emplace_back(i), res += b[i];
}
cout << res << '\n';
for (int i : u) cout << i << ' ';
cout << '\n';
for (int i : v) cout << i << ' ';
}
```
:::::
## [AT_wtf22_day1_a Save the Monsters](https://www.luogu.com.cn/problem/AT_wtf22_day1_a)
> A 和 B 进行博弈。B 拥有 $n$ 个怪兽,编号从 $1$ 到 $n$。A 的生命值为 $a$,B 的生命值为 $b$。
>
> 在接下来 $m$ 轮中,A 第 $i$ 轮可以选择以下两种行动之一:
> - 放弃操作。
>
> - 若 $a\ge1$ 且怪兽 $x_i$ 存活,则令 $a\gets a-1$ 并攻击怪兽 $x_i$。
>
>
> 若 A 选择攻击,B 可以选择以下两种行动之一:
> - 放弃操作,此时怪兽 $x_i$ 死亡。
> - 若 $b\ge1$,令 $b\gets b-1$ 并保护怪兽 $x_i$。
>
> A 和 B 都知晓所有信息,且绝顶聪明。记最终存活的怪兽数目为 $k$,A 希望最小化 $k$,B 希望最大化 $k$。求出这个 $k$。
>
> $n,m\le2.5\times10^5$,2 秒,1024 MB。
:::::success[题解]
我们站在 B 的角度思考问题。观察到一个性质:如果 B 选择保护怪兽 $i$,则在之后怪兽 $i$ 遭遇攻击的所有轮次,B 都必须保护 $i$,否则之前的保护无意义。
另一方面,A 的攻击必然有 $a-b$ 次无法防御,也即 $k$ 的上界是 $n-(a-b)$。
考虑贪心。求出怪兽 $i$ 被攻击的次数 $c_i$,按 $c_i$ 升序排序,并将 $b$ 次保护尽可能分配给 $c_i$ 较小的怪兽,容易说明正确性。
此时 A 的最优策略是将未被保护的怪兽全部击杀。容易计算此时的 $k$。
复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2.5e5 + 5;
int n, m, a, b, c[N];
void _main() {
cin >> n >> m >> a >> b;
for (int i = 1, x; i <= m; i++) cin >> x, c[x]++;
sort(c + 1, c + n + 1);
int s = 0, v = 0;
for (int i = 1; i <= n; i++, v++) {
s += c[i];
if (s > b) break;
}
cout << n - min(n - v, a - b);
}
```
:::::
## [CF2018B Speedbreaker](https://www.luogu.com.cn/problem/CF2018B)
> 数轴上有 $n$ 个点,分别为 $1,2,\cdots,n$。
>
> 在时刻 $1$,你可以选择一个起点访问。之后每个时刻,你需要选择已访问点的一个邻域进行访问。要求访问点 $i$ 的时刻不大于 $a_i$。
>
> 求出符合要求的起点数目。
>
> 多测,$\sum n\le2\times10^5$,2 秒,250 MB。
:::::success[题解]
讨论边界处的取值:
- 若 $a_1<n\land a_n<n$:无解。
- 若 $a_1\ge n\land a_n<n$:此时 $1$ 不能作为起点,而任意起点最后都能到达 $1$,故点 $1$ 对但没有影响,删去以后递归 $[2,n]$。
- 若 $a_1<n\land a_n\ge n$:同理删去 $n$ 后递归 $[1,n-1]$。
- 若 $a_1\ge n\land a_n\ge n$:判定点 $1,n$ 的合法性后递归 $[2,n-1]$。
只要判定端点处的合法性。以点 $1$ 为例,由于从端点开始必然是单向扩展,只要判断 $\forall i\in[1,n],a_i\ge i$ 是否成立,其中 $k$ 是区间外支付的代价。移项后维护 $a_i-i$ 的区间 $\min$ 即可。点 $n$ 同理维护 $a_i+i$ 的区间 $\min$。
线性 RMQ 可以 $O(n)$。代码是 $O(n\log n)$ 的。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, a[N], f[18][N], g[18][N];
int ask(int l, int r, auto&& f) {
int k = lg(r - l + 1);
return min(f[k][l], f[k][r - (1 << k) + 1]);
}
int solve(int l, int r) {
if (l > r) return 0;
if (l == r) return a[l] >= 1;
int n = r - l + 1;
if (a[l] < n && a[r] < n) return 0;
if (a[l] >= n && a[r] < n) return solve(l + 1, r);
if (a[l] < n && a[r] >= n) return solve(l, r - 1);
return solve(l + 1, r - 1) + (ask(l, r, f) >= 1 - l) + (ask(l, r, g) >= r + 1);
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
f[0][i] = a[i] - i, g[0][i] = a[i] + i;
}
for (int i = 1; (1 << i) <= n; i++)
for (int j = 1; j + (1 << i) - 1 <= n; j++) {
f[i][j] = min(f[i - 1][j], f[i - 1][j + (1 << (i - 1))]);
g[i][j] = min(g[i - 1][j], g[i - 1][j + (1 << (i - 1))]);
}
cout << solve(1, n) << '\n';
}
```
:::::
## [CF798D Mike and distribution](https://www.luogu.com.cn/problem/CF798D)
> 给出长为 $n$ 的序列 $a_i,b_i$。你需要找到一组下标 $p_1,p_2,\cdots,p_k$ 满足:
>
> $$
>2\sum_{i=1}^k a_{p_i}\le\sum_{i=1}^n a_i\\
>2\sum_{i=1}^k b_{p_i}\le\sum_{i=1}^n b_i\\
>$$
>
> 你需要保证 $k\le\left\lfloor\dfrac{n}{2}\right\rfloor+1$。
>
> $n\le10^5$,2 秒,512 MB。
:::::success[题解]
先做一步转化:选出数的和的二倍大于总和,等价于选出数之和大于未选数之和。
考虑将上述条件弱化,我们构造一种方案,使得选和不选的位置可以形成两两配对,且满足二维偏序关系 $a_i\ge a_j\land b_i\ge b_j$。
看到二维偏序,自然想到按 $a_i$ 降序排序。排序后,我们强制选择第一个元素。
此时剩下 $n-1$ 个数取 $\left\lfloor n/2\right\rfloor$ 个。我们做如下配对:$(2,3),(4,5)\cdots,(n-1,n)$,组与组之间由排序满足 $a_i$ 的约束,而 $b_i$ 的约束比较一下即可。
这样构造,后面 $n-1$ 个数的最坏情况为选出数的和等于未选数之和,加上第一个数,一定满足题目约束。
复杂度 $O(n\log n)$。
**启示:弱化题目限制;看到 $n/2$ 的构造题,考虑配对法。**
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n;
struct node {int a, b, id;} a[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].a, a[i].id = i;
for (int i = 1; i <= n; i++) cin >> a[i].b;
sort(a + 1, a + n + 1, [](const node& a, const node& b) -> bool {
return a.a > b.a;
});
cout << n / 2 + 1 << '\n' << a[1].id << ' ';
for (int i = 2; i < n; i += 2) {
if (a[i].b > a[i + 1].b) cout << a[i].id << ' ';
else cout << a[i + 1].id << ' ';
}
if (n % 2 == 0) cout << a[n].id;
}
```
:::::
:::::success[另解]
随机化,每次打乱数组,然后直接取走前 $\left\lfloor n/2\right\rfloor+1$ 个。如果不合法,就拒绝采样重新选择。
直接做就拥有 $O(n\sqrt{n})$ 的期望复杂度,可以通过本题。[复杂度证明](https://www.luogu.me/article/7qlnzfk1)。
我们还可以给随机化套上一些假贪心,尝试获得更高的正确率。
:::::
## [ARC218C Amidakuji](https://www.luogu.com.cn/problem/AT_arc218_c)
> 给出 $n$,你需要构造 $m$ 个置换,使得对于任意 $1\sim n$ 的排列 $p_i$,选择 $\le2n^2$ 个置换并应用后可以将其升序排序。要求 $m$ 取到精确下界。
>
> 采用交互方式提交。$3\le n\le500$,2 秒,1024 MB。
:::::success[题解]
我们断言 $m=2$。
构造置换 $(2,3,\cdots,n,1)$ 和 $(2,1,3,4,\cdots,n)$,前者用于循环移位,后者用于交换 $p_1,p_2$。
模拟冒泡排序的过程,不断循环移位,如果 $(1,2)$ 是逆序对就交换,那么操作次数不会超过 $1.5n^2$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 505;
int n, a[N], p[N], x[N];
void _main() {
cin >> n;
cout << 2 << '\n';
for (int i = 2; i <= n; i++) cout << i << ' ';
cout << 1 << '\n' << "2 1 ";
for (int i = 3; i <= n; i++) cout << i << ' ';
cout << endl;
for (int i = 1; i <= n; i++) cin >> a[i], p[a[i]] = i;
iota(x + 1, x + n + 1, 1);
vector<int> vec;
#define OP(x) vec.emplace_back(x)
for (int i = 1; i <= n; i++) {
for (int j = 1; j < n; j++) {
if (p[x[1]] > p[x[2]]) OP(2), swap(x[1], x[2]);
OP(1), rotate(x + 1, x + 2, x + n + 1);
}
OP(1), rotate(x + 1, x + 2, x + n + 1);
}
cout << vec.size() << ' ';
for (int i : vec) cout << i << ' ';
cout << endl;
}
```
:::::
## [CF1438D Powerful Ksenia](https://www.luogu.com.cn/problem/CF1438D)
> 给出一个长为 $n$ 的序列 $a_i$。一次操作选择三个不同下标 $i,j,k$,令 $a_i,a_j,a_k\gets a_i\oplus a_j\oplus a_k$。你需要在至多 $n$ 次操作内令 $a_i$ 全相等,输出构造或报告无解。
>
> $n\le10^5$,1 秒,250 MB。
:::::success[题解]
注意到操作一定不会改变整体异或和。于是求出 $m=\bigoplus\limits_{i=1}^n a_i$,$m$ 即为最终异或和。若 $n$ 为偶数则必有 $m=0$,否则无解。
我们尝试给出奇数情况的构造。注意到若 $a_i=a_j$,则一次操作后有 $a_i,a_j\gets a_k$,这启示我们先令 $a_n=m$ 再对 $1\sim n-1$ 顺次操作。
考虑增量维护前缀异或和。令 $i=1,3,\cdots,n-2$,对 $i,i+1,i+2$ 操作,从而让 $a_{i+2}$ 变为前缀异或和并继续传递。传递到 $a_n$ 后再返回来操作即可。
对于 $n$ 为偶数的情形,我们考虑删去 $a_n$ 转化为奇数情形。这是由于 $m=0$,也即 $a_n$ 必然与前面的数相等。
操作次数 $n-1$,复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, k, a[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], k ^= a[i];
if (n % 2 == 0 && k != 0) return cout << "NO", void();
if (n % 2 == 0) n--;
cout << "YES\n" << n - 1 << '\n';
for (int i = 1; i <= n - 2; i += 2) cout << i << ' ' << i + 1 << ' ' << i + 2 << '\n';
for (int i = 1; i <= n - 2; i += 2) cout << i << ' ' << i + 1 << ' ' << n << '\n';
}
```
:::::
## [AGC005C Tree Restoring](https://www.luogu.com.cn/problem/AT_agc005_c)
> 给出长为 $n$ 的序列 $a_i$。判断是否存在一棵无根树 $T$,使得节点 $i$ 到最远节点的路径边数为 $a_i$。
>
> $n\le100$,2 秒,512 MB。
:::::success[题解]
取出 $a_i$ 序列的 $\max$,可以说明两个 $\max$ 对应着 $T$ 的直径端点。如果 $\max$ 只有一个则不合法。
考察直径的形态:

可以发现直径从 $\max$ 到 $\min$ 展开,由对称性,每个值至少出现两次。
对于直径外的节点,考虑将这些点挂在直径上,成菊花状。容易发现这是合法的。

这就是我们的构造。考虑判定,我们的原则是用一堆必要条件拼出充分条件。
特判 $n=2$ 后,给出如下必要条件:
- $1$ 的出现次数 $\le1$。
- $a_i$ 的值域段连续。
- 从 $\max$ 到 $\min$ 的出现次数 $\ge2$。
- $\min$ 等于半径长度。
- 直径的奇偶性与半径的出现次数对应。
可以证明这些必要条件合起来是充分的。复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 105;
int n, a[N], c[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], c[a[i]]++;
sort(a + 1, a + n + 1, greater<int>());
int d = a[1];
if (c[d] < 2) return cout << "Impossible", void();
if (n == 2)
return cout << (d == 1 ? "Possible" : "Impossible"), void();
if (c[1] >= 2) return cout << "Impossible", void();
for (int i = 1; i < n; i++)
if (a[i] - a[i + 1] > 1) return cout << "Impossible", void();
for (int i = d; i > a[n]; i--)
if (c[i] < 2) return cout << "Impossible", void();
int r = (d + 1) / 2;
if (a[n] != r) return cout << "Impossible", void();
if (d % 2 == 0 && c[r] != 1) return cout << "Impossible", void();
if (d % 2 == 1 && c[r] != 2) return cout << "Impossible", void();
cout << "Possible";
}
```
:::::
## [P9820 [ICPC 2020 Shanghai R] Mine Sweeper II](https://www.luogu.com.cn/problem/P9820)
> 给出两个 $n\times m$的地图$A,B$,地图上有空地和障碍。将空地的价值定义为其周围 $8$ 个格子的障碍数目。你可以修改 $B$ 中至多 $\lfloor\frac{nm}{2}\rfloor$ 个格子,要求修改后 $A,B$ 中空地的价值和相同。输出构造。
>
> $n,m\le10^3$,1 秒,1024 MB。
:::::success[题解]
注意到将地图取反后空地价值和不变。证明考虑每一对八连通格子,取反以后贡献不变。
考虑将 $B$ 修改为 $A$ 或 $A$ 的补图。根据鸽巢原理,两者之间必有一个的修改次数 $\le\lfloor\frac{nm}{2}\rfloor$。复杂度 $O(nm)$。
**启示:遇到 $\lfloor n/2\rfloor$ 类的约束时,考虑取补图和鸽巢原理构造。**
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1005;
int n, m;
char a[N][N], b[N][N];
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> (a[i] + 1);
for (int i = 1; i <= n; i++) cin >> (b[i] + 1);
int c = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) c += (a[i][j] != b[i][j]);
if (c <= n * m / 2) {
for (int i = 1; i <= n; i++) cout << (a[i] + 1) << '\n';
} else {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << (a[i][j] == '.' ? 'X' : '.');
cout << '\n';
}
}
}
```
:::::
## [CF1450C2 Errich-Tac-Toe (Hard Version)](https://www.luogu.com.cn/problem/CF1450C2)
> 有一个 $n\times n$ 的井字棋棋盘。棋子有 `X` 和 `O` 两种类型,一方获胜当且仅当某一行或某一列中存在连续三个相同类型的棋子。
>
> 给出这个棋盘,设 $k$ 为棋子总数,你可以修改至多 $\lfloor k/3\rfloor$ 个格子,将 `X` 变为 `O` 或者将 `O` 变为 `X`。要求修改后的盘面上无人获胜。输出构造。
>
> 多测,$\sum n\le300$,1 秒,250 MB。
:::::success[题解]
仍然考虑鸽巢构造法。
我们将棋盘三染色,即按照 $(x+y)\bmod3$ 分类,如图所示:

可以发现格子被划分为 $S_0,S_1,S_2$ 三个集合。记 $X,O$ 为棋子位置的集合,若 $X\cap S_i=\varnothing\land O\cap S_j=\varnothing$ 则必然平局。
考虑枚举 $i,j$,共有 $6$ 种方案,所有方案的代价和为 $2k$。根据鸽巢原理,必然存在一种方案的代价 $\le\lfloor k/3\rfloor$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 305;
int n;
char s[N][N];
int work(int i, int j) {
int res = 0;
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++) {
if ((x + y) % 3 == i && s[x][y] == 'X') res++;
if ((x + y) % 3 == j && s[x][y] == 'O') res++;
}
return res;
}
void construct(int i, int j) {
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= n; y++) {
if ((x + y) % 3 == i && s[x][y] == 'X') cout << 'O';
else if ((x + y) % 3 == j && s[x][y] == 'O') cout << 'X';
else cout << s[x][y];
}
cout << '\n';
}
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> (s[i] + 1);
int k = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) k += (s[i][j] != '.');
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) {
if (i == j) continue;
if (work(i, j) <= k / 3) return construct(i, j), void();
}
}
```
:::::
## 2024 高联二试 A 卷 P3
> 给出一张 $3\times n$ 的网格图,每个节点染成黑或白色。找到一个连通块 $S$,使得 $S$ 中黑点和白点的数目之差不小于 $n$。
>
> 输出构造或报告无解。
:::::success[题解]
设原图中黑格的数目为 $x$,白格的数目为 $y$,则 $x+y=3n$。
考虑先取走第 $2$ 行,记该行中黑格的数目为 $x_2$,白格的数目为 $y_2$,则 $x_2+y_2=n$。不妨设 $x_2\ge y_2$。
考虑鸽巢构造法。我们给出两种策略:
- 取走第 $1,3$ 行的所有黑点。差值为 $x-y_2$。
- 取走第 $1,3$ 行的所有白点。差值为 $|y-x_2|$。
显然两种策略取走的点集是连通的。下面我们说明,两种策略中至少存在一个正确。
- 若 $y<x_2$,则由 $x_2\le n$ 得 $y<n$。
此时 $x=3n-y>2n$。
考察方案一的差值 $x-y_2>2n-n=n$,合法。
- 若 $y\ge x_2$,则方案二差值为 $y-x_2$。两式相加得 $x+y-x_2-y_2=2n$。
由鸽巢原理,$x-y_2$ 和 $y-x_2$ 中必然存在一个 $\ge n$ 的数。
复杂度 $O(n)$。
:::::
## [CF1217D Coloring Edges](https://www.luogu.com.cn/problem/CF1217D)
> 给出一个 $n$ 个点 $m$ 条边的有向图,你需要将边 $k$ 染色,使得不存在一个环同色。找到最小的 $k$ 并构造染色方案。
>
> $n,m\le5000$,1 秒,250 MB。
:::::success[题解]
使用拓扑排序判环,显然无环时 $k_{\min}=1$。
如果有环,我们断言 $k_{\min}=2$。考虑如下构造:对于边 $(u,v)$,若 $u<v$ 则染黑色,否则染白色。正确性使用反证法,即假设存在同色环,则环上点的编号递增且不会回到起点,矛盾。
复杂度 $O(n+m)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 5005;
int n, m, deg[N];
pair<int, int> a[N];
vector<int> e[N];
void _main() {
cin >> n >> m;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v, a[i] = {u, v};
e[u].emplace_back(v), deg[v]++;
}
queue<int> q;
for (int i = 1; i <= n; i++)
if (deg[i] == 0) q.emplace(i);
while (!q.empty()) {
int u = q.front(); q.pop();
for (int v : e[u])
if (--deg[v] == 0) q.emplace(v);
}
if (count(deg + 1, deg + n + 1, 0) == n) {
cout << 1 << '\n';
for (int i = 1; i <= m; i++) cout << 1 << ' ';
} else {
cout << 2 << '\n';
for (int i = 1; i <= m; i++) cout << (a[i].first < a[i].second ? 1 : 2) << ' ';
}
}
```
:::::
## [CF1485D Multiples and Power Differences](https://www.luogu.com.cn/problem/CF1485D)
> 给出一个 $n\times m$ 的矩阵 $a_{i,j}$。构造一个 $n\times m$ 的矩阵 $b_{i,j}$,满足如下条件:
>
> - $b$ 矩阵的值域为 $[1,10^6]$。
> - $b_{i,j}$ 是 $a_{i,j}$ 的倍数。
> - $b$ 矩阵中相邻两数之差都能表示成 $k^4$ 的形式。
>
> 输出构造。
>
> $n,m\le500$,$1\le a_{i,j}\le\textcolor{red}{16}$,2 秒,250 MB。
:::::success[题解]
注意到 $\operatorname{lcm}(1,2,\cdots,16)=720720<10^6$。
记 $k=720720$,考虑按如下形式构造:
- 若 $i+j\equiv1\pmod2$,则 $b_{i,j}=k$。
- 否则,$b_{i,j}=k-a_{i,j}^4$。
注意验证其满足条件。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 505;
int n, m, a[N][N];
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
const int k = 720720;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if ((i + j) & 1) cout << k << ' ';
else cout << k - a[i][j]*a[i][j]*a[i][j]*a[i][j] << ' ';
} cout << '\n';
}
}
```
:::::
## [CF1684E MEX vs DIFF](https://www.luogu.com.cn/problem/CF1684E)
> 给出长为 $n$ 的序列 $a_i$。你可以进行至多 $k$ 次操作:选择一个 $i$ 并将 $a_i$ 改为任意非负整数。最大化操作结束后 $\text{diff}-\text{mex}$ 的值并输出。其中 $\text{diff}$ 表示 $a_i$ 中出现的数的数目。
>
> 多测,$\sum n\le10^5$,2 秒,250 MB。
:::::success[题解]
记当前的 $\text{diff}=D,\text{mex}=M$。
考虑极端情况 $k=n$,此时将 $a_i$ 改成 $[0,1,\cdots,n-1]$ 时 $D=M=n$,答案为 $0$。这启示我们将序列改成 $0,1,2,\cdots$ 更优。
容易说明这个方法的正确性,因为一次修改必然使得 $M\gets M+1$,$D$ 至多增加 $1$。因此我们先通过模拟求出最终的 $M$。
将 $M$ 确定后,剩余操作应当用于最小化 $D$。贪心地,将 $>M$ 的数按其出现次数升序排序,然后取较小的数操作即可。
复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
int n, k;
umap<int, int> mp;
void _main() {
cin >> n >> k, mp.clear();
for (int i = 1, x; i <= n; i++) cin >> x, mp[x]++;
int m = 0, c = 0;
while (mp.find(m) != mp.end() || c < k) {
if (mp.find(m) == mp.end()) c++;
m++;
}
vector<int> vec;
for (auto [v, c] : mp) if (v > m) vec.emplace_back(c);
sort(vec.begin(), vec.end());
int res = vec.size();
for (int c : vec) {
if (k < c) break;
k -= c, res--;
}
cout << res << '\n';
}
```
:::::
## [P2168 [NOI2015] 荷马史诗](https://www.luogu.com.cn/problem/P2168)
> 现有 $n$ 个字符串,第 $i$ 个字符串的长度为 $w_i$。你需要找到一种字符集为 $\{1,2,\cdots,k\}$ 的编码,使得编码后不存在一个编码是另一个的前缀,且编码总长度最小,在此基础上最小化最长编码的长度。求出最小总长度和最长编码长度。
>
> $n\le10^5$,$k\le9$,$1\le w_i\le10^{11}$,1 秒,125 MB。
:::::success[题解]
考虑建 $k$ 叉 Huffman 树。注意建树时要补叶子使得 $(k-1)\mid(n-1)$。
由于本题要求最长编码最短,在优先队列中应当记录下 $(w,d)$ 二元组,分别表示点权和深度。对于权值相同的点,优先考虑深度最小的点合并。
这样编码就是 Huffman 树上的根链。复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 1e5 + 5;
using node = pair<int, int>;
int n, k;
priority_queue<node, vector<node>, greater<node>> q;
void _main() {
cin >> n >> k;
for (int i = 1, x; i <= n; i++) cin >> x, q.emplace(x, 0);
int len = 0, mx = 0;
while ((n - 1) % (k - 1)) q.emplace(0, 0), n++;
while (!q.empty()) {
int w = 0, d = 0;
for (int i = 1; i <= k; i++) {
if (q.empty()) return cout << len << '\n' << mx + 1, void();
auto [w1, d1] = q.top(); q.pop();
w += w1, chkmax(d, d1);
}
len += w, chkmax(mx, d), q.emplace(w, d + 1);
}
cout << len << '\n' << mx + 1;
}
```
:::::
## [ARC216A Reversi 3](https://www.luogu.com.cn/problem/AT_arc216_a)
> 给出长为 $n$ 的 01 串 $a_i$ 和 $b_i$。一次操作选择一个下标 $2\le i<n$,满足 $a_{i-1}=a_{i+1}$,然后翻转 $a_i$。最小化将 $a_i$ 变为 $b_i$ 的操作次数并输出,或报告无解。
>
> 多测,$\sum n\le10^6$,2 秒,1024 MB。
:::::success[题解]
显然 $a_1$ 和 $a_n$ 不会被变换,故 $a_1\ne b_1\lor a_n\ne b_n$ 直接无解。
对于第 $i$ 个位置,我们记录 $x_i$ 表示 $a_i,a_{i-1}$ 是否相同,即令 $x_i=a_i\oplus a_{i-1}$,做一个异或差分。当选定下标 $i$ 时:
- 操作条件 $a_{i-1}=a_{i+1}\iff x_i=x_{i-1}$;
- 翻转 $a_i$ 后,$x_i,x_{i-1}$ 同时翻转。
- 因此,对 $x$ 的操作描述为:将两个相邻元素翻转,如即`11` 变 `00`,`00` 变 `11`。
这么做还是不直观。根据经典 trick 将奇数位取反,即 $x_i\gets x_i\oplus(i\bmod2)$,则相邻同项取反化为交换相邻 01。
上述变换也应用在 $b_i$ 上得到 $y_i$。若 $x_i,y_i$ 中 `1` 的数目不同则无解。否则为简单贪心。根据绝对值四边形不等式 $a<b<c<d\implies|a-b|+|c-d|<|a-c|+|b-d|$,从左侧开始逐一匹配 $x_i,y_i$ 中的 1 即为最优。
复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e6 + 5;
int n, x[N], y[N];
string a, b;
void _main() {
cin >> n >> a >> b, a = ' ' + a, b = ' ' + b;
if (a[1] != b[1] || a[n] != b[n]) return cout << -1 << '\n', void();
x[1] = 1, y[1] = 1;
for (int i = 2; i <= n; i++) x[i] = a[i] ^ a[i - 1];
for (int i = 1; i <= n; i += 2) x[i] ^= 1;
for (int i = 2; i <= n; i++) y[i] = b[i] ^ b[i - 1];
for (int i = 1; i <= n; i += 2) y[i] ^= 1;
vector<int> p, q;
for (int i = 1; i <= n; i++) if (x[i] == 1) p.emplace_back(i);
for (int i = 1; i <= n; i++) if (y[i] == 1) q.emplace_back(i);
if (p.size() != q.size()) return cout << -1 << '\n', void();
i64 res = 0;
for (int i = 0; i < (int)p.size(); i++) res += abs(p[i] - q[i]);
cout << res << '\n';
}
```
:::::
:::::success[另解]
考虑构造掩码序列 $m_i$,使得 $a_i\gets a_i\oplus m_i$ 后 $a_{i-1}=a_{i+1}$。
根据要求有 $\forall i,m_{i-1}\ne m_{i+1}$。取 $m=[0,0,1,1,0,0,1,1,\cdots]$ 满足要求。
因此将 $i\bmod4\in\{3,0\}$ 的位置取反后,问题转化为 [CF1705D](https://www.luogu.com.cn/problem/CF1705D)。
我们可以构造异或差分,或者直接解决这个问题。考虑到操作的本质是伸长一个极长颜色段,且禁止颜色段合并,只需求出所有颜色段,将分界点升序匹配即最优。
:::::
## [CF2048E Kevin and Bipartite Graph](https://www.luogu.com.cn/problem/CF2048E)
> 现有一个左部 $2n$ 个点,右部 $m$ 个点的完全二分图。你需要给每条边染 $[1,n]$ 中的一种颜色,使得二分图中不存在单色环。输出方案或报告无解。
>
> 多测,$\sum n,\sum m\le10^3$,2 秒,250 MB。
:::::success[题解]
每种颜色的导出子图构成一个森林,至多存在 $2n+m-1$ 条边,于是有解的必要条件为 $(2n+m-1)n\le2nm$,解得 $m\le2n-1$。
对于 $m=2n-1$ 断言有解,则 $m$ 更小时套用此构造即可。考虑如下构造:将边 $(i,j)$ 染色为 $\lfloor\frac{(i+j)\bmod2n}{2}\rfloor+1$。可以证明方案中没有单色环:
对于颜色 $c$,边 $(i,j)$ 染色为 $c$ 当且仅当 $(i+j)\bmod2n\in\{2c-2,2c-1\}$,则对于右部点 $j$,其在颜色 $c$ 的导出子图中恰好连接两个左部点 $i_1,i_2$,且 $i_2-i_1\equiv1\pmod{2n}$。
因此,所有 $m$ 个右部点提供的连边在左部点上形成的是一条长度为 $m$ 的链,必然无法成环。证毕。
:::::
:::::info[代码]
```cpp line-numbers
int n, m;
void _main() {
cin >> n >> m;
if (m > 2 * n - 1) return cout << "No\n", void();
cout << "Yes\n";
for (int i = 1; i <= 2 * n; i++) {
for (int j = 1; j <= m; j++) {
cout << (i + j) % (2 * n) / 2 + 1 << ' ';
} cout << '\n';
}
}
```
:::::
## [P12741 [POI 2016 R3] 等价程序 Equivalent programs](https://www.luogu.com.cn/problem/P12741)
> 给出两个长为 $n$ 值域为 $[1,k]$ 的序列 $a_i,b_i$。再给出 $m$ 个二元组 $(u,v)$,表示值 $u,v$ 之间不能交换。问 $a_i$ 是否可以通过任意次交换相邻两项的操作变成 $b_i$。
>
> $n\le10^5,k\le10^3,m\le5\times10^4$,4 秒,128 MB。
:::::success[题解]
先判掉 $a_i,b_i$ 构成的多重集不同的情况。
考虑顺序扫描 $i=1,2,\cdots,n$,将 $b_i$ 对应的值交换到 $a_i$ 上。直觉告诉我们,选择最近的 $b_i$ 交换过来不劣。
原因是如果过程中不合法,那么选择一个更远的 $b_i$ 也会不合法。如果是为了之后合法,那么在 $i$ 之后的决策中也可以做到这一点。
根据这个贪心,我们就有 $O(n^2)$ 的简单做法,找到最近的 $b_i$ 交换到 $a_i$ 上,直接模拟判定是否合法。
注意到,元素 $b_i$ 能够被移动到最前面,当且仅当它能够跨过之前所有未匹配的元素。因此,考虑维护每个值的出现位置,和当前最小的未匹配下标,判合法直接枚举值进行判断,复杂度就是 $O(nk)$ 的。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5, M = 1e3 + 5;
int n, k, m, a[N], b[N], a0[N], b0[N], h[M];
vector<int> e[M], pos[M];
void _main() {
cin >> n >> k >> m;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
e[u].emplace_back(v), e[v].emplace_back(u);
}
for (int i = 1; i <= n; i++) cin >> a[i], a0[i] = a[i];
for (int i = 1; i <= n; i++) cin >> b[i], b0[i] = b[i];
sort(a0 + 1, a0 + n + 1), sort(b0 + 1, b0 + n + 1);
for (int i = 1; i <= n; i++)
if (a0[i] != b0[i]) return cout << "NIE", void();
for (int i = 1; i <= n; i++) pos[a[i]].emplace_back(i);
for (int i = 1; i <= n; i++) {
if (h[b[i]] >= (int)pos[b[i]].size()) return cout << "NIE", void();
int p = pos[b[i]][h[b[i]]];
for (int v : e[b[i]])
if (h[v] < (int)pos[v].size() && pos[v][h[v]] < p) return cout << "NIE", void();
h[b[i]]++;
}
cout << "TAK";
}
```
:::::
## [P2587 [ZJOI2008] 泡泡堂](https://www.luogu.com.cn/problem/P2587)
> 给出长为 $n$ 的序列 $a_i,b_i$。你需要将 $a_i,b_j$ 两两配对,当 $a_i>b_j$ 时产生 $2$ 的得分,$a_i=b_j$ 时产生 $1$ 的得分。求出你能得到的最大得分和最小得分。
>
> $n\le10^5$,1 秒,125 MB。
:::::success[题解]
最小得分交换 $a,b$ 后用 $2n$ 减去最大得分即得。下文只讨论最大化得分的做法。
我们维护未配对的元素集合 $A,B$,则执行如下贪心策略:
1. 若 $\max A>\max B$:配对 $(\max A,\max B)$ 并产生 $2$ 的得分;
2. 若 $\min A>\min B$:配对 $(\min A,\min B)$ 并产生 $2$ 的得分;
3. 若都不满足,配对 $(\min A,\max B)$ 并产生 $1$ 或 $0$ 的得分。
可以说明正确性:在情况 3 中,如果继续平凡策略,最大最小值在最好情况下只能产生 $1$ 的得分。用 $\min A$ 配对 $\max B$ 后,$\max A$ 就可以产生 $2$ 的得分,若 $\max A$ 与对方相等则可以产生两个相等。故策略 3 总是不劣。
排序后两个双端队列维护,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, a[N], b[N];
int solve(int *a, int *b) {
deque<int> x(a + 1, a + n + 1), y(b + 1, b + n + 1);
int res = 0;
while (!x.empty()) {
if (x.back() > y.back()) res += 2, x.pop_back(), y.pop_back();
else if (x.front() > y.front()) res += 2, x.pop_front(), y.pop_front();
else res += (x.front() == y.back()), x.pop_front(), y.pop_back();
} return res;
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
sort(a + 1, a + n + 1), sort(b + 1, b + n + 1);
cout << solve(a, b) << ' ' << 2 * n - solve(b, a);
}
```
:::::
## [P14507 缺零分治 mexdnc](https://www.luogu.com.cn/problem/P14507)
> 给出 $n$ 个二元组 $(a_i,b_i)$,表示现有 $b_i$ 个数字 $a_i$,保证 $a_i$ 严格递增。$q$ 次询问给出 $x$,你需要将这 $\sum\limits_{i=1}^n b_i$ 划分为 $k$ 个可重集,使得这些集合的 $\operatorname{mex}$ 之和恰为 $x$,求出 $k$ 的最小值或报告无解。
>
> 多测,$T\le10$,$n,q\le10^5$,$1\le b_i\le10^9$,2 秒,512 MB。
:::::success[题解]
观察性质起手:若 $a_i\ne i-1$,则 $[i,n]$ 的整段后缀都无用,可以直接舍去。下文的 $n$ 省去这段后缀。
贪心地,将集合都划分为 $\{0,1,2,\cdots,u_i\}$ 这样的连续自然数,可以最大化 $\operatorname{mex}$ 之和。故 $x$ 的上界为 $\sum(u_i+1)$。
将 $u_i$ 降序排序后,问题变为找到最小的 $k$,使得 $\sum\limits_{i=1}^k(u_i+1)\ge x$。显然可以二分 $k$。
这里 $u_i$ 的数目很多,无法直接模拟。但是我们可以一次扫描求出 $c_i$ 表示可以达到 $\operatorname{mex}(S)\ge i+1$ 的 $S$ 数目。
判定时,找到 $c_i$ 中第一个 $\ge k$ 的位置 $p$,则 $\sum\limits_{i=1}^k(u_i+1)=p\times k+\sum\limits_{i=p+1}^n c_i$,对 $c$ 预处理后缀和即可。
注意若干 corner case:
- $a_1\ne0$ 时,有解当且仅当 $x=0$;
- 若 $x\notin\left[1,\sum\limits_{i=1}^n c_i\right]$,则无解;
- 若 $x=n$,此时划成一段最优,答案为 $1$;
- 若 $x\in[1,n)$,此时答案为 $2$。
视 $n,q$ 同阶,总体复杂度 $O(Tn\log n\log V)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 1e5 + 5;
int n, q, m, a[N], b[N], c[N], suf[N];
int ask(int x) {
if (a[1] != 0) return x ? -1 : 1;
if (x > suf[1] || x == 0) return -1;
if (x == m) return 1;
if (x < m) return 2;
auto chk = [&](int k) -> int {
int p = upper_bound(c + 1, c + m + 1, k, greater<int>()) - c - 1;
return p * k + suf[p + 1];
};
int l = 2, r = suf[1], res = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (chk(mid) >= x) r = mid - 1, res = mid;
else l = mid + 1;
} return res;
}
void _main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i];
int cur = 2e18;
for (int i = 1; i <= n; i++) {
if (a[i] != i - 1) break;
chkmin(cur, b[i]), c[i] = cur, m = i;
}
suf[m + 1] = 0;
for (int i = m; i >= 1; i--) suf[i] = suf[i + 1] + c[i];
for (int x; q--; ) cin >> x, cout << ask(x) << '\n';
}
```
:::::
## [CF1129B Wrong Answer](https://www.luogu.com.cn/problem/CF1129B)
> 考虑如下问题:给出长为 $n$ 的序列 $a_i$,求 $\max\limits_{1\le l\le r\le n}\sum\limits_{i=l}^r(r-l+1)a_i$。这里 $1\le n\le2000$,$|a_i|\le10^6$。
>
> 给出一种错误的贪心,伪代码如下:
>
> ```python line-numbers
> function find_answer(n, a)
> # 假设 n 是 1 到 2000 之间的整数
> # 假设 a 是一个包含 n 个整数的列表:a[0], a[1], ..., a[n-1]
> res = 0
> cur = 0
> k = -1
> for i = 0 to i = n-1
> cur = cur + a[i]
> if cur < 0
> cur = 0
> k = i
> res = max(res, (i-k)*cur)
> return res
> ```
>
> 你需要构造一个序列 $a_i$,使得正确答案与错误答案恰好相差 $k$。
>
> $1\le k\le10^9$,1 秒,250 MB。
:::::success[题解]
考虑序列 $a=[0,0,\cdots,0,-a,a+b]$,其中 $a>0$。则错误答案为 $a+b$,正确答案为 $n\times b$,列方程 $(n-1)b-a=k$。
可以用 exGCD 一类的方法解。但是值域很小,直接枚举 $b$ 也可以通过。复杂度 $O(V)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int n = 2000, lim = 1e6;
int k;
void _main() {
cin >> k;
for (int b = -lim; b <= lim; b++) {
int a = (n - 1) * b - k;
if (a <= 0 || abs(a) > lim || abs(a + b) > lim) continue;
cout << n << '\n';
for (int i = 1; i <= n - 2; i++) cout << 0 << ' ';
cout << -a << ' ' << a + b;
return;
}
}
```
:::::
## [CF468C Hack it!](https://www.luogu.com.cn/problem/CF468C)
> 定义 $f(x)$ 为 $x$ 的十进制数码之和。
>
> 给出 $a$,构造 $l,r$ 使得 $\sum\limits_{i=l}^r f(i)\equiv0\pmod a$。要求 $1\le l\le r\le\textcolor{red}{10^{200}}$。
>
> $1\le a\le10^{18}$,1 秒,250 MB。
:::::success[题解]
观察取 $l=1,r=10^{m}$ 时的情形,设此时的 $\sum f(i)$ 为 $g(l,r)$。
考虑令 $l\gets l+1,r\gets r+1$。此时 $r$ 形如 $\tt{100\cdots01}$,有 $g\gets g+1$。故我们可以通过微调 $l,r$ 改变 $g$ 的取值。
那么只要取充分大的 $m$,将 $g$ 调整到 $a$ 的倍数即可。取 $m=18$,则
$$
\begin{aligned}
g(1,10^{18})&=\sum_{i=1}^{10^{18}}f(i)\\
&=18\dfrac{10^{18}}{10}\sum_{d=0}^9 d+f(10^{18})\\
&=45\times18\times10^{17}+1\\
&=81\times10^{18}+1
\end{aligned}
$$
记 $b=(81\times10^{18}+1)\bmod a$,只要调整 $a-b$ 次,故取 $l=a-b+1,r=10^{18}+a-b$ 即可。
:::::
:::::info[代码]
```cpp line-numbers
const i128 g = 8.1e19, m = 1e18;
i128 a;
void _main() {
cin >> a;
i128 b = (g + 1) % a;
cout << a - b + 1 << ' ' << m + a - b;
}
```
:::::
## [CF1179B Tolik and His Uncle](https://www.luogu.com.cn/problem/CF1179B)
> 现有一个 $n\times m$ 的网格,你需要从 $(1,1)$ 开始游走,恰好访问每个格子一次,并且任意两步间行走的向量不同。构造方案或报告无解。
>
> $nm\le10^6$,1 秒,250 MB。
:::::success[题解]
不妨先考虑一维的情形,一种简单的构造为 $1\to m\to2\to m-1\to\cdots$,即在首尾反复横跳,如下图:

于是我们考虑二维时,在左上角和右下角反复横跳。具体地,给出如下构造流程:
- 行配对:将行 $(1,n),(2,n-1),\cdots$ 两两配对,则两对之间的 $x$ 不会冲突;
- 组内配对:对于组 $(x_1,x_2)$,从左上角开始到右下角反复横跳,即 $(x_1,1)\to(x_2,m)\to(x_1,2)\to(x_2,m-1)\cdots$。
特别地,若 $n$ 为奇数,使用上面提到的一维策略即可。复杂度 $O(nm)$。
:::::
:::::info[代码]
```cpp line-numbers
int n, m;
void _main() {
cin >> n >> m;
int x1 = 1, x2 = n;
for (; x1 < x2; x1++, x2--) {
for (int y = 1; y <= m; y++) {
cout << x1 << ' ' << y << '\n';
cout << x2 << ' ' << m - y + 1 << '\n';
}
}
if (x1 == x2) {
int y1 = 1, y2 = m;
for (; y1 < y2; y1++, y2--) {
cout << x1 << ' ' << y1 << '\n';
cout << x1 << ' ' << y2 << '\n';
}
if (y1 == y2) cout << x1 << ' ' << y1;
}
}
```
:::::
## [QOJ4217 Graph Coloring](https://qoj.ac/problem/4217)
> 给出一个 $n$ 个点的竞赛图。你需要将每条边染色,使得对于任意 $u\to v\to w$,$u\to v$ 的颜色与 $v\to w$ 不同。构造方案并输出。
>
> $n\le3000$,要求颜色种类数 $\le14$,1 秒,512 MB。
:::::success[题解]
根据 [CF1365G](https://www.luogu.com.cn/problem/CF1365G) 的 trick,我们可以钦定 $\operatorname{popcount}$ 来进行编码。对于本题,注意到 $\binom{14}{7}>3000$,于是将 $\operatorname{popcount}=7$ 且长为 $14$ 的二进制数作为节点的编码。
对于边 $u\to v$,必然存在一个 bit 位,使得 $u$ 编码的这一位为 $1$,且 $v$ 编码的这一位为 $0$,将这个位分配作为边的颜色即可。
使用一些位运算技巧加速计算,复杂度 $O(2^k+n^2)$,其中 $k\le14$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 3005;
int n, a[N];
void _main() {
cin >> n;
int cnt = 0;
for (int s = 0; s < (1 << 14) && cnt < n; s++) {
if (popcount(s) == 7) a[++cnt] = s;
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j < i; j++) {
char c; cin >> c;
if (c == '0') cout << (char) (ctz(a[i] & ~a[j]) + 'a');
else cout << (char) (ctz(a[j] & ~a[i]) + 'a');
}
cout << '\n';
}
}
```
:::::
## [CF2178D Xmas or Hysteria](https://www.luogu.com.cn/problem/CF2178D)
> 现有 $n$ 个玩家,玩家 $i$ 的攻击力为 $a_i$,生命值为 $b_i$。初始 $b_i=a_i$。一次操作选择玩家 $i,j$,满足 $b_i>0\land b_j>0$ 且玩家 $i$ 没有发起过攻击,然后令 $i$ 攻击 $j$,使得 $b_j\gets b_j-a_i$,$b_i\gets b_i-a_j$。操作反复进行至无法继续操作。
>
> 构造一组操作序列,使得最终 $b_i>0$ 的玩家恰有 $m$ 人,或报告无解。
>
> 多测,$\sum n\le2\times10^5$,2 秒,500 MB。
:::::success[题解]
不妨先按 $a_i$ 升序排序,然后令 $a_i$ 最大的 $m$ 个玩家存活。
由于存活的玩家必须进行过攻击,因此有解的必要条件为 $2m>n$。若 $2m\le n$ 考虑如下分组:
- 第 $1\sim n-2m$ 名玩家:令 $i$ 攻击 $i+1$ 送死,这部分全部打死;
- 第 $n-2m+1\sim n-m$ 名玩家:令 $n-m+i$ 攻击 $n-2m+i$,则这部分玩家全部死亡;
- 第 $n-m+1\sim n$ 玩家:这部分玩家全部存活,且在上面已经攻击过。
注意到 $m=0$ 时上述策略无法成立。继续进行讨论:
- 若 $\sum\limits_{i=1}^{n-1}a_i<a_n$,则一定打不死 $n$,无解;
- 反之断言有解,考虑如下构造:
- 从 $1$ 开始不断攻击 $n$,直到下一次攻击会杀死 $n$ 时,停止攻击;
- 从停止的位置开始,令 $i$ 攻击 $i+1$ 送死;
- 最终状态仅剩 $n-1$ 和 $n$,此时令 $n-1$ 攻击 $n$ 必然可以杀死 $n$。
模拟上述流程即可,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 2e5 + 5;
int n, m;
struct node {int id, v;} a[N];
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i].v, a[i].id = i;
sort(a + 1, a + n + 1, [](const node& a, const node& b) -> bool {
return a.v < b.v;
});
vector<pair<int, int>> vec;
if (m == 0) {
int sum = 0, tar = a[n].v;
for (int i = 1; i < n; i++) sum += a[i].v;
if (sum < tar) return cout << -1 << '\n', void();
int i = 1;
for (; i < n; i++) {
if (tar < a[n - 1].v) break;
tar -= a[i].v, vec.emplace_back(a[i].id, a[n].id);
}
for (; i < n; i++) vec.emplace_back(a[i].id, a[i + 1].id);
} else {
if (2 * m > n) return cout << -1 << '\n', void();
for (int i = 1; i <= n - 2 * m; i++) vec.emplace_back(a[i].id, a[i + 1].id);
for (int i = 1; i <= m; i++) vec.emplace_back(a[n - m + i].id, a[n - 2 * m + i].id);
}
cout << vec.size() << '\n';
for (auto& i : vec) cout << i << '\n';
}
```
:::::
## [ABC454E LRUD Moving](https://www.luogu.com.cn/problem/AT_abc454_e)
> 现有一个 $n\times n$ 的网格。你需要从 $(1,1)$ 开始游走,不重不漏地经过除 $(x,y)$ 以外的格子恰好一次,到达 $(n,n)$。输出构造或报告无解。
>
> 多测,$\sum n^2\le10^6$,2 秒,1024 MB。
:::::success[题解]
先考虑怎么判无解。
将网格黑白染色,若 $(x_i+y_i)\bmod2=0$ 染成黑色,否则染成白色。那么起终点都是黑色,且每次移动切换颜色,故合法路径中,黑色格子必须恰好比白色格子多 $1$ 个。
于是有解的第一个必要条件是 $(n^2-1)\bmod2=1\iff n\bmod2=0$。
下面默认 $n$ 为偶数,则黑白格都有 $\frac{n^2}{2}$ 个。路径恰好需要走过 $\frac{n^2}{2}$ 个黑格和 $\frac{n^2}{2}-1$ 个白格,因此 $(x,y)$ 必然为白格,也即 $(x+y)\bmod2=1$ 是有解的第二个必要条件。
判掉两个无解条件后断言有解,下面给出构造式证明。
注意到下面这种走法:

通过走一个折线,可以删去上面两行,从而把问题规约为 $(n-2)\times n$ 的子问题。那么同理也可以删去左边两列。
考虑禁入点如果在绿区就炸了。但是仔细思考一下,操作是可逆的,我们也可以视为删去右边两列 / 下面两行,只是操作序列的添加顺序不同。
这样就可以归纳构造了。每次分治下去,一定有一种删行列的方案是合法的,最终 $2\times2$ 的情形特判。黑白染色后 $2\times2$ 一定有解。
复杂度 $O(n^2)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e6 + 5;
int n, x, y;
string s;
bool check(int x1, int x2, int y1, int y2) {
return x1 <= x && x <= x2 && y1 <= y && y <= y2;
}
void solve(int x1, int x2, int y1, int y2) {
if (x2 - x1 == 1 && y2 - y1 == 1) {
if (x == x1 && y == y2) s += "DR";
else s += "RD";
return;
}
if (x1 + 1 < x2 - 1 && !check(x1, x1 + 1, y1, y2)) {
s += string(y2 - y1, 'R') + 'D' + string(y2 - y1, 'L') + 'D';
solve(x1 + 2, x2, y1, y2);
} else if (x1 + 1 < x2 - 1 && !check(x2 - 1, x2, y1, y2)) {
solve(x1, x2 - 2, y1, y2);
s += 'D' + string(y2 - y1, 'L') + 'D' + string(y2 - y1, 'R');
} else if (y1 + 1 < y2 - 1 && !check(x1, x2, y1, y1 + 1)) {
s += string(x2 - x1, 'D') + 'R' + string(x2 - x1, 'U') + 'R';
solve(x1, x2, y1 + 2, y2);
} else {
solve(x1, x2, y1, y2 - 2);
s += 'R' + string(x2 - x1, 'U') + 'R' + string(x2 - x1, 'D');
}
}
void _main() {
cin >> n >> x >> y;
if (n & 1) return cout << "No\n", void();
if ((x + y) % 2 == 0) return cout << "No\n", void();
cout << "Yes\n";
s.clear(), solve(1, n, 1, n);
cout << s << '\n';
}
```
:::::
## [CF351E Jeff and Permutation](https://www.luogu.com.cn/problem/CF351E)
> 给出一个长为 $n$ 的序列 $a_i$。你可以任意将序列中的数字变为其相反数,最小化逆序对数并输出。
>
> $n\le2000$,1 秒,250 MB。
:::::success[题解]
本题的关键在于发现性质:在任意两个绝对值不等的数之间,是否构成逆序对,仅取决于绝对值较大的数的符号。
假设有两个数 $x$ 和 $y$,满足 $|x|>|y|$。
- 若令 $x\gets|x|$,那么无论 $y$ 是正是负,必有 $x>y$。如果 $x$ 出现在 $y$ 前,就会形成逆序对。
- 若令 $x\gets-|x|$,那么无论 $y$ 是正是负,必有 $x<y$。如果 $x$ 出现在 $y$ 后,就会形成逆序对。
因此,对于每个 $|a_i|$,我们只需考虑绝对值严格小于它的元素构成的逆序对。
我们分别统计在它左侧,且绝对值严格小于它的元素数目。若 $a_i$ 为负,就会产生 $x$ 个逆序对。用类似的方法统计右侧,可以求出 $a_i$ 为正时产生的逆序对数 $y$。
答案加上 $\min(x,y)$ 即可。不过这里有一个细节:绝对值相等的元素是否对逆序对有贡献。
考虑从左到右遍历相等元素时,$x$ 单调增,$y$ 单调减,故相等元素的符号分配形如 `...---+++...` 这样的结构,一定不会产生逆序对。
复杂度 $O(n^2)$,容易用离散化 & 权值树状数组优化到 $O(n\log n)$。
通过巧妙的性质将逆序对数的贡献独立,用简单的遍历计算两侧贡献,好题。
:::::
:::::info[题解]
```cpp line-numbers
const int N = 2005;
int n, a[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], a[i] = abs(a[i]);
int res = 0;
for (int i = 1; i <= n; i++) {
int x = 0, y = 0;
for (int j = 1; j < i; j++) x += a[j] < a[i];
for (int j = i + 1; j <= n; j++) y += a[j] < a[i];
res += min(x, y);
} cout << res;
}
```
:::::
:::::success[另解]
注意到每个数只有两种选择,考虑网络流集合划分模型。
记下标 $i,j$ 有 $a_i<a_j$,设超级源点 $S$,汇点 $T$,有:
- $|a_i|>|a_j|$,连边 $i\to T$,容量为 $1$,表示 $a_i$ 取正。
- $|a_i|<|a_j|$,连边 $S\to j$,容量为 $1$,表示 $a_j$ 取负。
- $|a_i|=|a_j|$,连边 $i\to j$,容量为 $1$,表示 $a_i$ 取正且 $a_j$ 取负。
求出最小割即为答案。跑 Dinic 理论复杂度 $O(n^4)$,跑 HLPP 理论复杂度 $O(n^3)$。
可以用 CDQ 分治优化建图,此时 Dinic 理论复杂度 $O(n^3\log n)$,HLPP 理论复杂度 $O(n^2\sqrt{n\log n})$。
实际上,朴素的 Dinic 实现即可通过。
:::::
## [CF1866G Grouped Carriages](https://www.luogu.com.cn/problem/CF1866G)
> 给出 $n$ 个元素 $a_i$ 和 $d_i$,表示在第 $i$ 个位置有 $a_i$ 个物品。物品可以随意移动,但初始在 $i$ 的物品最多移动 $d_i$ 次。最小化移动后的最大物品数并输出。
>
> $n\le2\times10^5$,3 秒,500 MB。
:::::success[题解]
不难发现每个物品可达的位置是一段区间,将区间处理处理以后可以将这些信息挂到左端点上。
题目要求最小化最大,考虑二分答案 $x$,接下来贪心判定 $x$ 是否合法。
不妨视为逐个位置分配物品,那么问题就是一个区间调度问题。我们顺次扫描每个位置,并且将所有区间按右端点排序,优先安排截止位置较小的。
可以用一个堆来维护右端点较小的区间。总复杂度 $O(n\log n\log V)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 2e5 + 5;
int n, a[N], d[N];
struct node {
int r, c;
node(int x = 0, int y = 0) : r(x), c(y) {}
bool operator< (const node& a) const {return r > a.r;}
};
vector<node> p[N];
bool check(int x) {
priority_queue<node> q;
for (int i = 1; i <= n; i++) {
for (auto& u : p[i]) q.emplace(u);
int cur = x;
while (!q.empty() && cur > 0) {
auto [r, c] = q.top(); q.pop();
if (c <= cur) cur -= c;
else c -= cur, cur = 0, q.emplace(r, c);
}
if (!q.empty() && q.top().r <= i) return false;
} return q.empty();
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> d[i];
for (int i = 1; i <= n; i++) {
if (a[i] == 0) continue;
int l = max(1LL, i - d[i]), r = min(n, i + d[i]);
p[l].emplace_back(r, a[i]);
}
int l = 0, r = 1e18, res = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) res = mid, r = mid - 1;
else l = mid + 1;
} cout << res;
}
```
:::::
## [CF1951E No Palindromes](https://www.luogu.com.cn/problem/CF1951E)
> 给出一个长为 $n$ 的字符串 $S$,你需要将 $S$ 不重不漏地划分为若干子串,使得每个子串都不是回文的。
>
> 输出构造或报告无解。
>
> 多测,$\sum n\le10^6$,字符集为 $\tt{a}\sim\tt{z}$,2 秒,250 MB。
:::::success[题解]
先判掉 $S$ 自身非回文的情形,此时直接将整体作为构造。
否则,我们断言,若有解,则必然存在划分段数 $k\le2$ 的解。
::::success[证明]{open}
考察一个 $k=3$ 的解 $A,B,C$,其中 $A,B,C$ 都不是回文串。
若 $AB$ 非回文,可将 $AB$ 和 $C$ 作为构造,故存在 $k=2$ 的解。$BC$ 非回文同理。
下面假设 $AB,BC,ABC$ 均为回文串。
由 $ABC$ 回文,$AB$ 回文,可得 $ABC$ 存在周期 $|C|$。 同理得 $|A|$ 也是周期。
由弱周期引理,$ABC$ 存在周期 $p=\gcd(|A|,|C|)$。这说明,$A,B,C$ 都可以视为一个循环串,即 $A=G^a$。
因为 $AB=G^{a+b}$ 回文,所以生成元 $G$ 回文。那么 $A,B,C$ 都是回文串,矛盾。
因此,上述情形不可能发生。对 $k>3$ 的情形归纳即可。
::::
得到这个观察后,枚举分界点,使用哈希 / Manacher 判定即可。复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e6 + 5;
int n; char s[N];
using hval = pair<mod998244353, mod1000000007>;
hval operator+ (const hval& a, const hval& b) {
return {a.fi + b.fi, a.se + b.se};
}
hval operator- (const hval& a, const hval& b) {
return {a.fi - b.fi, a.se - b.se};
}
hval operator* (const hval& a, const hval& b) {
return {a.fi * b.fi, a.se * b.se};
}
const hval base = {13331, 1333331};
hval b[N], h[N], ih[N];
hval sub(int l, int r) {
return h[r] - h[l - 1] * b[r - l + 1];
}
hval isub(int l, int r) {
return ih[l] - ih[r + 1] * b[r - l + 1];
}
bool check(int l, int r) {
int m = (l + r) >> 1;
if ((r - l + 1) & 1) return sub(l, m) == isub(m, r);
return sub(l, m) == isub(m + 1, r);
}
void _main() {
cin >> (s + 1); n = strlen(s + 1);
b[0] = {1, 1}; ih[n + 1] = {0, 0};
for (int i = 1; i <= n; i++) b[i] = b[i - 1] * base;
for (int i = 1; i <= n; i++) h[i] = h[i - 1] * b[1] + hval{s[i], s[i]};
for (int i = n; i >= 1; i--) ih[i] = ih[i + 1] * b[1] + hval{s[i], s[i]};
if (h[n] != ih[1]) {
cout << "YES\n" << 1 << '\n';
for (int i = 1; i <= n; i++) cout << s[i];
return cout << '\n', void();
}
for (int k = 1; k < n; k++) {
if (check(1, k) || check(k + 1, n)) continue;
cout << "YES\n" << 2 << '\n';
for (int i = 1; i <= k; i++) cout << s[i];
cout << ' ';
for (int i = k + 1; i <= n; i++) cout << s[i];
return cout << '\n', void();
}
cout << "NO\n";
}
```
:::::
## [ARC145D Non Arithmetic Progression Set](https://www.luogu.com.cn/problem/AT_arc145_d)
> 给出 $n,m$,构造一个大小为 $n$ 的整数集合 $S$ 满足:
>
> - $\forall i\in S,i\in[-10^7,10^7]$。
> - $\sum\limits_{i\in S}i=m$。
> - $\forall i,j,k\in S\land i<j<k,j-i\ne k-j$。
>
> $n\le10^4$,$|m|\le n\times10^6$,2 秒,1024 MB。
:::::success[题解]
将 $S$ 排成递增序列 $a_1\sim a_n$。设 $a_i$ 在 $x$ 进制下的表示为
$$
a_i=\sum_{n\ge0}b_{i,n}x^n
$$
其中 $b_{i,n}\in[0,x)$。题目要求任意 $i<j<k$ 满足
$$
\begin{aligned}
a_i+a_k &\ne2a_j\\
\left(\sum_{n\ge0}b_{i,n}x^n\right)+\left(\sum_{n\ge0}b_{k,n}x^n\right)&\ne2\sum_{n\ge0}b_{j,n}x^n \\
\sum_{n\ge0}(b_{i,n}+b_{k,n})x^n &\ne\sum_{n\ge0}2b_{j,n}x^n
\end{aligned}
$$
只要 $\exists n,b_{i,n}+b_{k,n}\ne2b_{j,n}$。
由 $a_i\ne a_k$,必然 $\exists n,b_{i,n}\ne b_{k,n}$。取出这个 $n$ 作为构造。
不妨取 $b_{i,n}=0,b_{k,n}=1$,进一步令 $b_{i,n}\in\{0,1\}$。此时 $b_{i,n}+b_{k,n}=1$,$b_{j,n}\in\{0,2\}$,二者必然不同,构造合法。
取 $x>2$ 均可满足要求。不难发现三进制下最优,故取所有三进制下只有 $\{0,1\}$ 的数即可。
我们需要对这个序列进行调整,使其满足和的限制。容易发现,对一个序列整体加减一个数仍然合法,因此考虑使原构造满足 $\sum\limits_{i=1}^n a_i\equiv m\pmod n$,此时令 $a_i\gets a_i+\dfrac{1}{n}\left(m-\sum\limits_{i=1}^n a_i\right)$ 即可。
初始构造可以通过微调实现。我们令 $b_{i,0}=0$,其他位填 $\{0,1\}$,然后选出若干 $b_{i,0}$ 改为 $1$,一次操作可以使 $\sum\limits_{i=1}^n a_i$ 增加 $1$。在模 $n$ 意义下总能调整出来。
打表发现调整值大概是 $10^6$ 级别,所以值域限制也可以满足。复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 1e4 + 5;
int n, m, a[N];
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int p = 3;
for (int x = i; x > 0; p *= 3, x >>= 1) if (x & 1) a[i] += p;
}
int sum = accumulate(a + 1, a + n + 1, 0LL);
int r = ((m - sum) % n + n) % n;
for (int i = 1; i <= r; i++) a[i]++, sum++;
int d = (m - sum) / n;
for (int i = 1; i <= n; i++) cout << a[i] + d << ' ';
}
```
:::::
## [P14800 [JOI 2026 二次预选] 船 / Ship](https://www.luogu.com.cn/problem/P14800)
> 给出一个长为 $n$ 的序列 $a_i$,保证 $a_i$ 单调递增。你需要将 $a_i$ 不重不漏地划分为若干等差子序列,你的得分是每段公差的最小值。最大化得分并输出。
>
> $n\le3500$,3 秒,1024 MB。
:::::success[题解]
首先我们注意到如下事实:最优解不会包含长度 $\ge4$ 的子序列。证明考虑调整法,拆成若干更小的段一定更优。
对于 $n$ 为偶数的情形,不难证明此时一定为两两匹配,且是 $i$ 与 $i+\dfrac{n}{2}$ 匹配,直接扫一遍即可。
对于 $n$ 为奇数的情形,我们继续观察:最优解中长度 $=3$ 的子序列有且仅有一个。充分性仍然调整法,将两个 $3$ 拆成三个 $2$ 更优。
那么可以枚举等差中项 $a_j$,然后双指针维护一下 $i,k$,使得 $a_i+a_k=2a_j$。除去 $i,j,k$ 位置以后是一个规模为 $n-3$ 的子问题,并且是偶数情形,直接匹配即有 $O(n^3)$。
记 $m=\dfrac{n-3}{2}$。对于一个 $(i,j,k)$,原数组下标跨过 $i,j,k$ 会产生 $O(1)$ 的偏移。更具体地,有 $6$ 个可能的分界点 $\{i,j-1,k-2,i-m,j-m-1,k-m-2\}$,这些分界点将原数组划分为至多 $7$ 段。
在每段内,每个匹配的左右下标偏移量恒定。容易发现总偏移量 $\in[0,3]$。因此,我们建立 $4$ 个 ST 表,维护 $a_{i+m+\Delta i}-a_i$ 的区间 min,然后查表。这就是 $O(n^2)$ 了。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 3505, inf = 2e9;
int n, a[N];
struct sttable {
int f[15][N];
void init(int off) {
for (int i = 1; i <= n; i++) {
if (i + off <= n) f[0][i] = a[i + off] - a[i];
else f[0][i] = inf;
}
for (int i = 1; (1 << i) <= n; i++) {
for (int j = 1; j + (1 << i) - 1 <= n; j++) f[i][j] = min(f[i - 1][j], f[i - 1][j + (1 << (i - 1))]);
}
}
int ask(int l, int r) const {
if (l > r) return inf;
int k = lg(r - l + 1);
return min(f[k][l], f[k][r - (1 << k) + 1]);
}
} st[4];
void _main() {
cin >> n;
if (n == 1) return cout << -1, void();
for (int i = 1; i <= n; i++) cin >> a[i];
if (n % 2 == 0) {
int res = 2e9;
for (int i = 1; i <= n / 2; i++) res = min(res, a[i + n / 2] - a[i]);
return cout << res, void();
}
int m = (n - 3) / 2;
for (int i = 0; i <= 3; i++) st[i].init(m + i);
int res = -1;
for (int j = 2; j < n; j++) {
for (int i = j - 1, k = j + 1; i >= 1 && k <= n; ) {
if (a[i] + a[k] == 2 * a[j]) {
deque<int> p = {i, j - 1, k - 2, i - m, j - m - 1, k - m - 2, 1, m + 1};
sort(p.begin(), p.end()), p.erase(unique(p.begin(), p.end()), p.end());
while (!p.empty() && p.front() < 1) p.pop_front();
while (!p.empty() && p.back() > m + 1) p.pop_back();
int cur = a[j] - a[i];
for (int x = 0; x < (int)p.size() - 1; x++) {
int l = (p[x] >= i) + (p[x] >= j - 1) + (p[x] >= k - 2), r = (p[x] >= i - m) + (p[x] >= j - m - 1) + (p[x] >= k - m - 2);
cur = min(cur, st[r - l].ask(p[x] + l, p[x + 1] + l - 1));
}
res = max(res, cur), k++, i--;
} else if (a[i] + a[k] < 2 * a[j]) k++;
else i--;
}
} cout << res;
}
```
:::::
## [P2512 [HAOI2008] 糖果传递](https://www.luogu.com.cn/problem/P2512)
> 给出一个长为 $n$ 的环形序列 $a_i$。一次操作选择两个相邻元素 $i,j$,令 $a_i\gets a_i-1,a_j\gets a_j+1$。求使 $a_i$ 全相等的最小操作次数。数据保证有解。
>
> $n\le10^6$,1 秒,128 MB。
:::::success[题解]
首先是一些基本转化:由于操作不改变整体的和,则最终元素必然都等于 $\frac{1}{n}\sum\limits_{i=1}^n a_i$。记这个值为 $m$。
设 $f_i$ 为 $i\to i-1$ 进行操作的总数,如果是正数就表示 $a_i\gets a_i-1$ 的次数,负数就表示 $a_i\gets a_i+1$ 的次数。下标都是环上的下标。
此时答案为 $\sum\limits_{i=1}^n|f_i|$,并且 $f_i$ 满足如下方程
$$
m=a_i-f_i+f_{i+1}\\
$$
写成递推式为 $f_{i+1}=m-a_i+f_i$。因此只需确定 $f_1$。
令 $a_i\gets a_i-m$,则 $f_{i+1}=f_i-a_i$,累加有 $f_i=f_1-\sum\limits_{j=1}^{i-1}a_j$。于是设出 $a_i$ 的前缀和 $s_i$,答案式子变为 $\sum\limits_{i=1}^n|f_1-s_i|$。
根据经典结论,$f_1$ 取到所有 $s_i$ 的中位数可以使得答案最小。复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 1e6 + 5;
int n, a[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int m = accumulate(a + 1, a + n + 1, 0LL) / n;
for (int i = 1; i <= n; i++) a[i] -= m;
for (int i = 1; i <= n; i++) a[i] += a[i - 1];
sort(a + 1, a + n + 1);
int res = 0;
for (int i = 1; i <= n; i++) res += abs(a[n / 2 + 1] - a[i]);
cout << res;
}
```
:::::
## [P4155 [SCOI2015] 国旗计划](https://www.luogu.com.cn/problem/P4155)
> 现有一个 $m$ 点的环,给出 $n$ 条线段,第 $i$ 条线段覆盖 $l_i\sim r_i$。对于每个 $i=1,2,\cdots,n$ 求出:强制选择线段 $i$ 的情况下,最少选择多少条线段可以覆盖整个环。保证有解,保证线段两两没有包含关系。
>
> $n\le2\times10^5$,$m\le10^9$,1.5 秒,250 MB。
:::::success[题解]
考虑断环为链,将环复制一倍。这样对于 $l_i>r_i$ 的线段,即令 $r_i\gets r_i+m$ 变成若干段区间,然后将区间也复制一倍。
注意到区间两两不包含,按左端点排序后右端点递增,于是选择 $i$ 后的下一个区间是确定的,可以双指针预处理。
算出下一个区间,直接暴力向后跳,跳跃次数即为答案,复杂度 $O(n^2)$。可以用倍增优化这个过程,注意细节,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 6e5 + 5;
int n, m, ans[N];
struct node {
int l, r, id;
} a[N];
int f[20][N];
int ask(int x) {
int res = 0, p = x;
for (int i = lg(2 * n); i >= 0; i--) {
int q = f[i][p];
if (q && a[q].r < a[x].l + m) res += 1 << i, p = q;
} return res + 2;
}
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i].l >> a[i].r, a[i].id = i;
if (a[i].l > a[i].r) a[i].r += m;
a[i + n] = node{a[i].l + m, a[i].r + m, a[i].id};
}
sort(a + 1, a + 2 * n + 1, [](const node& a, const node& b) -> bool {
return a.l < b.l;
});
for (int i = 1, j = 1; i <= 2 * n; i++) {
while (j <= 2 * n && a[j].l <= a[i].r) j++;
f[0][i] = j - 1;
}
for (int i = 1; (1 << i) <= 2 * n; i++)
for (int j = 1; j <= 2 * n; j++)
f[i][j] = f[i - 1][f[i - 1][j]];
for (int i = 1; i <= n; i++) ans[a[i].id] = ask(i);
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
}
```
:::::
## [AGC066A Adjacent Difference](https://www.luogu.com.cn/problem/AT_agc066_a)
> 给出一个 $n\times n$ 的矩阵 $a_{i,j}$ 和数 $k$。构造一个 $n\times n$ 的矩阵 $b_{i,j}$。满足 $\sum\limits_{i=1}^n\sum\limits_{j=1}^n|b_{i,j}|\le\frac{1}{2}kn^2$,并且将 $a_{i,j}\gets a_{i,j}+b_{i,j}$ 后,$a_{i,j}$ 与相邻数字之差不小于 $k$。
>
> $n\le500$,$k\le10^3$,2 秒,1024 MB。
:::::success[题解]
弱化限制,先考虑 $k=1$ 的做法。不妨考虑根据奇偶性构造,将网格黑白染色后,黑格放奇数,白格放偶数。
代价的期望值为 $\frac{1}{2}kn^2$,但最坏情况为 $kn^2$。注意到黑放偶数,白放奇数也是合法的,且两种操作的代价之和为 $kn^2$。根据鸽巢原理,必有一种方法的代价 $\le\frac{1}{2}kn^2$。
推广到一般情形,将奇偶的限制改为 $x\equiv k\pmod{2k}$ 和 $x\equiv0\pmod{2k}$,交换仍然成立,并且满足 $k=1$ 时的鸽巢构造法。复杂度 $O(n^2)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 505, M = 1000;
int n, k, a[N][N], b[2][N][N];
i64 cost(int st) {
i64 res = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) res += abs(b[st][i][j] - a[i][j]);
} return res;
}
void _main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cin >> a[i][j];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int v = (a[i][j] % k + k) % k, d = a[i][j] - v;
int x = (i + j) & 1, y = (d / k) & 1;
b[x ^ y][i][j] = d, b[x ^ y ^ 1][i][j] = d + k;
}
}
int st = cost(0) <= cost(1) ? 0 : 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cout << b[st][i][j] << ' ';
cout << '\n';
}
}
```
:::::
## [AGC025D Choosing Points](https://www.luogu.com.cn/problem/AT_agc025_d)
> 给定 $n,d_1,d_2$,在 $2n \times 2n$ 的网格图上选取 $n^2$ 个整点,使得任意两点的距离都不是 $\sqrt{d_1}$ 或 $\sqrt{d_2}$。输出构造。
>
> $n \le 300$,$d_1,d_2 \le 2 \times 10^5$,2 秒,1024 MB。
:::::success[题解]
整点网格图不存在等边三角形。更强的结论是,将 $(x_1-x_2)^2+(y_1-y_2)^2=d$ 的 $(x_1,y_1)$ 和 $(x_2,y_2)$ 连边,建立的图必为二分图。
::::success[证明]
若 $d$ 是奇数,则 $(x_1-x_2)^2+(y_1-y_2)^2 \equiv 1 \pmod 2$。进而
$$
\begin{aligned}
x_1^2+x_2^2+y_1^2+y_2^2&\equiv 1 \\
x_1+x_2+y_1+y_2&\equiv 1 \\
(x_1+y_1)\bmod 2&\ne(x_2+y_2)\bmod 2
\end{aligned}
$$
按 $x+y$ 的奇偶性分组,端点必然属于不同的组。
若 $d \equiv 2 \pmod 4$,则 $(x_1-x_2)^2 + (y_1-y_2)^2 \equiv 2 \pmod 4$。下列情形必有一种成立:
- $x_1-x_2\equiv 1 \land y_1-y_2 \equiv 1 \pmod 4$。
- $x_1-x_2\equiv -1 \land y_1-y_2 \equiv -1 \pmod 4$。
从而 $x_1-x_2$ 和 $y_1-y_2$ 都是奇数。按 $x$ 的奇偶性分组,端点必然属于不同的组。
若 $d \equiv 0 \pmod 4$,对坐标进行变换 $(x,y) \to \left(\dfrac{x}{2},\dfrac{y}{2}\right)$,建边条件为
$$
\left(\dfrac{x_1-x_2}{2}\right)^2+\left(\dfrac{y_1-y_2}{2}\right)^2=\dfrac{d}{4}
$$
归纳证明即可。
::::
根据上述结论,我们使用 $d_1,d_2$ 建立两张二分图,进行黑白染色,则每个整点可以组合出 $4$ 种颜色。根据鸽巢原理,必有一种颜色的点数 $\ge \dfrac{1}{4}(2n)^2=n^2$。复杂度 $O(n^3)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 605;
int n, d1, d2, c[2][N][N];
vector<pair<int, int>> e[N][N];
void solve(int d, auto&& col) {
for (int x1 = 0; x1 < 2*n; x1++) {
for (int y1 = 0; y1 < 2*n; y1++) {
e[x1][y1].clear();
for (int x2 = 0; x2 < 2*n; x2++) {
int u = d - (x1 - x2) * (x1 - x2);
if (u < 0) continue;
int v = sqrt(u);
if (v*v != u) continue;
for (int y2 : {y1 - v, y1 + v}) if (0 <= y2 && y2 < 2*n)
e[x1][y1].emplace_back(x2, y2);
}
}
}
auto dfs = [&](auto&& dfs, int x, int y) -> void {
for (auto [x2, y2] : e[x][y])
if (col[x2][y2] == -1) col[x2][y2] = col[x][y] ^ 1, dfs(dfs, x2, y2);
};
for (int x = 0; x < 2*n; x++)
for (int y = 0; y < 2*n; y++)
if (col[x][y] == -1) col[x][y] = 0, dfs(dfs, x, y);
}
void check(int i, int j) {
int cnt = 0;
for (int x = 0; x < 2*n; x++)
for (int y = 0; y < 2*n; y++)
if (c[0][x][y] == i && c[1][x][y] == j) cnt++;
if (cnt < n * n) return;
cnt = 0;
for (int x = 0; x < 2*n; x++)
for (int y = 0; y < 2*n; y++)
if (c[0][x][y] == i && c[1][x][y] == j)
if (++cnt <= n*n) cout << x << ' ' << y << '\n';
exit(0);
}
void _main() {
cin >> n >> d1 >> d2;
memset(c, -1, sizeof(c));
solve(d1, c[0]), solve(d2, c[1]);
for (int i : {0, 1}) for (int j : {0, 1}) check(i, j);
}
```
:::::
## [QOJ3678 LED-led Paths](https://qoj.ac/problem/3678)
> 给出一张 $n$ 个点 $m$ 条边的 DAG。你需要对边三染色,使得不存在一条长度 $\ge\textcolor{red}{42}$ 的有向同色路径。
>
> 输出构造,数据保证有解。
>
> $n\le5\times10^4$,$m\le2\times10^5$,3 秒,512 MB。
:::::success[题解]
首先对 DAG 进行拓扑排序,并将拓扑序作为点的标号。
注意到 $41^3=68921>5\times10^4$。考虑将点的编号拆成 $41$ 进制,即变成三元组 $(a_i,b_i,c_i)$,其中 $ 0\le a_i,b_i,c_i \le 40$。
对于有向边$(i,j)$,我们根据其从左到右第一位不同的数字进行染色:
- 若 $a_i<a_j$,颜色为 $1$。
- 若 $a_i=a_j\land b_i<b_j$,颜色为 $2$。
- 若 $a_i=a_j\land b_i=b_j\land c_i<c_j$,颜色为 $3$。
证明:取出一条全 $1$ 路径,则节点标号的 $a_i$ 严格递增。由于 $a_i$ 的值域是 $[0,40]$,故这条路径的长度至多是 $41$。对于全 $2,3$ 的路径同理。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5, B = 41;
int n, m, id[N], deg[N];
vector<int> e[N];
pair<int, int> ed[N];
void _main() {
cin >> n >> m;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
e[u].emplace_back(v), deg[v]++;
ed[i] = {u, v};
}
queue<int> q; int cnt = 0;
for (int i = 1; i <= n; i++) if (deg[i] == 0) q.emplace(i);
while (!q.empty()) {
int u = q.front(); q.pop(), id[u] = ++cnt;
for (int v : e[u]) if (--deg[v] == 0) q.emplace(v);
}
for (int i = 1; i <= m; i++) {
int u = id[ed[i].fi], v = id[ed[i].se];
int a1 = u / B / B, a2 = v / B / B;
int b1 = u / B % B, b2 = v / B % B;
if (a1 < a2) cout << "R\n";
else if (b1 < b2) cout << "G\n";
else cout << "B\n";
}
}
```
:::::
## [CF1956D Nene and the Mex Operator](https://www.luogu.com.cn/problem/CF1956D)
> 给出长度为 $n$ 的序列 $a_i$。一次操作选择一个 $[l,r]$,求出 $x=\operatorname{mex}(a_l,a_{l+1},\cdots,a_r)$ 后,将 $a_l\sim a_r$ 全部覆盖为 $x$。最大化操作结束后的 $\sum\limits_{i=1}^n a_i$,并输出方案。
>
> $n\le\textcolor{red}{18}$,$0\le a_i\le10^7$,要求操作次数 $\le5\times10^5$,2 秒,250 MB。
:::::success[题解]
我们断言,一个长度为 $n$ 的区间一定能被变为 $[n,n,\cdots,n]$。显然,长为 $1$ 的区间可以变为一个 $[1]$。
给出构造式证明:考虑一个长为 $n$ 的区间,其形如 $[0,1,2,\cdots,n-1]$,此时对整个区间操作,即可达成目标。
因此进行归纳构造。先将前 $n-1$ 个数变成 $[0,1,2,\cdots,n-2]$。然后对整个区间操作,得到 $[n-1,n-1,\cdots,n-1]$,接着再将前 $n-1$ 个数变换一次即可。
二进制枚举每个位置是否进行变换,可以得到答案。操作次数为 $O(2^n)$,总复杂度 $O(n^2 2^n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 20;
int n, a[N];
void construct(int s) {
vector<pair<int, int>> vec;
for (int i = 1; i <= n; i++) {
int l = i;
while (i <= n && (s >> (i - 1) & 1)) i++;
function<void(int)> dfs = [&](int r) -> void {
if (l > r) return;
dfs(r - 1);
if (a[r] != r - l) vec.emplace_back(l, r), fill(a + l, a + r + 1, r - l), dfs(r - 1);
};
if (l < i) dfs(i - 1), vec.emplace_back(l, i - 1), fill(a + l, a + i, i - l);
}
cout << vec.size() << '\n';
for (auto& i : vec) cout << i << '\n';
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int val = accumulate(a + 1, a + n + 1, 0), ans = 0;
for (int s = 1; s < (1 << n); s++) {
int cur = 0, len = 0;
for (int i = 1; i <= n; i++) {
if (!(s >> (i - 1) & 1)) cur += a[i] + len * len, len = 0;
else len++;
}
cur += len * len;
if (cur > val) val = cur, ans = s;
}
cout << val << ' ', construct(ans);
}
```
:::::
## [BZOJ3441 乌鸦喝水](https://hydro.ac/p/bzoj-P3441)
> 给出正整数 $n,m,x$。现有 $n$ 个任务 $(w_i,a_i)$。你需要顺次考虑每个任务共 $m$ 次:对于第 $i$ 个任务,若 $w_i\le x$,则可以选择执行,获得 $1$ 的得分,并对于所有 $i$ 令 $w_i\gets w_i+a_i$。也可以选择不执行。最大化得分并输出。
>
> $n,m\le10^5$,1 秒,256 MB。
:::::success[题解]
每次执行操作的效果是相同的,所以能执行任务时一定选择执行任务。这样直接模拟就可以做到 $O(nm)$。
考虑优化。可以求出 $t_i=\lfloor\frac{x-w_i}{a_i}\rfloor$ 表示第 $i$ 个任务最多可以承受几次操作。那么有一个关键的性质:若 $t_i$ 小的任务被执行,则 $t_i$ 大的一定可以被执行。基于此,可以将任务按 $t_i$ 升序排序并扫描:
对于当前任务,我们的贪心策略为将所有执行轮次全部用完。现在我们需要知道执行完成后的位置。容易转化为,在存活的任务中,找到第 $k$ 个位置。可以用树状数组上倍增维护,则复杂度 $O((m+n)\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
using node = pair<i64, int>;
int n, m, x;
i64 w[N], a[N];
struct BIT {
int tr[N];
void add(int x, int c) {
for (; x <= n; x += lowbit(x)) tr[x] += c;
}
int ask(int x) {
int res = 0;
for (; x >= 1; x -= lowbit(x)) res += tr[x];
return res;
}
int find(int k) {
int p = 0;
for (int i = lg(n); i >= 0; i--) {
int q = p + (1 << i);
if (q <= n && tr[q] < k) p = q, k -= tr[q];
} return p + 1;
}
} T;
void _main() {
cin >> n >> m >> x;
for (int i = 1; i <= n; i++) cin >> w[i];
vector<node> vec;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (w[i] <= x) vec.emplace_back((x - w[i]) / a[i], i), T.add(i, 1);
}
sort(vec.begin(), vec.end());
i64 k = 0, r = 1, pos = 0, len = vec.size();
for (auto [t, id] : vec) {
i64 c = t + 1 - k;
if (c > 0) {
i64 cnt = T.ask(n) - T.ask(pos);
if (c <= cnt) {
pos = T.find(T.ask(pos) + c);
} else {
i64 nr = (c - cnt - 1) / len + 1;
if (r + nr > m) return cout << k + cnt + (m - r) * len, void();
r += nr, pos = T.find((c - cnt - 1) % len + 1);
}
k = t + 1;
}
T.add(id, -1), len--;
if (len <= 0) break;
} cout << k;
}
```
:::::
## [P11166 [BalkanOI 2023] Save the Vine!](https://www.luogu.com.cn/problem/P11166)
> 给出 $n$ 个任务 $(a_i,b_i,c_i)$。你初始持有两个非负整数 $X,Y$,可以以任意顺序完成任务,但需要 $X\ge a_i\land Y\ge b_i$,完成后 $X\gets X+c_i$。给出 $k$,你需要完成至少 $k$ 个任务,最小化 $X+Y$ 并输出。
>
> $n\le2\times10^5$,2 秒,250 MB。
:::::success[题解]
这凭啥是绿啊???
我们钦定一个要完成的任务集合 $S$,则 $|S|=k$ 且 $Y=\max\limits_{i\in S}b_i$ 不劣。这启发我们枚举 $Y$,只需将任务按 $b_i$ 升序排序后枚举一段前缀 $[1,i]$,然后钦定 $Y=b_i$ 并在前缀中确定 $X_{\min}$。
考虑可以完成任务的充要条件。记 $x_0=X$,$x_i$ 表示每轮结束后的 $X$,那么 $\forall1\le i\le k,x_{i-1}\ge a_i$,且 $x_i=x_{i-1}+c_i$。移项整理得
$$
\forall1\le i\le k,X\ge a_i-\sum_{j=1}^{i-1}c_j
$$
要求 $X_{\min}$ 应当取交集,于是
$$
X=\max_{i=1}^k\left(a_i-\sum_{j=1}^{i-1}c_j\right)
$$
容易发现按 $a_i$ 升序排序可以得到最优。
我们现在可以做到 $O(n^2\log n)$,接下来考虑用数据结构维护这个式子。
枚举前缀时,每次加入 $i$ 相当于插入一个元素并按 $a_i$ 排序,可以使用平衡树。但这里我们有更简单的处理方案:将元素按 $a_i$ 升序排序,并记录每个元素的位置,插入元素相当于激活一个位置。
这个东西类似于离散化后权值线段树,所以在这个序列上维护一棵线段树,支持区间 $\max$。每次激活位置使得 $\sum c_i$ 向后平移,因此需要区间减法。
然后还需要维护一下第 $k$ 个位置去查询,我的做法使用权值树状数组上倍增找到这个位置。
整体复杂度 $O(n\log n)$。
**启示:通过枚举前缀的方法钦定一组元素。**
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
const i64 inf = 1e18;
int n, k, pos[N];
struct node {
int a, b, c, id;
} a[N], b[N];
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
i64 val[N << 2], tag[N << 2];
void pushup(int rt) {val[rt] = max(val[ls], val[rs]);}
void apply(int rt, i64 c) {val[rt] += c, tag[rt] += c;}
void pushdown(int rt) {
if (!tag[rt]) return;
apply(ls, tag[rt]), apply(rs, tag[rt]), tag[rt] = 0;
}
void build(int l = 1, int r = n, int rt = 1) {
val[rt] = -inf, tag[rt] = 0;
if (l == r) return;
int mid = (l + r) >> 1;
build(l, mid, ls), build(mid + 1, r, rs);
}
void update(int tl, int tr, i64 c, int l = 1, int r = n, int rt = 1) {
if (tl <= l && r <= tr) return apply(rt, c), void();
int mid = (l + r) >> 1; pushdown(rt);
if (tl <= mid) update(tl, tr, c, l, mid, ls);
if (tr > mid) update(tl, tr, c, mid + 1, r, rs);
pushup(rt);
}
void set(int x, i64 c, int l = 1, int r = n, int rt = 1) {
if (l == r) return val[rt] = c, void();
int mid = (l + r) >> 1; pushdown(rt);
if (x <= mid) set(x, c, l, mid, ls);
else set(x, c, mid + 1, r, rs);
pushup(rt);
}
i64 ask(int tl, int tr, int l = 1, int r = n, int rt = 1) {
if (tl <= l && r <= tr) return val[rt];
i64 mid = (l + r) >> 1, res = -inf; pushdown(rt);
if (tl <= mid) res = max(res, ask(tl, tr, l, mid, ls));
if (tr > mid) res = max(res, ask(tl, tr, mid + 1, r, rs));
return res;
}
} S;
struct BIT {
int cnt[N];
i64 sum[N];
void add(int x, i64 c) {
for (; x <= n; x += lowbit(x)) cnt[x]++, sum[x] += c;
}
i64 ask(int x) {
i64 res = 0;
for (; x >= 1; x -= lowbit(x)) res += sum[x];
return res;
}
int kth(int k) {
int p = 0;
for (int i = 1 << 18; i; i >>= 1) {
if (i + p <= n && cnt[i + p] < k) p += i, k -= cnt[p];
} return p + 1;
}
} B;
void _main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i].a >> a[i].b >> a[i].c, a[i].id = i, b[i] = a[i];
S.build();
sort(a + 1, a + n + 1, [](const node& x, const node& y) -> bool {return x.b < y.b;});
sort(b + 1, b + n + 1, [](const node& x, const node& y) -> bool {return x.a < y.a;});
for (int i = 1; i <= n; i++) pos[b[i].id] = i;
i64 res = inf;
for (int i = 1; i <= n; i++) {
int x = pos[a[i].id];
if (x < n) S.update(x + 1, n, -a[i].c);
S.set(x, a[i].a - B.ask(x)), B.add(x, a[i].c);
if (i < k) continue;
res = min(res, a[i].b + S.ask(1, B.kth(k)));
} cout << res;
}
```
:::::
## [P9133 [THUPC 2023 初赛] 大富翁](https://www.luogu.com.cn/problem/P9133)
> 给出一棵节点数为 $n$ 的有根树,根节点为 $1$,点带权 $w_i$。A 和 B 进行博弈,A 先手。
>
> 一轮游戏中,当前操作方选择一个未被选过的节点 $u$,失去 $w_u$ 的分数。记 $u$ 的子树中有 $n_1$ 个被对方选择的节点,$u$ 的祖先中有 $n_2$ 个被对方选择的节点,则操作方向对方支付 $n_1$ 的分数,并从对方手中获得 $n_2$ 的分数。
>
> 假定两人绝顶聪明。求出 A 在博弈结束后可获得的最大分数。
>
> $n\le2\times10^5$,1 秒,512 MB。
:::::success[题解]
记 $f(x,y)$ 表示 $x$ 是否是 $y$ 的祖先。钦定一个先手选点构成的集合 $S$,则可以将得分的贡献拆到每个点对上
$$
\sum_{u\in S}\sum_{v\notin S}(f(u,v)-f(v,u))-\sum_{u\in S}w_u
$$
这顺带说明了操作没有后效性,每次选择是独立的。
注意到上面的式子等价于
$$
\sum_{u\in S}(s_u-d_u-w_u)
$$
其中 $s_u$ 为子树 $u$ 的大小,$d_u$ 为节点 $u$ 的深度。$v$ 对 $S$ 的贡献在枚举时可以被消去。
于是将点按照 $s_u-d_u-w_u$ 降序排序后,先手必然选择价值前 $1,3,5,\cdots$ 大的节点,直接累加即可。
复杂度 $O(n\log n)$。
**启示:许多问题的答案与选择过程无关,而与最终结果相关。可以直接刻画最终形态。**
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, w[N], s[N], d[N], a[N];
vector<int> e[N];
void dfs(int u) {
s[u] = 1;
for (int v : e[u]) d[v] = d[u] + 1, dfs(v), s[u] += s[v];
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int v = 2, u; v <= n; v++) cin >> u, e[u].emplace_back(v);
d[1] = 1, dfs(1);
for (int i = 1; i <= n; i++) a[i] = s[i] - d[i] - w[i];
i64 res = 0;
sort(a + 1, a + n + 1, greater<int>());
for (int i = 1; i <= n; i += 2) res += a[i];
cout << res;
}
```
:::::
## [P12652 [KOI 2024 Round 2] 拔树游戏](https://www.luogu.com.cn/problem/P12652)
> 给定一棵节点数为 $n$ 的有根树,根节点为 $1$。点带权 $a_i$,且所有 $a_i$ 构成一个排列。一次操作中,找到一条字典序最小的根链,将点权向根循环移位一个单位,并删去叶子,共进行 $n$ 次。求每次操作前根节点的点权。
>
> $n\le3\times10^5$,2 秒,1024 MB。
:::::success[题解]
将一次操作描述为:
- 将根节点的权值输出,并在根节点处设置一个空洞;
- 找到权值最小的儿子补上这个洞,将空洞转移到这个节点上;
- 重复上述过程,递归直到叶节点。
当一个节点的权值被拿走,其儿子全部暴露出来,因此需要加入候选集合。而每次拿走的必然是候选集合中权值最小的节点。
小根堆维护即可,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 3e5 + 5;
using node = pair<int, int>;
int n, a[N];
vector<int> e[N];
priority_queue<node, vector<node>, greater<node>> q;
void _main() {
cin >> n;
for (int v = 2, u; v <= n; v++) cin >> u, e[u].emplace_back(v);
for (int i = 1; i <= n; i++) cin >> a[i];
q.emplace(a[1], 1);
for (int i = 1; i <= n; i++) {
auto [x, u] = q.top(); q.pop();
cout << x << '\n';
for (int v : e[u]) q.emplace(a[v], v);
}
}
```
:::::
## [P5749 [IOI 2019] 排列鞋子](https://www.luogu.com.cn/problem/P5749)
> 给出 $2n$ 个整数 $a_i$。称序列 $a_i$ 是合法的,当且仅当 $\forall i\in[1,n],a_{2i}+a_{2i+1}=0\land a_{2i}<0\land a_{2i+1}>0$。
>
> 一次操作可以交换相邻两数,求使得 $a_i$ 合法的最小操作次数。数据保证有解。
>
> $n\le10^5$,1 秒,1024 MB。
:::::success[题解]
看到相邻对换想逆序对。对于本题,我们考虑求出每个元素的目标位置 $p_i$,则 $p_i$ 的逆序对数即为所求。
顺次扫描序列 $a_i$。设负数 $x$ 在扫描中第 $k$ 次出现。贪心地,我们不希望数字的匹配关系存在交叉,这样只会增加逆序对数。因此,负数 $x$ 一定匹配第 $k$ 次出现的正数 $-x$。
基于此考虑实现方法:维护 $2n$ 个队列表示每个数的出现位置。假设扫描中位于第 $i$ 个位置,已经配对 $c$ 次,且 $p_i$ 还未确定。从队列中找到 $j$ 表示其配对下标。
- 若 $a_i<0$,则负数在正数前面,无需额外配对。则 $p_i\gets2c,p_j\gets2c+1$。
- 若 $a_i>0$,此时正负必须产生一次交叉,直接赋值 $p_j\gets2c,p_i\gets2c+1$,可以产生一个逆序对,从而捕捉到这次交叉的代价。
结束后令 $c\gets c+1$,并将 $i,j$ 出队。模拟过程线性,总复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, a[N], p[N];
queue<int> x[N], y[N];
i64 solve(int l, int r) {
if (l == r) return 0;
int mid = (l + r) >> 1;
i64 res = solve(l, mid) + solve(mid + 1, r);
for (int i = l, j = mid + 1; i <= mid && j <= r; ) {
if (p[i] <= p[j]) i++;
else j++, res += mid - i + 1;
}
inplace_merge(p + l, p + mid + 1, p + r + 1);
return res;
}
void _main() {
cin >> n;
for (int i = 1; i <= 2 * n; i++) {
cin >> a[i];
if (a[i] > 0) x[a[i]].emplace(i);
else y[-a[i]].emplace(i);
}
int cnt = 0;
fill(p + 1, p + 2 * n + 1, -1);
for (int i = 1; i <= 2 * n; i++) {
if (p[i] != -1) continue;
if (a[i] < 0) {
int j = x[-a[i]].front();
x[-a[i]].pop(), y[-a[i]].pop();
p[i] = 2 * cnt, p[j] = 2 * cnt + 1;
} else {
int j = y[a[i]].front();
x[a[i]].pop(), y[a[i]].pop();
p[j] = 2 * cnt, p[i] = 2 * cnt + 1;
}
cnt++;
}
cout << solve(1, 2 * n);
}
```
:::::
## [CF521D Shop](https://www.luogu.com.cn/problem/CF521D)
> 给出一个长为 $k$ 的序列 $a_i$。给出 $n$ 种操作,操作形如将 $a_i$ 赋值 / 加上 / 乘上 $c$。你至多选择 $m$ 种操作,最大化 $\prod\limits_{i=1}^k a_i$。构造一种选择方案。
>
> $k,n,m\le10^5$,$1\le a_i,c\le10^6$,2 秒,250 MB。
:::::success[题解]
观察性质起手:
- 赋值操作一定在加操作和乘操作前面;
- 由 $(a+c_1)c_2>ac_2+c_1$,加操作一定在乘操作前面;
- 对同一个数的赋值操作至多执行一次,且取 $c_{\max}$ 执行。
考虑对于每个数,求出其赋值操作对应的 $c_{\max}$,然后把赋值转化为加法。
对于每个数,它选择的加操作显然是最大的若干个。按照 $c$ 排序后加法可以转化为乘法:$a\gets a+c\iff a\gets a\times\frac{a+c}{a}$。
现在只剩下乘操作,这个很简单,将所有乘法操作排序后取出前 $m$ 大即可。
视 $n,m,k$ 同阶复杂度 $O(n\log n)$。注意一些实现细节:用分数类维护 $ \frac{a+c}{a}$ 并且开 int128;输出时注意还原操作顺序。
**启示:通过分析操作性质,将所给操作化归为一种。**
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
using info = pair<i64, int>;
int k, n, m, a[N], op[N];
vector<info> x[N], y[N];
struct node {
i64 x, y; int id;
node(i64 a = 0, i64 b = 0, int c = 0) : x(a), y(b), id(c) {}
bool operator< (const node& a) const {
return (i128)x * a.y > (i128)a.x * y;
}
};
vector<node> z;
void _main() {
cin >> k >> n >> m;
for (int i = 1; i <= k; i++) cin >> a[i];
for (int i = 1, opt, u, c; i <= n; i++) {
cin >> opt >> u >> c; op[i] = opt;
if (opt == 1) x[u].emplace_back(c, i);
else if (opt == 2) y[u].emplace_back(c, i);
else if (c > 1) z.emplace_back(c, 1, i);
}
for (int i = 1; i <= k; i++) {
if (x[i].empty()) continue;
auto [c, id] = *max_element(x[i].begin(), x[i].end());
y[i].emplace_back(c - a[i], id);
}
for (int i = 1; i <= k; i++) {
sort(y[i].begin(), y[i].end(), greater<info>());
i64 sum = a[i];
for (auto [c, id] : y[i]) {
if (c <= 0) continue;
z.emplace_back(sum + c, sum, id);
sum += c;
}
}
sort(z.begin(), z.end());
vector<int> vec;
for (int i = 0; i < min<int>(m, z.size()); i++) vec.emplace_back(z[i].id);
sort(vec.begin(), vec.end(), [](int x, int y) -> bool {
return op[x] < op[y];
});
cout << vec.size() << '\n';
for (int i : vec) cout << i << ' ';
}
```
:::::
## [P5290 [十二省联考 2019] 春节十二响](https://www.luogu.com.cn/problem/P5290)
> 给出一棵以 $1$ 为根的有根树,节点数为 $n$,点带权 $a_i$。你需要将这些节点划分为若干个集合 $S_1,S_2,\cdots,S_k$,满足集合内部不存在祖先—后代关系。最小化 $\sum\limits_{i=1}^k\max\limits_{u\in S_i}a_u$ 并输出。
>
> $n\le2\times10^5$,1 秒,500 MB。
:::::success[题解]
对于点 $u$ 的两个儿子 $x,y$,由于集合不能存在祖先—后代关系,因此 $x$ 的答案需要与 $y$ 合并。
注意到 $\max$ 的四边形不等式 $a<b<c<d\implies\max(a,b)+\max(c,d)<\max(a,c)+\max(b,d)$。根据 exchange argument 的理论,将 $x,y$ 的答案升序排序后依次配对,在局部即为最优。
接下来证明局部最优不会影响祖先答案。将不升序列 $a_i,b_i$ 合并后的 $c_i=\max(a_i,b_i)$ 也是一个不升序列。因此采用其他合并方法得到 $c'_i$ 并降序排序后必然有 $c'_i\ge c_i$。
子树 $u$ 继续向上合并时,提供一个更劣的 $c'_i$ 一定不优。因此上传 $c_i$ 就是全局最优。
直接模拟即可 $O(n^2)$。用启发式合并维护优先队列就有 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, a[N];
vector<int> e[N];
priority_queue<int> q[N];
void join(int u, int v) {
if (q[u].size() < q[v].size()) swap(q[u], q[v]);
vector<int> vec;
while (!q[v].empty()) {
vec.emplace_back(max(q[u].top(), q[v].top()));
q[u].pop(), q[v].pop();
}
for (int i : vec) q[u].emplace(i);
}
void dfs(int u) {
for (int v : e[u]) dfs(v), join(u, v);
q[u].emplace(a[u]);
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int v = 2, u; v <= n; v++) cin >> u, e[u].emplace_back(v);
dfs(1); i64 res = 0;
while (!q[1].empty()) res += q[1].top(), q[1].pop();
cout << res;
}
```
:::::
## [P5914 [POI 2004] MOS](https://www.luogu.com.cn/problem/P5914)
> 有 $n$ 个人需要渡河,船只有一条,每次最多渡过两个人。
>
> 每个人有一个代价 $a_i$,渡过两个人的代价则取两人代价的最大值。
>
> 初始时人全部位于左岸,目标为将所有人渡到右岸。最小化代价并输出。
>
> $n\le10^5$,1 秒,128 MB。
:::::success[题解]
我们先将 $a_i$ 升序排序,不妨考虑渡过代价尽量大的人。记渡过 $x$ 的操作为 $(x)$,渡过 $x,y$ 的操作为 $(x,y)$,则渡过 $n-1,n$ 的最优操作一定在以下两者中产生:
- $(1,n)\to(1)\to(1,n-1)\to(1)$;
- $(1,2)\to(1)\to(n,n-1)\to(2)$。
前者代价为 $2a_1+a_n+a_{n-1}$,后者代价为 $a_1+2a_2+a_n$。两种策略取 $\min$ 即可。
渡过 $n$ 和 $n-1$ 后,问题变成一个规模为 $n-2$ 的子问题,归纳构造即可。
::::success[正确性]{open}
做法正确性并不显然,这里给出证明。
下面假定 $n>3$,并记每轮中回来的人构成集合 $S$。则有一些显然的观察:
- 每次回来的人数恰好为 $1$。
- 当前回来的人,一定是右岸代价值最小的人 $r_{\min}$。
- 证明:调整法,如果存在另一个人 $r'$ 回来,则直接用 $r_{\min}$ 代替 $r'$ 的后续行动不劣。
- $n-1\notin S\land n\notin S$。
- 证明:设 $x\in\{n-1,n\}$,操作序列为 $(x,y)\to(x)$,则代价为 $2a_x$。将 $x$ 替换为 $1$ 代价即变为 $2a_1$,不劣。
说明上述观察后,我们考虑 $n-1$ 和 $n$ 的渡河策略:
- 两人在两次行程中渡河:设两轮的摆渡人为 $x,y$,即操作序列 $(x,n)\to(x)\to(y,n-1)\to(y)$,代价为 $a_n+a_{n-1}+a_x+a_y$,易得 $x=y=1$ 时代价最小。
- 两人在一次行程中渡河:根据第三个观察,我们需要提前送一个人 $y$ 渡河,设这次任务的摆渡人为 $x$,则 $x\ne y$。操作序列 $(x,y)\to(x)\to(n-1,n)\to(y)$,代价为 $a_n+\max(a_x,a_y)+a_x+a_y$。$x=1,y=2$ 时代价最小。
以上证明完毕,只需依次考虑 $n-1,n$ 即为最优,$n>3$ 时渡过 $n-1,n$ 的最优策略只有上述两种。
::::
注意实现细节:上述策略在 $n\le3$ 时不再适用,因为不需要返回左岸接人,需要单独手玩。特判 $n=1$。
复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 1e5 + 5;
int n, a[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
if (n <= 2) return cout << a[n], void();
int res = 0;
for (; n > 3; n -= 2) {
int x = 2 * a[1] + a[n] + a[n - 1];
int y = a[1] + 2 * a[2] + a[n];
res += min(x, y);
}
if (n <= 2) return cout << res + a[n], void();
cout << res + a[1] + a[2] + a[3];
}
```
:::::
## [P8903 [USACO22DEC] Bribing Friends G](https://www.luogu.com.cn/problem/P8903)
> 现有 $n$ 个元素 $(p_i,c_i,x_i)$。你初始持有 $a$ 元钱和 $b$ 张优惠券。对于第 $i$ 个元素,你可以支付 $c_i$ 元获得 $p_i$ 的得分。同时,如果你支付 $x_i$ 张优惠劵,你还可以获得 $1$ 元的折扣,折扣的上限为 $c_i$。最大化得分并输出。
>
> $n,c_i,x_i,a,b\le2000$,2 秒,256 MB。
:::::success[题解]
容易设计一个 DP:记 $f_{i,j,k}$ 为考虑到第 $i$ 个元素,当前持有 $j$ 元钱,$k$ 张优惠券,枚举对第 $i$ 个元素支付的优惠券可以转移。视 $n,V$ 同阶复杂度 $O(n^4)$,无法通过。
我们需要发现性质,然后用贪心优化 DP。
考虑如下情景:我们已经确定了最优解中选择哪些元素。这种情况下有一个贪心:我们按 $x_i$ 升序排序,并且顺次使用优惠券。
对于前面的元素,我们一定是尽量使用优惠券直到买满。那么整个场面上至多有一个元素没有被买满,是使用钱 + 优惠券混用得到的。
拓展到一般情况,将元素按 $x_i$ 升序排序后,最优解一定形如:

我们可以对前缀做一个 $(p_i,x_i)$ 的背包,对后缀做一个 $(p_i,c_i)$ 的背包。在计算答案时,只需枚举中点,再枚举中点元素使用的优惠券数目,即用 $(\max,+)$ 卷积合并前后缀背包。
复杂度 $O(n^2)$,有一些 corner case。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2005;
int n, a, b, f[N][N], g[N][N];
struct node {
int p, c, x;
} c[N];
void _main() {
cin >> n >> a >> b;
for (int i = 1; i <= n; i++) cin >> c[i].p >> c[i].c >> c[i].x;
sort(c + 1, c + n + 1, [](const node& a, const node& b) -> bool {
return a.x < b.x;
});
for (int i = 1; i <= n; i++) {
int w = c[i].c * c[i].x;
for (int j = 0; j <= b; j++) {
f[i][j] = f[i - 1][j];
if (j >= w) f[i][j] = max(f[i][j], f[i - 1][j - w] + c[i].p);
}
}
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= a; j++) {
g[i][j] = g[i + 1][j];
if (j >= c[i].c) g[i][j] = max(g[i][j], g[i + 1][j - c[i].c] + c[i].p);
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= c[i].c; j++) {
if (j * c[i].x > b || c[i].c - j > a) continue;
res = max(res, f[i - 1][b - j * c[i].x] + g[i + 1][a - c[i].c + j] + c[i].p);
}
} cout << res;
}
```
:::::
## [AGC010F Tree Game](https://www.luogu.com.cn/problem/AT_agc010_f)
> 有一棵节点数为 $n$ 的有根树,点带权 $a_i$。两人进行博弈:初始将棋子放在一点 $u$,两人轮流操作,每次操作先将 $a_u\gets a_u-1$,然后移动到一个邻居 $u\gets v$。若 $a_u=0$ 则失败。求哪些初始点满足先手必胜。
>
> $n\le3000$,$0\le a_i\le10^9$,2 秒,256 MB。
:::::success[题解]
观察到一种策略:对方移动到 $v$ 时,我方就回到 $u$,进行反复横跳。若 $a_v\ge a_u$ 且反复横跳持续进行,先手必胜。
即使对方放弃僵持,$a_v$ 也会减少,出路减少必然不优。因此,两方只会选择 $a_v<a_u$ 的 $u\to v$ 边。
缩减状态后直接做即有 $O(n^2)$。事实上可以将 $a_v<a_u$ 的边定向,问题就变成有向图博弈,拓扑排序 DP 即可做到 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 3005;
int n, a[N], f[N], deg[N];
vector<int> e[N];
void bfs() {
queue<int> q;
for (int i = 1; i <= n; i++) if (!deg[i]) q.emplace(i), f[i] = 0;
while (!q.empty()) {
int u = q.front(); q.pop();
for (int v : e[u]) {
f[v] |= f[u] ^ 1;
if (--deg[v] == 0) q.emplace(v);
}
}
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
if (a[u] == a[v]) continue;
if (a[u] > a[v]) swap(u, v);
e[u].emplace_back(v), deg[v]++;
}
bfs();
for (int i = 1; i <= n; i++) if (f[i]) cout << i << ' ';
}
```
:::::
## [P12651 [KOI 2024 Round 2] 最大异或](https://www.luogu.com.cn/problem/P12651)
> 给出一个长为 $n$ 的 01 串,要求选出两个子串,使得两个子串作为二进制数的异或和最大。不要求子串不交。输出最大的异或和。
>
> 多测,$\sum n\le10^7$,2 秒,1024 MB。
:::::success[题解]
首先注意到,结果的首位应当为 $1$ 且长度最大。如果能保留第一个 $1$ 则一定不劣。所以找到串中第一个 $1$ 的出现位置 $p$,第一个子串 $s_1$ 选 $[p,n]$ 即可。如图所示:

找到 $p$ 后,我们从 $p+1$ 开始寻找第一个 $0$ 的位置 $q$。我们希望将 $[p,q)$ 中所有的 $1$ 保留,所以 $s_2$ 不能与这 $q-p$ 位对齐。因此,$|s_2|\le n-q$。
进一步,我们希望将 $q$ 位置的 $0$ 翻转成 $1$,那么 $s_2$ 的最高位必须为 $1$ 且长度对齐这个 $0$。因此,$|s_2|=n-q$。
现在问题转化为:在 $[p,q)$ 中找一个起点 $i$,使得 $s_2$ 与 $s_1$ 剩下的部分 $[q,n]$ 异或和最大。
因为 $i\in[p,q)$,所以 $s_2$ 必然有一段连续 $1$ 的前缀,且长度恰为 $q-i$。设目标串开头有 $z$ 个 $0$,于是:
- 若 $z\le q-p$:令 $i=q-z$。此时 $s_2$ 以 $z$ 个 $1$ 开头,产生 $z+1$ 个连续 $1$;
- 若 $z>q-p$:此时连续 $1$ 不够用,我们尽量提供更多的 $1$,取 $i=p$ 最优。
注意一些 corner case:找不到 $p$ 或找不到 $q$ 的情况,对应特判是容易的。
复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e7 + 5;
int n;
char s[N];
void _main() {
cin >> n >> (s + 1);
int p = -1, q = -1, len = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '1') {p = i; break;}
}
if (p == -1) return cout << 0 << '\n', void();
for (int i = p; i <= n; i++) {
if (s[i] == '0') {q = i; break;}
}
for (int i = q; i <= n; i++) {
if (s[i] != '0') break;
len++;
}
if (len == 0) {
if (p == 1) cout << string(n - 1, '1') << '0';
else cout << string(n - p + 1, '1');
return cout << '\n', void();
}
cout << string(q - p, '1');
for (int i = q; i <= n; i++) {
char a = s[i], b = s[i - min(q - p, len)];
cout << (a == b ? '0' : '1');
}
cout << '\n';
}
```
:::::
## [P10960 SUBSTRACT](https://www.luogu.com.cn/problem/P10960)
> 给出一个长为 $n$ 的序列 $a_i$。第 $i$ 次操作选择一个 $x$,令 $a_x\gets a_x-a_{x+1}$ 并删去 $a_{x+1}$。目标为 $n-1$ 次操作后序列恰好剩下一个数 $k$。输出构造,数据保证有解。
>
> $n\le100,|k|\le10^4,1\le a_i\le100$,1 秒,512 MB。
:::::success[题解]
不难发现,最终的 $k$ 由 $n$ 个数合并而来,且 $a_1,a_2$ 的符号恒定,$a_3\sim a_n$ 的符号可以任意调节。
那么转化为构造一组权值 $w_i\in\{-1,1\}$,使得 $a_1-a_2+\sum\limits_{i=3}^n a_iw_i=k$。移项以后两边同加 $\sum\limits_{i=3}^n a_i$,式子变成
$$
\sum_{i=3}^n a_i(w_i+1)=k-a_1+a_2+\sum_{i=3}^n a_i
$$
这就是个很经典的 01 背包了,物品价值是 $2a_i$,只有选和不选两种决策。用一个可行性 DP 做背包,然后倒推回去就能求得一组 $w_i$。
根据 $w_i$ 的取值容易构造最终方案。具体地,我们先处理 $w_i=1$ 的数字,依次从前往后操作 $a_i$,然后用一个操作 $1$ 修正符号,接着不断进行操作 $1$ 即可处理 $w_i=-1$ 的数字。
bitset 优化可行性背包,复杂度 $O(\frac{nV}{w})$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 105, M = 2e4 + 5;
int n, k, a[N], w[N];
bitset<M> f[N];
void _main() {
cin >> n >> k;
if (n == 1) return;
if (n == 2) return cout << 1, void();
for (int i = 1; i <= n; i++) cin >> a[i];
int m = k - a[1] + a[2] + accumulate(a + 3, a + n + 1, 0);
f[2][0] = 1;
for (int i = 3; i <= n; i++) f[i] = f[i - 1] | (f[i - 1] << (2 * a[i]));
for (int i = n, j = m; i >= 3; i--) {
if (j >= 2 * a[i] && f[i - 1][j - 2 * a[i]]) w[i] = 1, j -= 2 * a[i];
else w[i] = -1;
}
int cnt = 0;
for (int i = 2; i <= n; i++) if (w[i] == 1)
cout << i - cnt - 1 << '\n', cnt++;
cout << 1 << '\n';
for (int i = 2; i <= n; i++) if (w[i] == -1)
cout << 1 << '\n';
}
```
:::::
## [ARC166D Interval Counts](https://www.luogu.com.cn/problem/AT_arc166_d)
> 给出两个长为 $n$ 的序列 $x_i,y_i$。你需要构造若干区间 $[l_i,r_i]$,使得每个点 $x_i$ 恰好被覆盖 $y_i$ 次。最大化 $\min\limits_{i}\left(r_i-l_i\right)$ 并输出。保证 $x_i$ 单调递增。
>
> $n\le2\times10^5$,2 秒,1024 MB。
:::::success[题解]
考虑贪心构造。首先有一个朴素的观察:为了让区间尽可能长,应当最小化 $l_i$ 并最大化 $r_i$。
通过分析 $y_i$ 到 $y_{i+1}$ 的变化,我们可以分析线段在 $x_i,x_{i+1}$ 两段的起止情况:
- 若 $y_i>y_{i-1}$,则 $(x_{i-1},x_i]$ 之间必然有 $y_i-y_{i-1}$ 个起点。左端点的最小取值为 $x_{i-1}+1$。
- 若 $y_i<y_{i+1}$,则 $[x_i,x_{i+1})$ 之间必然有 $y_{i+1}-y_i$ 个终点,右端点的最小取值为 $x_{i+1}-1$。
这里认为 $x_0=-\infty,y_0=0$ 且 $x_{n+1}=+\infty,y_{n+1}=0$。
我们会得到一堆左右端点。做 exchange argument 易证:将其升序排序后,两两对应匹配即为最优。
直接模拟需要维护 $O(nV)$ 个端点,但容易发现不同的端点只有 $O(n)$ 个,记录二元组 $(a,b)$ 表示端点 $a$ 出现了 $b$ 次,双指针匹配即可。复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 2e5 + 5, inf = 1e18;
int n, x[N], y[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> x[i];
for (int i = 1; i <= n; i++) cin >> y[i];
x[0] = -inf, x[n + 1] = inf;
vector<pair<int, int>> l, r;
for (int i = 1; i <= n; i++) {
if (y[i] > y[i - 1]) l.emplace_back(x[i - 1] + 1, y[i] - y[i - 1]);
if (y[i] > y[i + 1]) r.emplace_back(x[i + 1] - 1, y[i] - y[i + 1]);
}
int res = inf;
for (int i = 0, j = 0; i < (int)l.size() && j < (int)r.size(); ) {
chkmin(res, r[j].first - l[i].first);
int c = min(l[i].second, r[j].second);
l[i].second -= c, r[j].second -= c;
if (l[i].second == 0) i++;
if (r[j].second == 0) j++;
}
cout << (res >= 1e17 ? -1 : res) << '\n';
}
```
:::::
## [P10647 [NordicOI 2023] Ice Cream Machines](https://www.luogu.com.cn/problem/P10647)
> 给出 $n,m,k$ 和长为 $n$ 值域 $[1,m]$ 的序列 $a_i$。初始有序列 $b_1,b_2,\cdots,b_k$ 且 $b_i=-1$。
>
> 对于每个 $i=1,2,\cdots,n$,你需要依次进行决策,选择一个 $j\in[1,k]$,若 $b_j\ne a_i$ 则产生 $1$ 的代价,并将 $b_j\gets a_i$。最小化代价并输出。
>
> $n,m,k\le2\times10^5$,1 秒,512 MB。
:::::success[题解]
如果要在线决策的话是不可能最优的,这启示我们分析离线信息。
若 $\exists j\in[1,k],b_j=a_i$,显然选择 $b_j$ 不劣;否则必须要丢掉一个 $b_j$。
我们的贪心策略是,丢掉在当前 $a_i$ 后缀中出现最晚的 $b_j$。正确性在于,如果选择出现时间更靠前的 $b_{j'}$,那么 $b_{j'}$ 所对应的需求一定还会产生代价,而且 $b_j$ 也有可能产生代价,其他代价都不会被影响,所以这是不优的。
直接模拟可以做到 $O(nk)$。考虑优化,用一个堆来维护每个 $b_i$ 的下一次出现位置,需要 increase-key,复杂度 $O(n\log k)$。学习了题解中 pbds 的写法。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, m, k, a[N], nxt[N], pos[N];
heap<int> q;
heap<int>::point_iterator it[N];
void _main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
fill(pos + 1, pos + m + 1, n + 1);
for (int i = n; i >= 1; i--) nxt[i] = pos[a[i]], pos[a[i]] = i;
int res = 0;
for (int i = 0; i <= m; i++) it[i] = nullptr;
for (int i = 1; i <= n; i++) {
if (it[a[i]] != nullptr) {
q.modify(it[a[i]], nxt[i]);
continue;
}
if ((int)q.size() == k) {
int x = q.top(); q.pop();
it[a[x]] = nullptr;
}
it[a[i]] = q.push(nxt[i]), res++;
}
cout << res;
}
```
:::::
## [P8162 [JOI 2022 Final] 让我们赢得选举 / Let's Win the Election](https://www.luogu.com.cn/problem/P8162)
> 给出 $n$ 个任务 $(a_i,b_i)$,$b_i$ 可能为 $+\infty$。你初始持有 $d=1$,对于第 $i$ 个任务,可以选择一个实数 $x$,若 $dx\ge a_i$ 则获得 $1$ 的得分,若 $dx\ge b_i$ 则令 $d\gets d+1$。此操作支付 $x$ 的代价。
>
> 每个任务只能获得一次得分,求获得 $k$ 得分的最小代价。
>
> $n,k\le500$,1.6 秒,1024 MB。
:::::success[题解]
对第 $i$ 个任务,不难发现最优解满足 $x_i\in\{0,a_i,b_i\}$。
如果我们钦定了 $x_i$,则最优顺序一定是先执行 $x_i=b_i$ 的任务使得 $d$ 较大,再执行 $x_i=a_i$ 的任务。并且根据排序不等式,执行 $x_i=b_i$ 的任务时按 $b_i$ 升序排序即最优顺序。
如果我们确定了 $x_i=b_i$ 的任务集合,则 $a_i$ 直接排序贪心选取即可。这启发我们枚举 $m$ 并钦定恰好选 $m$ 个 $x_i=b_i$。
根据上述分析,按 $b_i$ 升序排序可以形成最优子结构,因此考虑 DP。记 $f_{i,j,k}$ 为考虑前 $i$ 个任务,选择 $j$ 个 $x_i=b_i$ 的任务,$k$ 个 $x_i=a_i$ 的任务的最小代价,转移时考虑当前任务是哪种情况即可,复杂度 $O(n^4)$。
进一步,我们可以使用调整法说明:在这段特定前缀不存在 $x_i=0$ 的任务。找到最后一个 $x_j=b_j$ 的任务 $j$,并令 $x_i=b_i,x_j=0$ 更优。
于是我们有 $j+k=i$,那么可以省略一维,总复杂度即 $O(n^3)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 505;
const double inf = 1e18;
int n, k;
struct node {
double a, b;
} a[N];
double v[N], f[N][N];
double work(int m) {
for (int i = 1; i <= n; i++) v[i] = a[i].a;
for (int i = 1; i <= n; i++) fill(f[i], f[i] + i + 1, inf);
f[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= min(m, i); j++) {
chkmin(f[i + 1][j], f[i][j] + a[i + 1].a / (m + 1));
chkmin(f[i + 1][j + 1], f[i][j] + a[i + 1].b / (j + 1));
}
}
double res = inf;
for (int i = k; i <= n; i++) chkmin(res, f[i][m]);
for (int i = k - 1; i >= m; i--) {
sort(v + i + 1, v + n + 1);
chkmin(res, f[i][m] + accumulate(v + i + 1, v + k + 1, 0.0) / (m + 1));
} return res;
}
void _main() {
cin >> n >> k;
for (int i = 1, x, y; i <= n; i++) {
cin >> x >> y;
a[i].a = x, a[i].b = (y == -1 ? inf : y);
}
sort(a + 1, a + n + 1, [](const node& a, const node& b) -> bool {
return a.b < b.b;
});
double res = inf;
for (int i = 0; i <= k; i++) res = min(res, work(i));
cout << fixed << setprecision(12) << res;
}
```
:::::
## [LC3049 标记所有下标的最早秒数 II](https://leetcode.cn/problems/earliest-second-to-mark-indices-ii/description/)
> 给出长为 $n$ 的数组 $a_i$ 和长为 $b_i$ 的数组 $b_i$。在 $1\sim m$ 的每个时刻 $t$,可以进行如下操作之一或不操作:
>
> - 选择下标 $i$,令 $a_i\gets a_i-1$;
> - 令 $a_{b_t}\gets0$;
> - 选择下标 $i$,满足 $a_i=0$ 并标记下标 $i$。
>
> 求出标记所有下标的最短时间。
>
> $n,m\le5000$。
:::::success[题解]
考虑二分答案 $k$ 转判定。
记 $f_i$ 为数组 $b$ 中下标 $i$ 首次出现的位置,没有则 $f_i=+\infty$。钦定一个进行清零操作的下标集合 $S$,则有必要条件
$$
\max\left(\max_{i\in S}f_i,\sum\limits_{i\notin S}a_i+n+|S|\right)\le k
$$
上述条件不充分的原因是,$\max\limits_{i\in S}f_i$ 并不是集合 $S$ 全部标记的时间。由于在清零后才能标记,$S$ 的一段后缀会相互冲突,导致实际时间增大。
考虑将 $S$ 中的元素按 $f_i$ 降序排序。当我们取前 $j$ 大的出现位置时,总共需要 $2j$ 个时刻,且应当在时间段 $[f_j,k]$ 中。列出不等式并整理得 $f_j+2j-1\le k$。
这是 $S$ 合法的充要条件,可以在 $O(n)$ 时间内判定。基于此,考虑贪心:按照 $a_i$ 降序排序,并逐个确定 $i$是否能被归入$S$。这是简单的,将其归入以后检查条件是否满足,不满足就直接删去即可。
复杂度 $O(n^2\log m)$。
:::::
:::::info[代码]
```cpp line-numbers
class Solution {
public:
using i64 = long long;
int earliestSecondToMarkIndices(vector<int>& a, vector<int>& b) {
int n = a.size(), m = b.size();
if (n > m) return -1;
a.insert(a.begin(), -1), b.insert(b.begin(), -1);
vector<int> f(n + 5, 1e9);
for (int i = m; i >= 1; i--) f[b[i]] = i;
auto check = [&](int k) -> bool {
vector<int> vec;
for (int i = 1; i <= n; i++) {
if (a[i] > 0 && f[i] <= k) vec.emplace_back(i);
}
sort(vec.begin(), vec.end(), [&](int i, int j) -> bool {
return a[i] > a[j];
});
vector<int> cnt(k + 5);
i64 sz = 0, sum = 0;
for (int i : vec) {
cnt[f[i]]++, sz++;
bool ok = true;
int suf = 0;
for (int j = k; j >= 1; j--) {
suf += cnt[j];
if (2 * suf > k - j + 1) {
ok = false; break;
}
}
if (ok) sum += a[i];
else cnt[f[i]]--, sz--;
}
i64 tot = n + accumulate(a.begin() + 1, a.begin() + n + 1, 0LL);
return tot - sum + sz <= k;
};
int l = n, r = m, res = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) res = mid, r = mid - 1;
else l = mid + 1;
} return res;
}
};
```
:::::
## [P3620 [APIO/CTSC2007] 数据备份](https://www.luogu.com.cn/problem/P3620)
> 在数轴上有 $n$ 个点,第 $i$ 个点位于 $a_i$,保证 $a_i$ 严格递增。你需要将点两两配对,形成 $k$ 对,代价定义为每对点坐标差之和。最小化代价并输出。
>
> $n\le10^5$,1 秒,125 MB。
:::::success[题解]
求出 $a_i$ 的差分数组 $d_i=a_i-a_{i-1}$ 并钦定 $d_1=d_{n+1}=+\infty$,问题转化为:一次操作删除一个 $d_i$ 并禁止其左右的数被删除,需要删除 $k$ 次并最小化被删数之和。
考虑反悔贪心,动态调整。删去点 $i$ 后引入一个反悔决策,这个决策的代价为 $d_{i-1}+d_{i+1}-d_i$,表示反悔掉 $i$ 并选择 $i$ 的左右两侧。
可以证明,当必须反悔掉 $i$ 时,其左右两侧的元素必然被选择。
考虑扩展这一做法。可以使用双向链表维护每个 $i$ 的前驱后继,这样反悔决策的代价容易计算。类似 sp trick 使用一个小根堆维护,并且懒惰删除,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5, inf = 2e9;
using node = pair<int, int>;
int n, k, a[N], d[N], L[N], R[N];
priority_queue<node, vector<node>, greater<node>> q;
void _main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], d[i] = a[i] - a[i - 1];
d[1] = inf, d[n + 1] = inf;
for (int i = 1; i <= n; i++) q.emplace(d[i], i), L[i] = i - 1, R[i] = i + 1;
i64 res = 0, cnt = 0;
while (!q.empty()) {
auto [w, x] = q.top(); q.pop();
if (w != d[x]) continue;
res += w;
if (++cnt >= k) break;
d[x] = d[L[x]] + d[R[x]] - w, q.emplace(d[x], x);
d[L[x]] = inf, L[x] = L[L[x]], R[L[x]] = x;
d[R[x]] = inf, R[x] = R[R[x]], L[R[x]] = x;
}
cout << res;
}
```
:::::
:::::success[另解 1]
反悔贪心做法的正确性不容易说明,考虑引入模拟费用流的观点。
将点按照奇偶性分类。如下建边:
- $S\to S'$:容量为 $k$,费用为 $0$,限制整个网络的流量;
- $S'\to2i+1$:容量为 $1$,费用为 $1$;
- $2i+1\to2i$:容量为 $1$,费用为 $d_{2i+1}-d_{2i}$,用于描述限制。同理建立 $2i+1\to2i+2$ 的边;
- $2i\to T$:容量为 $1$,费用为 $0$。
则答案为 $S\to T$ 的最小费用最大流。
考虑模拟费用流的过程,每次找出增广路并建立反向边,此时反向边的边权恰好是 $d_{i-1}+d_{i+1}-d_i$。于是用堆来模拟增广路,双向链表维护网络图形态,就说明了反悔贪心的正确性。
:::::
:::::success[另解 2]
设 $f(x)$ 为 $k=x$ 时的答案,我们猜测 $f$ 是下凸函数。严谨证明考虑另解 1 中建模为费用流,LP 问题具有凸性。
套路地考虑 WQS 二分切线斜率 $h$,构造 $g(x)=f(x)-hx$,将求 问题转化为求 $g$ 的谷点 $x_0$。
这相当于每次配对带上 $h$ 的代价。考虑 DP,令 $f_{0/1,i}$ 为考虑前 $i$ 个点,是否将 $(i-1,i)$ 配对的最小代价。转移为
$$
f_{0,i}=\min(f_{0,i-1},f_{1,i-1})\\
f_{1,i}=f_{0,i-1}+a_i-a_{i-1}-h
$$
在 DP 转移时记录决策点,从最优解推回来即可得到配对数 $x_0$。
复杂度 $O(n\log n)$。
:::::
## [QOJ6744 Square](https://qoj.ac/problem/6744)
> 给出正整数 $x,y$,一次操作可以令 $x\gets x-1$ 或 $x\gets x+\lfloor\sqrt{2x}+1.5\rfloor$,求将 $x$ 变成 $y$ 的最小操作次数。
>
> 多测,$T\le10^5$,$1\le x,y\le10^{18}$,1 秒,1024 MB。
:::::success[题解]
特判 $x\ge y$ 的情形,此时只能做减法,操作次数 $x-y$。
考虑刻画 $x\gets x+\lfloor\sqrt{2x}+1.5\rfloor$ 这个奇妙操作。我们充分发扬人类智慧,考虑画出一个数字三角形:
```plain
1
2 3
4 5 6
7 8 9 10
```
于是加法就变成了在三角形上向下走一行。
记 $x,y$ 所在行为 $r_x,r_y$。考虑此时的最优策略,不难发现只有以下两种:
- 直接走到 $r_y$ 再向左平移;
- 退到 $r_x-1$ 然后向下走到 $r_y$。
两种策略都可以通过推柿子 $O(1)$ 得到答案。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
int x, y;
int E(int r) {return r * (r + 1) / 2;}
int R(int x) {
if (x <= 0) return 0;
int r = sqrt(2 * x);
if (r * (r + 1) < 2 * x) r++;
return r;
}
void _main() {
cin >> x >> y;
if (x >= y) return cout << x - y << '\n', void();
int rx = R(x), ry = R(y), r1 = R(y + E(rx) - x);
int v1 = r1 - rx + x + E(r1) - E(rx) - y;
int v2 = x - E(rx - 1) + ry - rx + 1 + E(ry) - y;
cout << min(v1, v2) << '\n';
}
```
:::::
## [QOJ9675 电池检测](https://qoj.ac/problem/9675)
> 现有 $a$ 个 $1$ 和 $b$ 个 $0$。你每轮可以选择两个未知元素,若两个元素都为 $1$ 则检查成功,否则失败。你可以得知检查的结果。求最坏情况下使得检查成功的最小检查次数。
>
> 多测,$T\le10^3$,$a,b\le10^3$,1 秒,1024 MB。
:::::success[题解]
考虑 $a\ge b+2$ 的部分分。此时 $1$ 的数目充足,可以直接将元素两两配对,进行独立检查。由抽屉原理,必然存在一组成功,检测次数为 $b+1$。
对于 $a\le b+1$ 的情形,最优策略为:将 $a+b$ 个元素均分为 $a-1$ 组,组内两两配对。令 $q=\lfloor\frac{a+b}{a-1}\rfloor,r=(a+b)\bmod(a-1)$,则有 $r$ 个组包含 $q+1$ 个元素,$a-1-r$ 个组包含 $q$ 个元素。此时的答案为
$$
r\binom{q}{2}+(a-1-r)\binom{q-1}{2}
$$
下面证明这一策略最优。
Turán 定理指出,若图 $G$ 具有 $n$ 个顶点且不存在大小 $\ge k$ 的团,则将顶点平均分为 $k-1$ 组,组内不连边,组与组之间两两连边,可以使得 $G$ 的边数最大化。图 $G$ 称为 Turán 图。
图论建模,对于每次检查的元素 $u,v$,都建立无向边 $(u,v)$。此时你需要最小化边数,并且建立的图中不能存在大小为 $a$ 的独立集。否则最坏情况 $1$ 全部位于这个独立集中,检查就失败了。
对于上述问题,将其取补图,则构造 Turán 图最优。得证。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
int a, b;
void _main() {
cin >> a >> b;
if (a >= b + 2) return cout << b + 1 << '\n', void();
int q = (a + b) / (a - 1), r = (a + b) % (a - 1);
cout << r * q * (q + 1) / 2 + (a - 1 - r) * q * (q - 1) / 2 << '\n';
}
```
:::::
## [ARC073E Ball Coloring](https://www.luogu.com.cn/problem/AT_arc073_c)
> 给出 $n$ 对数 $(x_i,y_i)$。现有两个多重集 $A,B$,对于每个 $i$,你需要将 $x_i,y_i$ 中的一个数归入 $A$,另一个数归入 $B$。最小化 $(\max A-\min A)(\max B-\min B)$ 并输出。
>
> $n\le2\times10^5$,2 秒,256 MB。
:::::success[题解]
我们注意到给出的 $2n$ 个数中,总会存在最小值和最大值,它们一定会成为集合中的最值。
不妨令 $x\le y$,我们可以求出 $x_i$ 的范围 $[a_1,a_2]$ 和 $y_i$ 的范围 $[b_1,b_2]$。分类讨论:
- 当 $a_1\in A\land b_2\in B$ 时,答案式为 $(\max A-a_1)(b_2-\min B)$。注意到极差积满足四边形不等式 $a\le b\le c\le d\implies(a-b)(c-d)\le(a-c)(b-d)$,所以我们的策略为将较小的分给 $A$,较大的分给 $B$,答案为 $(a_2-a_1)(b_2-b_1)$。
- 当 $a_1\in A\land b_2\in A$ 时,答案式为 $(b_2-a_1)(\max B-\min B)$,所以我们只需考虑最小化 $B$ 的极差。
将所有数对按 $x_i$ 升序排序,采取调整法。初始时,全部选择 $x$,则极差为 $\max x-\min x$。
为了缩小极差,我们设法提高最小值,即将 $x_i$ 替换为 $y_i$。如果还想提高最小值,就继续替换 $x_{i+1}\to y_{i+1}$。因此,我们枚举一个分界点 $k$,将前缀 $[1,k]$ 中的数由 $x$ 换成 $y$,并且计算答案即可。
最后两种情况取 $\min$。复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 2e5 + 5, inf = 2e18;
int n;
pair<int, int> a[N];
void _main() {
cin >> n;
int a1 = inf, a2 = 0, b1 = inf, b2 = 0;
for (int i = 1, x, y; i <= n; i++) {
cin >> x >> y;
if (x > y) swap(x, y);
a[i] = {x, y};
a1 = min(a1, x), a2 = max(a2, x), b1 = min(b1, y), b2 = max(b2, y);
}
sort(a + 1, a + n + 1);
int res = a2 - a1, c1 = inf, c2 = 0;
for (int i = 1; i < n; i++) {
c1 = min(c1, a[i].second), c2 = max(c2, a[i].second);
res = min(res, max(c2, a2) - min(c1, a[i + 1].first));
}
cout << min((a2 - a1) * (b2 - b1), (b2 - a1) * res);
}
```
:::::
## [CF525D Arthur and Walls](https://www.luogu.com.cn/problem/CF525D)
> 给你一个 $n\times m$ 的网格图,图上有障碍和空地。你需要删除一些障碍,使得所有连通块的形状都是矩形。最小化删除的障碍数并给出构造。
>
> $n,m\le2000$,2 秒,500 MB。
:::::success[题解]
这是官方做法,对局部贪心。
我们关注每个障碍的周围形态,那么下面这四种情况是不合法的构造中一定会出现的:
```
#. .# .. ..
.. .. #. .#
```
对于这四种情况,我们将 `#` 调整为空地。这个调整会导致周围 $8$ 个方向的连通性改变,我们可以直接 DFS 下去。
由于每个位置至多修改一次,DFS 时注意剪掉空地的位置,那么复杂度即严格 $O(nm)$。
本题使用 DFS 贪心有一些神秘的问题,会因为爆栈 RE on #92。需要使用一些玄学的方法,比如开 C++17、加 `inline`、换递归顺序等。避免这种情况的方法可以是用 BFS、也可以用另解中的方法。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2005;
int n, m;
char s[N][N];
inline void dfs(int x, int y) {
if (x <= 0 || y <= 0 || x > n || y > m || s[x][y] == '.') return;
if (s[x + 1][y] == '.' && s[x + 1][y + 1] == '.' && s[x][y + 1] == '.') s[x][y] = '.';
if (s[x - 1][y] == '.' && s[x - 1][y - 1] == '.' && s[x][y - 1] == '.') s[x][y] = '.';
if (s[x + 1][y] == '.' && s[x + 1][y - 1] == '.' && s[x][y - 1] == '.') s[x][y] = '.';
if (s[x - 1][y] == '.' && s[x - 1][y + 1] == '.' && s[x][y + 1] == '.') s[x][y] = '.';
if (s[x][y] == '*') return;
dfs(x + 1, y + 1), dfs(x + 1, y - 1), dfs(x - 1, y + 1), dfs(x - 1, y - 1);
dfs(x + 1, y), dfs(x - 1, y), dfs(x, y + 1), dfs(x, y - 1);
}
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> (s[i] + 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] == '*') dfs(i, j);
}
}
for (int i = 1; i <= n; i++) cout << (s[i] + 1) << '\n';
}
```
:::::
:::::success[另解]
这是我的做法,对整体贪心。
我们容易预处理出每个连通块的四个边界。那么边界内所有障碍是要删掉的。
但是我们发现,删掉障碍会导致两个连通块合并。为此,我们使用带权并查集来维护,在并查集中记录当前连通块的四个边界。
实现时,我们维护一个队列,做类似 BFS 的扩展,队列中存储连通块的代表元。每次删除障碍,将障碍所属的连通块再次入队。
考虑到外层 BFS 会运行多次,我们需要对每行再维护一个并查集,路径压缩存储下一个障碍的位置,从而快速跳过空地的位置。这样一来,寻找障碍的时间变为 $O(\log m)$。
每个位置只会修改一次,且连通块入队次数不超过 $O(nm)$,则总复杂度 $O(nm\log nm)$。
[提交记录](https://codeforces.com/contest/525/submission/367326075) & [代码](https://www.luogu.me/paste/qamof16x)。
:::::
## [P16325 【MX-J29-T4】XOR and Swap](https://www.luogu.com.cn/problem/P16325)
> 给出 $0\sim2^n-1$ 的两个排列 $p_i,q_i$,下标从 $0$ 开始。一次操作选择下标 $i,j$,满足 $p_i\oplus p_j\le i\oplus j$,然后交换 $p_i,p_j$。要求构造一组操作方案,使得排列 $p_i$ 变为 $q_i$。
>
> $n\le20$,满分操作次数 $2.1\times10^6$,5 秒,512 MB。
:::::success[题解]
注意到操作是可逆的,且操作次数大概是 $2\times2^n$。这启发我们用 $2^n$ 次操作将 $p,q$ 变成同一个状态,然后两段操作拼起来得到构造。
不妨取目标状态 $a_i=i$ 观察是否可行。
考虑连边 $i\to p_i$ 形成若干交换环,目标为 $2^n$ 个自环。由于环上的边权异或和为 $0$,一个非自环上必然存在一对可以交换的元素。直接暴力可以做到 $O(4^n)$,获得 [34pts](https://www.luogu.com.cn/record/274446529)。
在 $x,y$ 交换时必有 $p_x\oplus p_y\le x\oplus y$ 且钦定 $p_y=x$,代换两边得 $p_x\oplus x\le p_y\oplus y$。因此动态维护 $w_x=p_x\oplus x$,每次找到 $w_x$ 最小且未归位的 $x$ 交换即可。
可以记一下逆排列,然后用一个小根堆懒惰删除维护,复杂度 $O(n2^n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e6 + 5;
int n, a[N], b[N], rev[N];
using node = pair<int, int>;
vector<node> solve(int* a, int n) {
for (int i = 0; i < n; i++) rev[a[i]] = i;
vector<node> op;
priority_queue<node, vector<node>, greater<node>> q;
for (int i = 0; i < n; i++) if (a[i] != i) q.emplace(i ^ a[i], i);
while (!q.empty()) {
auto [w, x] = q.top(); q.pop();
if (a[x] == x || (a[x] ^ x) != w) continue;
int y = rev[x];
op.emplace_back(x, y), swap(a[x], a[y]);
rev[a[x]] = x, rev[a[y]] = y;
if (a[y] != y) q.emplace(y ^ a[y], y);
}
return op;
}
void _main() {
cin >> n;
for (int i = 0; i < (1 << n); i++) cin >> a[i];
for (int i = 0; i < (1 << n); i++) cin >> b[i];
auto A = solve(a, 1 << n), B = solve(b, 1 << n);
reverse(B.begin(), B.end());
cout << A.size() + B.size() << '\n';
for (auto& i : A) cout << i << '\n';
for (auto& i : B) cout << i << '\n';
}
```
:::::
## [P3619 魔法](https://www.luogu.com.cn/problem/P3619)
> 给出 $n$ 个任务 $(a_i,b_i)$。有一个当前时间 $k$,每次可以选择一个没有被选过的任务,满足 $k>a_i$ 然后令 $k\gets k+b_i$。要求始终有 $k>0$。问是否能全部选完。
>
> 多测,$ T \le 10$,$n, k, a_i, |b_i| \le 10^5$,1 秒,128 MB。
:::::success[题解]
自己做的时候想到的贪心思路是:在当前允许的范围内,选择$b_i$ 最大的做。
这是错的。考虑 $k=12$,两组任务 $(5,-4)$ 和 $(9,-5)$。
考虑 $b_i\ge0$ 时,上述策略确实是正确的。所以我们先做完 $b_i\ge0$ 的所有任务。如果做不完,做 $b_i<0$ 更不可能,故无解。
考虑做 exchange argument。对于局部的 $(a_i,b_i)$ 和 $(a_j,b_j)$,若先 $i$ 后 $j$ 可行而先 $j$ 后 $i$ 不可行,有
$$
a_i<T\land a_j<k+b_i\\
a_j<T\land a_i\ge k+b_i
$$
上下两式相加并移项整理
$$
a_i+b_i>k>a_j+b_j
$$
按 $a_i+b_i$ 降序排序显然满足严格全序。排序以后继续模拟,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
i64 n, k;
using node = pair<int, int>;
void _main() {
cin >> n >> k;
vector<node> x, y;
for (int i = 1, a, b; i <= n; i++) {
cin >> a >> b;
if (b >= 0) x.emplace_back(a, b);
else y.emplace_back(a, b);
}
sort(x.begin(), x.end());
for (auto& [a, b] : x) {
if (a >= k) return cout << "-1s\n", void();
k += b;
}
sort(y.begin(), y.end(), [](const node& a, const node& b) -> bool {
return a.first + a.second > b.first + b.second;
});
for (auto& [a, b] : y) {
if (a >= k) return cout << "-1s\n", void();
k += b;
if (k <= 0) return cout << "-1s\n", void();
}
cout << "+1s\n";
}
```
:::::
:::::success[另解]
还是先做完 $b_i\ge0$ 的所有任务。对于 $b_i<0$ 的任务,将这个过程倒过来。
记 $S=\sum\limits_{i=1}^n-b_i[b_i<0]$。则完成所有任务时满足 $k\ge S$。
每完成一个负收益任务,我们有 $k\gets k-(-b_i)$。故上一个任务的完成需满足 $k\ge a_i-(-b_i)$。
因此,令 $a_i\gets a_i+b_i,b_i\gets-b_i$,问题转化为 $b_i\ge0$ 的情形,可以套用相同的方法解决。
可以发现这个视角推导出的结果也是按 $a_i+b_i$ 排序。
:::::
## [ABC167F Bracket Sequencing](https://www.luogu.com.cn/problem/AT_abc167_f)
> 给出 $n$ 个字符串,字符集为 $\{\tt{(},\tt{)}\}$。你可以以任意顺序连接所有 $S_i$,问是否可以构成一个合法括号序列。
>
> $n,\sum|S_i|\le10^6$,2 秒,1024 MB。
:::::success[题解]
令左括号为 $1$,右括号为 $-1$,则一个序列合法,当且仅当序列的和为 $0$,且最小前缀和为 $0$。
考虑对于每个字符串,求出其和 $x_i$ 和最小前缀和 $y_i$。此时 $\sum x_i=0$ 是整体合法的必要条件。
记当前总和为 $k$,则选择第 $i$ 个字符串要求 $k+y_i\ge0$,选完后 $k\gets k+x_i$。分类讨论:
- 若 $x_i\ge0\land y_i\ge0$:一定先选,且顺序无关;
- 若 $x_i\ge0\land y_i<0$:按 $y_i$ 升序排序选择即可;
- 若 $x_i<0\land y_i\ge0$:根据定义,这种情况不可能出现;
- 若 $x_i<0\land y_i<0$:可以转化为 [P3619](https://www.luogu.com.cn/problem/P3619),做 exchange argument 或者时光倒流,得到按 $x_i-y_i$ 降序排序选择。
复杂度 $O(\sum|S_i|+n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e6 + 5, inf = 1e9;
int n, m;
using node = pair<int, int>;
vector<node> A, B, C;
void _main() {
cin >> n;
int sum = 0;
for (int i = 1; i <= n; i++) {
string s; cin >> s;
int x = 0, y = inf;
for (char c : s) x += (c == '(' ? 1 : -1), chkmin(y, x);
sum += x;
if (x >= 0 && y >= 0) A.emplace_back(x, y);
else if (x >= 0 && y < 0) B.emplace_back(x, y);
else C.emplace_back(x, y);
}
if (sum != 0) return cout << "No", void();
int cur = 0;
for (auto [x, y] : A) cur += x;
sort(B.begin(), B.end(), [](const node& a, const node& b) -> bool {
return a.second > b.second;
});
for (auto [x, y] : B) {
if (cur + y < 0) return cout << "No", void();
cur += x;
}
sort(C.begin(), C.end(), [](const node& a, const node& b) -> bool {
return a.first - a.second > b.first - b.second;
});
for (auto [x, y] : C) {
if (cur + y < 0) return cout << "No", void();
cur += x;
}
cout << "Yes";
}
```
:::::
## [ABC433E Max Matrix 2](https://www.luogu.com.cn/problem/AT_abc433_e)
> 给出 $n,m$,你需要构造一个 $n\times m$ 的矩阵,其中每行的最大值为 $r_i$,每列的最大值为 $c_i$。要求矩阵中元素构成 $1\sim nm$ 的排列。给出构造或报告无解。
>
> 多测,$\sum nm\le2\times10^5$,2 秒,1024 MB。
::::::success[题解]
观察性质起手,有如下几个显然的观察:
- 若一个数在 $r_i$ 或 $c_i$ 中出现 $\ge2$ 次则无解。
- 若一个数在 $r_i$ 和 $c_i$ 中都出现,则可以确定这个数的位置。称这类数为一类数。
- 全局最大值 $nm$ 必然为一类数,否则无解。
考虑本题的思路:
1. 枚举值,填入对应格子;
2. 枚举格子,找到对应的值。
这两种方法在本题中都会用到。下面我们先采用第一种思路:
首先,我们将所有一类数填入。然后考虑在 $r_i$ 和 $c_i$ 中出现恰好一次的数,称其为二类数。考虑二类数的约束,其需要填入某个特定行列,且不能破坏其他位置的约束。
注意到,二类数的数目不会超过 $n+m-1$ 个。因此有较为巧妙的构造:钦定另一个不确定的维度与数 $nm$ 相同。如图:

对于蓝色的二类数,其列数已经确定(即图中蓝线),此时将其行钦定为与 $nm$ 相同(即图中红色横线)。
通过这种操作,可以将所有二类数归位。接下来还有一种两维都不确定的数,称之为三类数。
此时我们换一个视角,使用思路二。对于格子 $(x,y)$,其能填入三类数 $v$ 的充要条件为 $v>r_x\land v>c_y\iff v>\min(r_x,c_y)$。从大到小枚举三类数,然后将格子按 $\min(r_x,c_y)$ 排序依次配对即可。
过程中注意判定无解。复杂度 $O(nm\log nm)$。
::::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
using node = pair<int, int>;
int n, m, r[N], c[N], rp[N], cp[N];
void _main() {
cin >> n >> m;
fill(rp + 1, rp + n * m + 1, -1), fill(cp + 1, cp + n * m + 1, -1);
for (int i = 1; i <= n; i++) cin >> r[i];
for (int i = 1; i <= m; i++) cin >> c[i];
for (int i = 1; i <= n; i++) {
if (rp[r[i]] != -1) return cout << "No\n", void();
rp[r[i]] = i;
}
for (int i = 1; i <= m; i++) {
if (cp[c[i]] != -1) return cout << "No\n", void();
cp[c[i]] = i;
}
if (rp[n * m] == -1 || cp[n * m] == -1) return cout << "No\n", void();
vector<vector<int>> a(n + 5, vector<int>(m + 5, -1));
set<int> st;
for (int i = 1; i <= n * m; i++) st.emplace(i);
for (int i = 1; i <= n * m; i++) {
if (rp[i] != -1 && cp[i] != -1) {
if (a[rp[i]][cp[i]] != -1) return cout << "No\n", void();
a[rp[i]][cp[i]] = i, st.erase(i);
}
}
for (int i = n * m - 1; i >= 1; i--) {
if (rp[i] != -1 && cp[i] == -1) {
if (a[rp[i]][cp[n * m]] != -1) return cout << "No\n", void();
a[rp[i]][cp[n * m]] = i, st.erase(i);
}
if (cp[i] != -1 && rp[i] == -1) {
if (a[rp[n * m]][cp[i]] != -1) return cout << "No\n", void();
a[rp[n * m]][cp[i]] = i, st.erase(i);
}
}
vector<node> vec;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == -1) vec.emplace_back(i, j);
}
}
sort(vec.begin(), vec.end(), [](const node& a, const node& b) -> bool {
return min(r[a.first], c[a.second]) > min(r[b.first], c[b.second]);
});
for (auto [x, y] : vec) {
int v = *st.rbegin(); st.erase(--st.end());
if (v > r[x] || v > c[y]) return cout << "No\n", void();
a[x][y] = v;
}
cout << "Yes\n";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << a[i][j] << ' ';
cout << '\n';
}
}
```
:::::
## [P14180 「FAOI-R8」奶龙大战暴暴龙](https://www.luogu.com.cn/problem/P14180)
> 给出两个长为 $n,m$ 的数组 $a_i,b_i$。一次操作选择 $l,r,k$,满足 $1\le l\textcolor{red}{<}r\le n$,然后将 $a$ 的子数组 $[l,r]$ 移除,再插入到第 $k$ 个元素后。
>
> 你需要在至多 $\max(n,m)$ 次操作后将 $a_i$ 变成 $b_i$,给出构造或报告无解。
>
> 多测,$T\le30$,$1\le n,m,a_i,b_i\le5\times10^4$,0.5 秒,512 MB。
:::::success[题解]
首先判掉一些显然的无解情形:$n\ne m$ 或者 $a_i,b_i$ 构成的多重集不同。
因为操作次数为 $n$,我们想到逐个让 $a_i\gets b_i$。从左到右扫描 $i$,找到第一个 $b_i$ 出现的位置 $p$:
- 若 $p\ne n$:将后缀 $[p,n]$ 移动过来。
- 若 $p=n$:
- 若 $i<n-1$:将 $[i,p)$ 放到末尾。
- 若 $i=n-1$:此时形如 `1 2 4 3` 变 `1 2 3 4`,我们有如下操作方法:`[1 2] 4 3` 变 `4 [1 2 3]` 变 `1 2 3 4`。
注意特判 $n=3$ 的 corner case。操作次数显然不大于 $n$。
直接模拟上述构造,复杂度 $O(n^2)$,可以获得 [85pts](https://www.luogu.com.cn/record/275462710)。
考虑用数据结构模拟上述过程,需要模拟操作和找出现位置。一个魔怔的做法是 FHQ-Treap 套 bitset,复杂度 $O\left(\frac{nV\log n}{w}\right)$,可以获得 [25pts](https://www.luogu.com.cn/record/275475464)。
较为人类的做法:维护 FHQ-Treap 的父节点,然后对于每个值开队列维护对应的节点指针,查询的时候跳根链得到下标。复杂度 $O(n\log n)$,可以通过。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 5e4 + 5;
int h, n, m, a0[N], b0[N], a[N], b[N];
vector<tuple<int, int, int>> vec;
struct node {
u32 pri; int val, sz;
node *l, *r, *f;
node(int v = 0) :
pri(rand32()), val(v), sz(1), l(nullptr), r(nullptr), f(nullptr) {}
node* pushup() {
sz = 1;
if (l) sz += l->sz, l->f = this;
if (r) sz += r->sz, r->f = this;
return this;
}
};
void split(node* u, int k, node*& x, node*& y) {
if (!u) return x = y = nullptr, void();
int ls = u->l ? u->l->sz : 0;
if (ls < k) x = u, split(u->r, k - ls - 1, x->r, y), x->pushup(), x->f = nullptr;
else y = u, split(u->l, k, x, u->l), y->pushup(), y->f = nullptr;
}
node* merge(node* u, node* v) {
if (!u || !v) return u ? u : v;
return u->pri < v->pri
? (u->r = merge(u->r, v), u->f = nullptr, u->pushup())
: (v->l = merge(u, v->l), v->f = nullptr, v->pushup());
}
node *T;
deque<node*> pos[N];
void op(int l, int r, int k) {
node *a, *b, *c, *d, *e, *f;
split(T, r, a, c), split(a, l - 1, a, b);
d = merge(a, c), split(d, k, e, f);
T = merge(merge(e, b), f);
vec.emplace_back(l, r, k);
}
int ask(node* u) {
int p = (u->l ? u->l->sz : 0) + 1;
for (; u->f; u = u->f)
if (u == u->f->r) p += (u->f->l ? u->f->l->sz : 0) + 1;
return p;
}
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i], a0[i] = a[i];
for (int i = 1; i <= m; i++) cin >> b[i], b0[i] = b[i];
if (n != m) return cout << -1 << '\n', void();
sort(a0 + 1, a0 + n + 1), sort(b0 + 1, b0 + n + 1);
for (int i = 1; i <= n; i++) if (a0[i] != b0[i]) return cout << -1 << '\n', void();
if (n == 3) {
if (a[1] == b[1] && a[2] == b[2]) cout << 0 << '\n';
else if (a[1] == b[2] && a[2] == b[3]) cout << "1\n1 2 1\n";
else if (a[2] == b[1] && a[3] == b[2]) cout << "1\n2 3 0\n";
else cout << -1 << '\n';
return;
}
T = nullptr, vec.clear();
for (int i = 1; i <= n; i++) pos[a[i]].clear();
for (int i = 1; i <= n; i++) {
node *u = new node(a[i]);
pos[a[i]].emplace_back(u), T = merge(T, u);
}
for (int i = 1; i <= n; i++) {
node *u = pos[b[i]].front();
pos[b[i]].pop_front();
int p = ask(u);
if (p == i) continue;
if (p != n) op(p, n, i - 1);
else if (i != p - 1) op(i, p - 1, i);
else op(n - 3, n - 2, n - 3), op(n - 2, n, n - 4);
}
cout << vec.size() << '\n';
for (auto [l, r, k] : vec) cout << l << ' ' << r << ' ' << k << '\n';
}
```
:::::
## [ZR3589 彩虹剖分](https://zhengruioi.com/problem/3589)
> 现有一个凸 $n$ 边形,第 $i$ 个顶点的颜色为 $a_i$,其中 $a_i \in \{0,1,2\}$。找到多边形的三角剖分方案,使得任意三角形的顶点颜色互不相同。
>
> 输出构造或报告无解。
>
> $3 \le n \le 10^6$,2 秒,1024 MB。
:::::success[题解]
考虑如何判定。我们提出如下两条必要条件:
- 不存在相邻同色顶点。
- 颜色种类数恰为 $3$。
必要性显然,充分性由下面的构造做法导出。
三角剖分是一个很适合归纳构造的问题。对于一个凸 $n$ 边形,我们钦定三角剖分的一条对角线后,就可以将问题规约为两个子问题。故只要考虑对角线如何选取。
可以发现,只要对角线两端的顶点异色,条件一自然满足。为了满足条件二,我们钦定对角线的端点颜色为当前**出现次数最少**的颜色。、
设子问题为凸 $m$ 边形,顶点标号为 $0 \sim m-1$。不妨设标号 $0$ 即为对角线的一端。我们从 $0$ 开始,向两个方向各扫描一次,找到第一个 $l,r$ 使得 $0 \to l$ 和 $0 \to r$ 上三种颜色均出现,则标号在 $[l,r]$ 中的顶点作另一端点均合法。
为了分治平衡,我们在 $[l,r]$ 中选取最接近 $\frac{m}{2}$ 的位置作为另一端点,并从这里劈开分治。考虑 $l \le \frac{2}{3}n$ 且 $r \ge \frac{1}{3}n$,从而最劣情形只会将问题分成 $\frac{1}{3}{n}$ 和 $\frac{2}{3}n$ 规模,对应分治深度为 $\log_{1.5}n$,总复杂度 $O(n \log n)$ 可以通过。
**注意输出构造时需满足 $\mathbf{u < v}$。** 模拟赛 $100 \to 0$。
:::::
:::::info[题解]
```cpp line-numbers
const int N = 1e6 + 5;
int n, a[N], c[3];
using node = pair<int, int>; // (col, id)
vector<pair<int, int>> vec;
void solve(vector<node> cur) {
if (cur.size() == 3) return;
int cnt[3] = {0, 0, 0};
for (auto [c, id] : cur) cnt[c]++;
int p = min_element(cnt, cnt + 3) - cnt;
int n = cur.size();
for (int i = 0; i < n; i++) {
if (cur[i].fi != p) continue;
rotate(cur.begin(), cur.begin() + i, cur.end());
break;
}
int lo = -1, hi = -1;
bool has[3] = {0, 0, 0};
for (int i = 0; i < n; i++) {
has[cur[i].fi] = true;
if (has[0] && has[1] && has[2]) {
lo = i; break;
}
}
fill(has, has + 3, false), has[cur[0].fi] = true;
for (int i = n - 1; i >= 1; i--) {
has[cur[i].fi] = true;
if (has[0] && has[1] && has[2]) {
hi = i; break;
}
}
int half = n / 2, mid = 1e9;
for (int i = lo; i <= hi; i++)
if (abs(i - half) < abs(mid - half) && cur[i].fi != cur[0].fi) mid = i;
vec.emplace_back(cur[0].se, cur[mid].se);
vector<node> l(cur.begin(), cur.begin() + mid + 1), r(cur.begin() + mid, cur.end());
r.emplace_back(cur[0]);
solve(l), solve(r);
}
void _main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i], c[a[i]]++;
for (int i = 0; i < n; i++)
if (a[i] == a[(i + 1) % n]) return cout << -1, void();
if (c[0] == 0 || c[1] == 0 || c[2] == 0) return cout << -1, void();
vector<node> cur;
for (int i = 0; i < n; i++) cur.emplace_back(a[i], i + 1);
solve(cur);
cout << n - 3 << '\n';
for (auto [u, v] : vec) cout << min(u, v) << ' ' << max(u, v) << '\n';
}
```
:::::
## [P5521 [yLOI2019] 梅深不见冬](https://www.luogu.com.cn/problem/P5521)
> 给出一棵节点数为 $n$ 的有根树,根节点为 $1$,带点有点权 $a_u$。
>
> 你初始持有 $f_u$ 个物品,位于节点 $1$。你可以在树上进行游走,可以选择进入一个未进入的子节点,或者回到父节点。
>
> 你需要在每个节点上放置若干物品。对于非叶节点 $u$,允许在其上放置物品的条件为:每个子节点 $v$ 的物品数都恰好为 $ a_v$。
>
>你可以在任意时刻回收任意节点上的物品,且不需要走到对应点。
>
>对于$u=1,2,\cdots,n$,求出在节点 $u$ 上放置 $a_u$ 个物品所需的 $f_u$ 的最小值。
>
> $n\le10^5+4$,1 秒,500 MB。
:::::success[题解]
考虑树形 DP,设 $f_u$ 为节点答案。注意到 $u$ 点可回收的物品数恰好为 $a_u$。我们钦定某种顺序,依次游走子树 $v_1,v_2,\cdots,v_k$,那么有转移:
$$
\begin{aligned}
f_u &\gets\sum_{i=1}^{x-1}a_{v_i}+f_{v_x},x=1,2,\cdots,k\\
f_u &\gets\sum_{i=1}^k a_i+f_u
\end{aligned}
$$
根据木桶原理这里做的是 chkmax。前面这个求和式表示之前回收的物品总数,容易前缀和维护。
现在考虑如何对儿子 $v_i$ 排序,想到用 exchange argument,考虑局部,设两儿子为 $x,y$。
记前面的和式为 $S$,则讨论先 $x$ 后 $y$ 和先 $y$ 后 $x$ 所造成的局部 $\max$:
- 先 $x$ 后 $y$:
- 处理 $x$ 时的需求量为 $S+f_x$。
- 处理 $y$ 时,$S\gets S+a_x$,故需求量 $S+a_x+f_y$。
- 故局部峰值为 $\max(S+f_x,S+a_x+f_y)=S+\max(f_x,a_x+f_y)$。
- 先 $y$ 后 $x$ 同理,得局部峰值 $S+\max(f_y,a_y+f_x)$。
令 $\max(f_x,a_x+f_y)<\max(f_y,a_y+f_x)$。
根据 $a_x,a_y\ge1$,我们有 $f_x<f_x+a_y\land a_x+f_y>f_y$,故原不等式写为
$$
a_x+f_y<a_y+f_x\iff f_x-a_x>f_y-a_y
$$
得证,按 $f_v-a_x$ 降序排序即可,显然严格全序。
复杂度 $O(n\log n)$。用邻项交换贪心来确定 DP 转移顺序,十分精妙。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 10;
int n, a[N];
vector<int> e[N];
i64 f[N];
void dfs(int u) {
for (int v : e[u]) dfs(v);
sort(e[u].begin(), e[u].end(), [](int x, int y) -> bool {
return f[x] - a[x] > f[y] - a[y];
});
i64 sum = 0;
for (int v : e[u]) f[u] = max(f[u], sum + f[v]), sum += a[v];
f[u] = max(f[u], sum + a[u]);
}
void _main() {
cin >> n;
for (int i = 2, x; i <= n; i++) cin >> x, e[x].emplace_back(i);
for (int i = 1; i <= n; i++) cin >> a[i];
dfs(1);
for (int i = 1; i <= n; i++) cout << f[i] << ' ';
}
```
:::::
## [P3574 [POI 2014] FAR-FarmCraft](https://www.luogu.com.cn/problem/P3574)
> 给出一棵 $n$ 个点的有根树,根节点为 $1$。你从根节点开始游走,走过一条边的代价为 $1$,必须经过每条边恰好两次。
>
> 每个点有点权 $a_i$,当你游走到该点时,该点上会开始一个时长为 $a_i$ 的任务。最终回到根节点后,开始一个时长为 $a_1$ 的任务。最小化所有点完成任务的时间并输出。
>
> $n\le5\times10^5$,1 秒,125 MB。
:::::success[题解]
考虑树形 DP,记 $f_u$ 为 $u$ 子树内的最大时间,$g_u$ 为将子树内游走完成的总时间。如果可以钦定一个游走儿子的顺序,就有转移:
$$
\begin{aligned}
f_u &\gets\max(f_u,f_v+g_u+1)\\
g_u &\gets g_v+2
\end{aligned}
$$
关键在于确定 $f$。考虑和上一题一样做 exchange argument。考虑局部 $x,y$ 有:
- 不交换:贡献为 $\max(f_x+g_u+1,f_y+g_u+g_x+3)$;
- 交换:贡献为 $\max(f_y+g_u+1,f_x+g_u+g_y+3)$。
钦定前者更优,于是
$$
f_y+g_u+g_x+3<f_x+g_u+g_y+3\iff f_x-g_x>f_y-g_y
$$
这是一个严格偏序,按 $f_u-g_u$ 降序排序,然后做 DP 转移即可。复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 5e5 + 5;
int n, a[N], f[N], g[N];
vector<int> e[N];
void dfs(int u, int fa) {
if (fa != -1) f[u] = a[u];
vector<int> vec;
for (int v : e[u]) {
if (v == fa) continue;
dfs(v, u), vec.emplace_back(v);
}
sort(vec.begin(), vec.end(), [](int x, int y) -> bool {
return f[x] - g[x] > f[y] - g[y];
});
for (int v : vec) chkmax(f[u], f[v] + g[u] + 1), g[u] += g[v] + 2;
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
e[u].emplace_back(v), e[v].emplace_back(u);
}
dfs(1, -1);
cout << max(f[1], a[1] + g[1]);
}
```
:::::
## [QOJ3676 Joined Vessels](https://qoj.ac/problem/3676)
> 现有 $n$ 个水桶,水桶 $i,i+1$ 之间通过一根高度为 $a_i$ 的管道相连。保证 $a_i$ 两两不同。
>
> 进行 $q$ 次询问,询问直接相互独立。每轮中,选择水桶 $u_i$ 不断倒水。水的流动按照连通器原理,且认为管道足够细。求出倒水的最少体积,使得水可以到达水桶 $v_i$。
>
> $n,q\le2\times10^5$,3 秒,512 MB。
:::::success[题解]
首先,需要对 $u_i<v_i$ 和 $u_i>v_i$ 的情况讨论。这里只解决 $u_i<v_i$ 的情形,另外一种同理。
设 $u_i$ 中水的体积为 $x$。则 $x$ 有两个去向:
1. 漏到左侧。记 $m=\max\limits_{j\in[u_i,v_i)}a_j$,找到左侧第一个高于 $m$ 的水管位置,此时该水管到 $u_i$ 间的水桶被漏满,体积为 $m$。
2. 输送到右侧。从 $v_i-1$ 倒着扫,每次遇到一个后缀最大值时,水会被划分开形成若干段,形状是一个矩形。
下图展示了我们的两个观察:

第二张图中,水形成了三个矩形,这些区域是被后缀最大值分开的;第三 & 四张图中,绿色圆圈代表着我们找到的漏水终点。
直接模拟,将两种去向相加,即可做到 $O(qn)$。考虑优化:
- 计算 $m$ 的过程容易用 ST 表优化。
- 漏水的过程,可以用 ST 表二分 / 单调栈优化;
- 输水的过程,可以抽象为对于一个静态序列,多次询问 $[l,r]$ 中后缀最大值之和。这个问题有很多做法,如离线单调栈二分 / 倍增 / 楼房重建线段树等。
使用 ST 表二分 + 倍增实现,可以在线回答,复杂度 $O(q\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, q, a[N], st[18][N], L[18][N], R[18][N];
i64 Ls[18][N], Rs[18][N];
void prework() {
copy(a + 1, a + n, st[0] + 1);
for (int i = 1; (1 << i) < n; i++)
for (int j = 1; j + (1 << i) - 1 < n; j++)
st[i][j] = max(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
stack<int> st;
for (int i = 1; i < n; i++) {
while (!st.empty() && a[st.top()] < a[i]) st.pop();
L[0][i] = st.empty() ? 0 : st.top();
st.emplace(i);
}
while (!st.empty()) st.pop();
for (int i = n - 1; i >= 1; i--) {
while (!st.empty() && a[st.top()] < a[i]) st.pop();
R[0][i] = st.empty() ? n : st.top();
st.emplace(i);
}
for (int i = 1; i < n; i++) Ls[0][i] = 1LL * a[i] * (i - L[0][i]), Rs[0][i] = 1LL * a[i] * (R[0][i] - i);
R[0][n] = n;
for (int i = 1; i <= lg(n); i++)
for (int j = 0; j <= n; j++) {
L[i][j] = L[i - 1][L[i - 1][j]], R[i][j] = R[i - 1][R[i - 1][j]];
Ls[i][j] = Ls[i - 1][j] + Ls[i - 1][L[i - 1][j]];
Rs[i][j] = Rs[i - 1][j] + Rs[i - 1][R[i - 1][j]];
}
}
int qmax(int l, int r) {
int k = lg(r - l + 1);
return max(st[k][l], st[k][r - (1 << k) + 1]);
}
i64 qpre(int l, int r) {
i64 res = 0;
for (int i = lg(n); i >= 0; i--) {
if (R[i][l] > r) continue;
res += Rs[i][l], l = R[i][l];
}
return res + 1LL * a[l] * (r - l + 1);
}
i64 qsuf(int l, int r) {
i64 res = 0;
for (int i = lg(n); i >= 0; i--) {
if (L[i][r] < l) continue;
res += Ls[i][r], r = L[i][r];
}
return res + 1LL * a[r] * (r - l + 1);
}
i64 ask1(int l, int r) {
int mx = qmax(l, r - 1), lo = 1, hi = l - 1, to = l;
while (lo <= hi) {
int mid = (lo + hi) >> 1;
if (qmax(mid, l - 1) < mx) to = mid, hi = mid - 1;
else lo = mid + 1;
}
return 1LL * (l - to) * mx + qsuf(l, r - 1);
}
i64 ask2(int r, int l) {
int mx = qmax(l, r - 1), lo = r, hi = n - 1, to = r - 1;
while (lo <= hi) {
int mid = (lo + hi) >> 1;
if (qmax(r, mid) < mx) to = mid, lo = mid + 1;
else hi = mid - 1;
}
return 1LL * (to - r + 1) * mx + qpre(l, r - 1);
}
void _main() {
cin >> n;
for (int i = 1; i < n; i++) cin >> a[i];
prework(), cin >> q;
for (int u, v; q--; ) {
cin >> u >> v;
if (u < v) cout << ask1(u, v) << '\n';
else cout << ask2(u, v) << '\n';
}
}
```
:::::
## [ABC225F String Cards](https://www.luogu.com.cn/problem/AT_abc225_f)
> 给出 $n$ 个字符串 $S_i$。你需要选出 $k$ 个字符串,并按某个顺序拼接,最小化这个串的字典序并输出。
>
> $n\le50$,$|S_i|\le50$,字符集为 $\tt{a}\sim\tt{z}$,2 秒,1024 MB。
:::::success[题解]
注意到 [P1012](https://www.luogu.com.cn/problem/P1012) 即本题 $k=n$ 的特殊情形。考虑套用这个题的方法:定义 $A\prec B\iff AB<BA$,按照 $\prec$ 将字符串集合排序。可证 $\prec$ 是严格全序。
直接选择一段长为 $k$ 的前缀是错的。原因是长度不固定,如 $[\tt{ba},\tt{a},\tt{ba}]$,显然 $\tt{bab}$ 优于 $\tt{baba}$。
考虑 DP。记 $f_{i,j}$ 为考虑了**前** $i$ 个元素,当前选择了 $j$ 个元素时的最小字符串,转移为 $f_{i,j}\gets\min(f_{i-1,j},f_{i-1,j-1}S_i)$。
这个 DP 还是错的,仍然没有考虑长度变化带来的问题。如 $[\tt{b},\tt{ba},\tt{c}]$。但是我们发现字典序是正序比较的,如果倒序 DP 就不会有问题。
重设状态为:$f_{i,j}$ 表示考虑了**后** $i$ 个元素,当前选择了 $j$ 个元素时的最小字符串。转移为 $f_{i,j}\gets\min(f_{i+1,j},S_i f_{i+1,j-1})$。
视作 $n,k,|S_i|$ 同阶,复杂度 $O(n^4)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 55;
int n, k;
string s[N], f[N][N];
void _main() {
cin >> n >> k;
string inf(k, 'z' + 1);
for (int i = 1; i <= n; i++) cin >> s[i];
sort(s + 1, s + n + 1, [](const string& a, const string& b) -> bool {
return a + b < b + a;
});
fill(f[n] + 1, f[n] + k + 1, inf), f[n][1] = s[n];
for (int i = n - 1; i >= 1; i--) {
for (int j = 1; j <= k; j++) f[i][j] = min(f[i + 1][j], s[i] + f[i + 1][j - 1]);
}
cout << f[1][k];
}
```
:::::
:::::success[另解]
其实正序 DP 是可以救活的。
考虑钦定长度,记 $f_{i,j,l}$ 为考虑了**前** $i$ 个元素,当前选择了 $j$ 个元素,当前字符串的长度为 $l$ 时的最小字符串。
此时转移不会受到长度影响:$f_{i,j,l}\gets\min(f_{i-1,j,l},f_{i-1,j-1,l-|S_i|}S_i)$。
直接做的复杂度为 $O(n^6)$,在本题可以冲过去。一些魔怔的方法是用线段树合并维护一下哈希,然后二分比较字典序,可以做到 $O(n^4\log^2 n)$。
$O(n^6)$ 做法的 [submission](https://atcoder.jp/contests/abc225/submissions/74970897)。
:::::
## [P9000 [CEOI 2022] Measures](https://www.luogu.com.cn/problem/P9000)
> 数轴上初始有 $n$ 个点,位置为 $a_1,a_2,\cdots,a_n$。每个点可以以每个时刻 $1$ 个长度的速度同时移动。要求移动后任意两点之间距离不小于 $d$。
>
> 现有 $q$ 次操作,每次操作插入一个点。在每次操作后,求符合要求的最短移动时间。
>
> $n,q\le2\times10^5$,$1\le d,a_i\le10^9$,1.5 秒,512 MB。
:::::success[题解]
考虑二分答案 $x$ 转判定。贪心地,我们将所有人按照初始位置升序排序,并决策每个人的最终位置尽量靠左。记 $f_i$ 为第 $i$ 人位置的最小值,$f$ 有递推式
$$
f_i=\max(f_{i-1}+d,a_i-x)
$$
含义是 $f_i-f_{i-1}\ge d$ 和步数限制 $|f_i-a_i|\le x$。$x$ 合法当且仅当 $\forall i\in[1,n],f_i\le a_i+x$。直接做可以做到 $O(nq\log n)$。
逐项展开并归纳得 $f_i=\max\limits_{j=1}^i(a_j-x+(i-j)d)$。代入合法条件
$$
\begin{aligned}
f_i=\max\limits_{j=1}^i(a_j-x+(i-j)d)&\le a_i+x\\
\max\limits_{j=1}^i(a_j-a_i-x+(i-j)d)&\le2x\\
\dfrac{1}{2}\max_{j=1}^i(a_j-j\times d-a_i+i\times d)&\le x
\end{aligned}
$$
令 $b_i=a_i-i\times d$,则我们只要维护 $\max\limits_{1\le i\le j\le n}(b_i-b_j)$ 求得答案。直接做可以做到 $O(n^2 q)$ 到 $O(nq)$。
用权值线段树状物维护。按照 $a_i$ 的排名建线段树,并在线段树上维护每个位置的 $b_i$。插入数字 $k$ 时,我们找到 $k$ 的位置做单点修改,然后将 $[k,+\infty)$ 的一段后缀减去 $d$。注意到插入 $k$ 只会对跨过 $k$ 的 $b_i-b_j$ 有影响,故维护 $k$ 左侧的 $\max$ 和右侧的 $\min$ 即可。
综上,我们的线段树需要区间减法和区间最值,复杂度 $O(q\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 4e5 + 5, inf = 1e18;
int n, q, d, m, a[N], b[N], h[N];
void out(int x) {
if (x & 1) cout << x / 2 << ".5 ";
else cout << x / 2 << ' ';
}
struct node {
int mx, mn, cnt;
node(int a = -inf, int b = inf, int c = 0) : mx(a), mn(b), cnt(c) {}
};
node operator+ (const node& a, const node& b) {
return node{max(a.mx, b.mx), min(a.mn, b.mn), a.cnt + b.cnt};
}
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
node val[N << 2]; int tag[N << 2];
void apply(int rt, int c) {val[rt].mx += c, val[rt].mn += c, tag[rt] += c;}
void pushup(int rt) {val[rt] = val[ls] + val[rs];}
void pushdown(int rt) {
if (!tag[rt]) return;
apply(ls, tag[rt]), apply(rs, tag[rt]), tag[rt] = 0;
}
void set(int x, int c, int l = 1, int r = m, int rt = 1) {
if (l == r) return val[rt].mx = val[rt].mn = c, val[rt].cnt++, void();
int mid = (l + r) >> 1; pushdown(rt);
if (x <= mid) set(x, c, l, mid, ls);
else set(x, c, mid + 1, r, rs);
pushup(rt);
}
void update(int tl, int tr, int c, int l = 1, int r = m, int rt = 1) {
if (tl <= l && r <= tr) return apply(rt, c), void();
int mid = (l + r) >> 1; pushdown(rt);
if (tl <= mid) update(tl, tr, c, l, mid, ls);
if (tr > mid) update(tl, tr, c, mid + 1, r, rs);
pushup(rt);
}
node ask(int tl, int tr, int l = 1, int r = m, int rt = 1) {
if (tl <= l && r <= tr) return val[rt];
int mid = (l + r) >> 1; pushdown(rt);
if (tl <= mid && mid < tr) return ask(tl, tr, l, mid, ls) + ask(tl, tr, mid + 1, r, rs);
return tl <= mid ? ask(tl, tr, l, mid, ls) : ask(tl, tr, mid + 1, r, rs);
}
} T;
pair<int, int> p[N];
int pos[N];
void _main() {
cin >> n >> q >> d, m = n + q;
for (int i = 1; i <= m; i++) cin >> b[i], p[i] = {b[i], i};
sort(p + 1, p + m + 1);
for (int i = 1; i <= m; i++) pos[p[i].se] = i;
int res = 0;
for (int i = 1; i <= m; i++) {
int x = pos[i], p = T.ask(1, x).cnt + 1;
T.update(x + 1, m, -d), T.set(x, b[i] - d * p);
chkmax(res, T.ask(1, x).mx - T.ask(x, m).mn);
if (i > n) out(res);
}
}
```
:::::
## [P14891 Trink](https://www.luogu.com.cn/problem/P14891)
> 给定一棵有根树 $T$,根节点为 $1$,儿子之间区分顺序。
>
> 对上述树 $T$,定义一次变换为:
>
> - 同时考虑所有不为根的结点 $u$,如果 $u$ 不是其父亲最左的儿子,则把 $u$ 的父亲改为 $u$ 左侧的兄弟中最靠右的。
>
> 进行 $n$ 次操作,第 $i$ 次操作给定 $f_i$,新建一个标号为 $i+1$ 的节点作为 $f_i$ 最右侧的儿子。在每次操作结束后,回答如下问题:
>
> - 设对 $T$ 执行 $k$ 次变换后,再对 $T$ 执行一次变换其形态不变。求出 $k_{\min}$。
>
> $n\le10^6$,1 秒,512 MB。
:::::success[题解]
首先,一次变换的实质是将 $T$ 改为左儿子右兄弟表示法。进而不难发现如下结论:
**性质 1** 树 $T$ 在充分多次变换后,必然变成一条单链。$T$ 初次变为单链的时刻即为所求。
**性质 2** 树 $T$ 的先序遍历 DFS 序不变。
这两个结论说明,$T$ 的最终形态是唯一确定的。
想象一个节点 $u$,它的左兄弟是 $x(u)$。在首次变换时,$u$ 的父亲变为 $x$,而在后续变换中,$x$ 的原子树展开成一条链。
根据性质 2,$u$ 必须落到 $x$ 子树的链底,$u$ 掉落的步数,恰好是 $x$ 原子树的大小。记 $\text{sz}_u$ 为子树大小,上述观察表明答案为
$$
\max_{u\in T}\text{sz}_{x(u)}
$$
进一步,我们只要维护右链的左子树作为 $x$。容易说明,其余左兄弟的子树一定被这些子树包含,从而不会成为答案。

类比笛卡尔树地,使用单调栈维护右链,对新叶子的位置分类讨论:
- 若新叶子属于右链,则弹栈直到 $f_i$ 在栈顶,并将新节点入栈。对于原右链节点,可以暴力合并子树并更新答案,均摊复杂度线性。

- 若新叶子不属于右链,则找到其贡献的右链节点并更新答案。使用并查集维护代表元。

总复杂度 $O(n\alpha(n))$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e6 + 5;
int n, fa[N], sz[N], ins[N];
vector<int> ch[N];
stack<int> st;
int find(int x) {return x == fa[x] ? x : fa[x] = find(fa[x]);}
void _main() {
cin >> n, n++;
iota(fa + 1, fa + n + 1, 1);
st.emplace(1), ins[1] = true, sz[1] = 1;
int res = 0;
for (int i = 2, u; i <= n; i++) {
cin >> u;
if (ins[u]) {
while (!st.empty() && st.top() != u) {
int x = st.top(); st.pop(), ins[x] = false;
sz[x] = 1;
for (int y : ch[x]) sz[x] += sz[y], fa[y] = x;
chkmax(res, sz[x]);
}
ch[u].emplace_back(i);
st.emplace(i), ins[i] = true, sz[i] = 1;
} else {
int r = find(u);
chkmax(res, ++sz[r]), fa[i] = r;
}
cout << res << '\n';
}
}
```
:::::
## [QOJ993 100 Boxes Per Hour...](https://qoj.ac/problem/993)
> 现有 $100$ 个物品,物品有三种颜色。你可以得知 $x,y,z$ 表示不同颜色物品的数目,但不知道具体颜色。
>
> 现有两个箱子,每个箱子只能放置同色物品。物品依次加入,你需要在线地决策物品的去向。你可以将其丢弃,或者加入一个箱子。你可以在任意时刻清空箱子。
>
> 构造一种策略,使得对于任意物品序列,结束时箱子中有至少 $43$ 个物品。
>
> 采用交互方式提交。多测,$T\le100$,2 秒,512 MB。
:::::success[题解]
不妨设 $x\le y\le z$,然后分类讨论:
- 若 $100-z\ge43$,考虑直接钦定两个箱子放某两色颜色的物品,第三种颜色丢弃,此时至少可以加入 $x+y=100-z$ 个物品;
- 若 $100-3x\ge43$,考虑等到三种颜色都出现 $x+1$ 次时再放入,前 $x$ 次出现的丢弃,排除掉最小的颜色,至少可以加入 $100-3x$ 个物品。
- 若以上情况都不满足,考虑先按第一种策略放置,当一种颜色出现 $y+1$ 次时一定时最大颜色,我们清空一个箱子并重新钦定,至少可以加入 $100-2y$ 个物品。
可以说明做法的正确性:策略一可以处理 $z\le57$ 的情形,策略二可以处理 $x\le19$ 的情形,策略三可以处理 $y\le29$ 的情形。反证法可以说明三种情况已经覆盖了全部情况。
:::::
:::::info[代码]
```cpp line-numbers
int x, y, z;
void discard() {cout << "DISCARD" << endl;}
void empty(int x) {cout << "EMPTY " << x << endl;}
void place(int x) {cout << "PLACE " << x << endl;}
void sub1() {
int T = 100;
while (T--) {
char c; cin >> c;
if (c == 'R') place(1);
else if (c == 'G') place(2);
else discard();
}
}
void sub2() {
int T = 100, tot = 0;
map<char, int> cnt, pos;
while (T--) {
char c; cin >> c;
if (++cnt[c] >= x + 1) {
if (!pos.count(c)) pos[c] = ++tot;
place(pos[c]);
} else discard();
}
}
void sub3() {
int T = 100;
map<char, int> cnt, pos;
pos['R'] = 1, pos['G'] = 2;
while (T--) {
char c; cin >> c;
if (++cnt[c] >= y + 1 && !pos.count(c)) {
auto [k, v] = *pos.begin();
empty(v), pos.erase(k);
pos[c] = v;
}
if (pos.count(c)) place(pos[c]);
else discard();
}
}
void _main() {
cin >> x >> y >> z;
vector<int> vec = {x, y, z};
sort(vec.begin(), vec.end());
x = vec[0], y = vec[1], z = vec[2];
if (100 - z >= 43) sub1();
else if (100 - 3 * x >= 43) sub2();
else sub3();
}
```
:::::
## [P4665 [BalticOI 2015] Network](https://www.luogu.com.cn/problem/P4665)
> 给出一棵节点数为 $n$ 的无根树,你需要添加若干条边,使得任意一条边断开后图仍然连通。最小化加边的数目并输出构造。
>
> $n\le5\times10^5$,1 秒,500 MB。
:::::success[题解]
问题可以描述为:在树上选出若干条路径,使得每条边被覆盖一次。
任意定根,则选择叶子节点不劣。注意如果根的度数为 $1$ 则认为根也是叶子。
设叶子的数目为 $m$,则答案的下界为 $\lceil\frac{m}{2}\rceil$。考虑提出一个构造使得答案达到下界,此时等价于将叶子两两配对。
考虑将叶子定序后,将第 $i$ 个叶子配对第 $i+\lfloor\frac{m}{2}\rfloor$ 个叶子。若 $m$ 为奇数,则剩下的一个叶子配对第 $1$ 个叶子。对于非叶节点 $x$:
- 若 $x$ 子树中叶子数目 $\le\lfloor\frac{m}{2}\rfloor$,为了满足 $x\to f_x$ 需要存在向外的连边;
- 若 $x$ 子树中叶子数目 $>\lfloor\frac{m}{2}\rfloor$,同理需要存在向内的连边,此时 $x\to f_x$ 也被满足。
我们充分发扬人类智慧,注意到按 DFS 序标号后,同子树内叶子的编号连续,满足上述性质。
最终复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 5e5 + 5;
int n, dn, dfn[N];
vector<int> e[N], lef;
void dfs(int u, int fa) {
dfn[u] = ++dn; int son = 0;
for (int v : e[u]) {
if (v == fa) continue;
dfs(v, u), son++;
}
if (!son) lef.emplace_back(u);
}
void _main() {
cin >> n;
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
e[u].emplace_back(v), e[v].emplace_back(u);
}
dfs(1, -1);
if (e[1].size() == 1) lef.emplace_back(1);
sort(lef.begin(), lef.end(), [](int u, int v) -> bool {
return dfn[u] < dfn[v];
});
int m = lef.size();
cout << (m + 1) / 2 << '\n';
for (int i = 0; i < m / 2; i++) cout << lef[i] << ' ' << lef[i + m / 2] << '\n';
if (m & 1) cout << lef[m - 1] << ' ' << lef[0];
}
```
:::::
## [ABC341G Highest Ratio](https://www.luogu.com.cn/problem/AT_abc341_g)
> 给出一个长为 $n$ 的序列 $a_i$。对 $l=1,2,\cdots,n$ 求出
> $$
>\max_{l\le r\le n}\dfrac{1}{r-l+1}\sum_{i=l}^r a_i
>$$
> $n\le2\times10^5$,2 秒,1024 MB。
:::::success[题解]
将 $a_i$ 变成前缀和,所求即 $\dfrac{a_r-a_{l-1}}{r-(l-1)}$ 的 $\max$。
转二维平面分析,将 $(i,a_i)$ 视为平面上的点,倒序扫描每个 $a_i$,则需要在 $i$ 右侧找到一点 $j$,最大化 $(i,a_i)\to(j,a_j)$ 的连线斜率。
类似斜率优化地,可以发现只有上凸壳有用。单调栈维护即可,复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n; i64 a[N];
double ans[N];
using node = pair<i64, i64>;
node operator- (const node& a, const node& b) {
return {a.fi - b.fi, a.se - b.se};
}
i64 operator* (const node& a, const node& b) { // cross
return a.fi * b.se - a.se * b.fi;
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], a[i] += a[i - 1];
vector<node> st;
for (int i = n; i >= 0; i--) {
node v(i, a[i]);
while (st.size() >= 2 && (st.back() - v) * (st.back() - st[st.size()-2]) < 0) st.pop_back();
auto v0 = st.empty() ? v : v - st.back();
ans[i] = 1.0 * v0.se / v0.fi;
st.emplace_back(v);
}
cout << fixed << setprecision(12);
for (int i = 1; i <= n; i++) cout << ans[i-1] << '\n';
}
```
:::::
## [P3076 [USACO13FEB] Taxi G](https://www.luogu.com.cn/problem/P3076)
> 你是一名出租车司机,从数轴上 $0$ 位置出发,要行驶到 $m$ 位置。给出 $n$ 名乘客 $(s_i,t_i)$,表示它要从 $s_i$ 坐车到 $t_i$。
>
> 你可以在某个位置先放下乘客,搭上另一名乘客,返回时再将放下的乘客搭上。同一时刻,出租车最多只能有一名乘客。最小化总路程并输出。
>
> $n\le10^5$,1 秒,125 MB。
:::::success[题解]
怎么这么多小朋友建议降橙,这个题很简单吗。
考虑用图论语言来刻画本题。我们将数轴画出,进行如下连边:
- $s_i\to t_i$,表示送一名乘客。
- $t_i\to s_j$,其中 $i\ne j$,表示空车去找另一名乘客。
建立超级源点 $S$,超级汇点 $T$,其在数轴的位置分别为 $0,m$。连边 $T\to S$。下面给出一个示例:

上图中,橙色边为源汇点向普通点连的边,紫色边为 $s_i\to t_i$ 的边,粉色边为 $t_i\to s_j$ 的边。
考虑一些乘车方式:
- $S\to s_1\to s_2\to t_2\to t_1\to T$。在上图中刻画为 $S\to s_2\to t_2\to T\to S$。
- $S\to s_1\to t_1\to s_2\to t_2\to T$。在上图中刻画为 $S\to s_1\to t_1\to s_2\to t_2\to T\to S$。
其他方式类似。我们发现:每种合法的乘车方式都是一个 $S\to S$ 的回路。
注意到,在回路中,紫色边一定有贡献,可以先统计上。如果将 $T\to S$ 视为紫色边,那么粉色边和橙色边其实没有区别,因为这种边都是 $t\to s$ 的结构。我们将其统一为一种边。
更进一步,我们只需选择若干此类边,使得每个点的入度和出度相等,即可构造一条合法回路。直观的想法是将这类边按边权排序,但是有 $O(n^2)$ 条边,无法通过。
注意到边权的特殊性。在本题中,相当于将 $t\to s$ 两两匹配,最小化 $\sum|t_i-s_j|$。我们尝试做 exchange argument。自然的想法是按 $|a-b|+|c-d|$ 排序,但是这个东西没有非对称性,因此我们寻找一个必要条件。
根据绝对值的几何意义,其满足四边形不等式 $a\le b\le c\le d\implies|a-b|+|c-d|\le|a-c|+|b-d|$。所以我们按 $s_i\le s_j,t_i\le t_j$ 分别将 $s,t$ 排序,然后对应位置匹配即为最优。
复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, m, a[N], b[N];
void _main() {
cin >> n >> m;
i64 res = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
res += abs(a[i] - b[i]);
}
a[0] = m, b[0] = 0;
sort(a, a + n + 1), sort(b, b + n + 1);
for (int i = 0; i <= n; i++) res += abs(a[i] - b[i]);
cout << res;
}
```
:::::
## [P3634 [APIO2012] 守卫](https://www.luogu.com.cn/problem/P3634)
> 现有一个隐藏的长为 $n$ 的 01 串,其中有 $k$ 个 $1$。给出 $m$ 条限制,第 $i$ 条限制形如 $[l_i,r_i]$ 中至少有一个 $1$,或者全部为 $0$。求出所有必然为 $1$ 的位置。
>
> $n,m\le10^5$,1 秒,125 MB。
:::::success[题解]
观察性质起手:
- 对于 $0$ 的限制,$[l_i,r_i]$ 段已经无用,可以直接将子串删去后重标号。下文的限制特指 $1$ 的限制。
- 删去以后,若存在不等的 $i,j$ 满足 $[l_i,r_i]\subseteq[l_j,r_j]$,则 $j$ 限制可以忽略。
处理完这些以后,考虑先求出至少有几个 $1$。将区间按左端点升序排序后顺次扫描,若当前区间的限制未被满足,则在右端点放置一个 $1$。容易说明这个做法的最优性。
设上述算法得到的答案为 $c$。若 $c<k$,可以说明除 $l_i=r_i$ 的限制,剩余点都无法确定。考虑对于一组解做调整,将一个点删去然后加入相邻点可证。
因此 $c<k$ 的情形直接输出即可。注意一个 corner case:当剩余点位的数目恰为 $k$ 时所有点也是必选的。
否则,将区间按右端点降序排序,反向执行上述贪心。设两次贪心得到的选点集合为 $S,T$,我们断言 $S\cap T$ 即为答案。
考虑点 $x$ 必选当且仅当去掉 $x$ 以后无解,或者说答案大于 $k$。由于两次贪心都取到了这个位置,调整以后必然是左边放一个,右边放一个,答案至少增加 $1$。这就说明了 $c=k$ 时的正确性。
用线段树模拟贪心过程,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
using node = pair<int, int>;
int n, k, m, d[N];
vector<node> a, b;
bitset<N> x, y;
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
int val[N << 2];
void pushup(int rt) {val[rt] = max(val[ls], val[rs]);}
void build(int l = 0, int r = n, int rt = 1) {
val[rt] = 0;
if (l == r) return;
int mid = (l + r) >> 1;
build(l, mid, ls), build(mid + 1, r, rs);
}
void update(int x, int l = 0, int r = n, int rt = 1) {
if (l == r) return val[rt] = 1, void();
int mid = (l + r) >> 1;
if (x <= mid) update(x, l, mid, ls);
else update(x, mid + 1, r, rs);
pushup(rt);
}
int ask(int tl, int tr, int l = 0, int r = n, int rt = 1) {
if (tl <= l && r <= tr) return val[rt];
int mid = (l + r) >> 1, res = 0;
if (tl <= mid) chkmax(res, ask(tl, tr, l, mid, ls));
if (tr > mid) chkmax(res, ask(tl, tr, mid + 1, r, rs));
return res;
}
} T;
void _main() {
cin >> n >> k >> m;
for (int i = 1, l, r, op; i <= m; i++) {
cin >> l >> r >> op;
if (op == 0) d[l]++, d[r + 1]--;
else a.emplace_back(l, r);
}
vector<int> vec;
for (int i = 1; i <= n; i++) {
d[i] += d[i - 1];
if (d[i] == 0) vec.emplace_back(i);
}
sort(vec.begin(), vec.end());
for (auto& [l, r] : a) {
l = lower_bound(vec.begin(), vec.end(), l) - vec.begin();
r = upper_bound(vec.begin(), vec.end(), r) - vec.begin() - 1;
}
sort(a.begin(), a.end(), [](const node& x, const node& y) -> bool {
if (x.first == y.first) return x.second > y.second;
return x.first < y.first;
});
reverse(a.begin(), a.end());
int to = 1e9;
for (auto [l, r] : a) {
if (l > r) continue;
if (r < to) b.emplace_back(l, r), to = r;
}
sort(b.begin(), b.end());
for (auto [l, r] : b) {
if (T.ask(l, r)) continue;
T.update(r), x.set(vec[r]);
}
if (x.count() < k) {
if (k == (int)vec.size()) {
for (int i : vec) cout << i << '\n';
return;
}
vector<int> arr;
for (auto [l, r] : b) if (l == r) arr.emplace_back(vec[l]);
if (arr.empty()) return cout << -1, void();
for (int i : arr) cout << i << '\n';
return;
}
T.build();
sort(b.begin(), b.end(), [](const node& x, const node& y) -> bool {
return x.second > y.second;
});
for (auto [l, r] : b) {
if (T.ask(l, r)) continue;
T.update(l), y.set(vec[l]);
}
auto z = x & y;
if (z.none()) return cout << -1, void();
for (int i = 1; i <= n; i++) if (z[i]) cout << i << '\n';
}
```
:::::
## [P17143 [NOI 2026] 中位数](https://www.luogu.com.cn/problem/P17143)
> 对大小为 $m$ 的可重集,定义中位数是其中第 $\left\lceil\frac{m}{2}\right\rceil$ 大的数。
>
> 给定长为 $n$ 的序列 $a_i$,你需要将其不重不漏地划分为恰好 $k$ 段,将每段的中位数构成多重集,最大化这个集合的中位数并输出。
>
> 多测,$\sum n \le 10^6$,$2 \le k \le n$,$1 \le a_i \le n$,1 秒,1024 MB。
:::::success[题解]
中位数最优化问题,考虑二分答案 $x$,将 $\ge x$ 的设为 $1$,$<x$ 的设为 $-1$,则某段中位数 $\ge x$ 等价于元素和 $\ge 0$。
问题转化为,判定能否将序列划分为恰好 $k$ 段,使得至少 $m= \left\lceil\frac{k}{2}\right\rceil$ 段的元素和 $\ge 0$。下文称元素和 $\ge 0$ 的为好段,$<0$ 的为坏段。讨论时将 $-1$ 写作 `0`。
考虑 DP,记 $f_{i,x}$ 为将前 $i$ 个元素划分为 $x$ 段时,好段的最大数目。转移枚举上一个划分点 $j$,转移 $f_{j,x-1}+\left[\sum \limits_{k=j+1}^i a_k \ge 0\right] \to f_{i,x}$。复杂度 $O(n^2k \log n)$,获得 [35pts](https://qoj.ac/submission/2719480)。
对数组求前缀和后,通过简单推式子可以得到 $O(nk\log^2 n)$ 的线段树优化 DP 做法,对正解没有启发,故略去。
考虑贪心优化转移。对于增加坏段的情形,直接记录前缀 $\max$ 即可优化。对于增加好段的情形,我们希望决策点尽可能靠近 $i$,分析决策点的位置:
- 形如 `11`:取 $j=i-1$。
- 形如 `10`:取 $j=i-2$。
- 形如 `1...0`:取最后的 $j$ 满足 $\sum \limits_{k=j+1}^i a_k=0$。
预处理前缀后,遍历三种决策点分别转移即可。复杂度 $O(nk \log n)$,获得 [70pts](https://qoj.ac/submission/2719942)。
注意到 DP 的 $O(nk)$ 状态无法优化,转而考虑能否贪心地求解判定问题。
先判掉 $1$ 的数目不足 $m$ 的情形。朴素的想法是,取 $m$ 个 $1$ 独立成为好段,总段数是 $2m+1$,但题目要求我们恰好划出 $k$ 段,需要进行微调。
- 若 $k$ 为偶数,则 $k=2m$,消除一个 $-1$ 坏段或合并两个好段。
- 若 $k$ 为奇数,则 $k=2m-1$,消除两个坏段或合并好段。
观察可以调整的结构:
- `11`:将两个好段合并。
- `101`:划分为 `10|1`
- `1001`:划分为 `10|01`。
- `10001`:必然剩余坏段,消除失败。
从而消除一个坏段的条件是,存在一对 $1$ 的距离 $\le 3$,注意特判 $1$ 在边界的情况。这样 $k$ 为偶数解决。
对于两次调整的策略,我们穷举所有结构:
- 两对 $1$ 的距离 $\le 3$,独立消去两个 $-1$。
- 三个 $1$ 得到 $3$ 个好段:
- 三个连续:`111`。
- 两个连续,间隔 $1$:`1101` 或 `1011`。
- 两个连续,间隔 $2$:`10011` 或 `11001` 或 `10101`。
- 长度 $6$:`101001` 或 `100101`。
上述结构全部需要特判 `1` 在边界的情形。
- 四个 $1$ 得到 $3$ 个好段:
- 长度 $7$:`1100011`。
- 长度 $8$:`11000101` 或 `10100011`。
注意枚举的优先级。由于上面的构造需要充分长的序列,对 $k=2,3,5$ 不成立,需要拼上 DP 做法才有正确性。
复杂度在 $k \le 5$ 时为 $O(nk \log n)$,在 $k > 5$ 时为 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e6 + 5, inf = 1e9;
int n, k, a[N], b[N], s[N], mp[2*N];
bool check(int x) {
auto check_dp = [&]() -> bool {
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + (a[i] >= x ? 1 : -1);
fill(mp, mp + 2*n + 1, -1);
vector<vector<int>> f(k+3, vector<int>(n+5, -inf));
vector<int> g(k+3, -inf);
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int x = 0; x <= k; x++) chkmax(g[x], f[x][i - 1]);
for (int x = 1; x <= k; x++) {
f[x][i] = g[x-1];
auto chk = [&](int j) -> void {
if (j < 0) return;
chkmax(f[x][i], f[x-1][j] + (s[i] - s[j] >= 0));
};
chk(i-1), chk(i-2), chk(mp[s[i]+n]);
}
mp[s[i] + n] = i;
}
return 2 * f[k][n] >= k;
};
auto check0 = [&]() -> bool {
int m = k / 2;
for (int i = 1; i <= n; i++) b[i] = a[i] >= x;
if (count(b + 1, b + n + 1, 1) < m) return false;
vector<int> v = {-1};
for (int i = 1; i <= n; i++) if (b[i] == 1) v.emplace_back(i);
v.emplace_back(n + 2);
int ls = -inf;
for (int x : v) {
if (x - ls <= 3) return true;
ls = x;
}
return false;
};
auto check1 = [&]() -> bool {
int m = (k + 1) / 2;
for (int i = 1; i <= n; i++) b[i] = a[i] >= x;
if (count(b + 1, b + n + 1, 1) < m) return false;
vector<int> v = {-1};
for (int i = 1; i <= n; i++) if (b[i] == 1) v.emplace_back(i);
v.emplace_back(n + 2);
int cnt = 0, ls = -inf;
for (int x : v) {
if (x - ls <= 3) cnt++, ls = -inf;
else ls = x;
}
if (cnt >= 2) return true;
auto chk = [&](int l, int len, vector<int> v) -> bool {
if (l + len - 1 > n) return false;
for (int i = 0; i < len; i++) if (v[i] != b[l + i]) return false;
return true;
};
if (chk(1, 2, {1, 1})) return true;
if (chk(1, 3, {1, 0, 1})) return true;
if (chk(1, 4, {1, 0, 0, 1})) return true;
if (chk(1, 3, {0, 1, 1})) return true;
if (chk(1, 4, {0, 1, 0, 1})) return true;
if (chk(n-1, 2, {1, 1})) return true;
if (chk(n-2, 3, {1, 0, 1})) return true;
if (chk(n-3, 4, {1, 0, 0, 1})) return true;
if (chk(n-2, 3, {1, 1, 0})) return true;
if (chk(n-3, 4, {1, 0, 1, 0})) return true;
for (int i = 1; i <= n; i++) {
if (chk(i, 3, {1, 1, 1})) return true;
if (chk(i, 4, {1, 1, 0, 1})) return true;
if (chk(i, 4, {1, 0, 1, 1})) return true;
if (chk(i, 5, {1, 0, 1, 0, 1})) return true;
if (chk(i, 5, {1, 0, 0, 1, 1})) return true;
if (chk(i, 5, {1, 1, 0, 0, 1})) return true;
if (chk(i, 6, {1, 0, 1, 0, 0, 1})) return true;
if (chk(i, 6, {1, 0, 0, 1, 0, 1})) return true;
}
if (count(b + 1, b + n + 1, 1) <= m) return false;
for (int i = 1; i <= n; i++) {
if (chk(i, 7, {1, 1, 0, 0, 0, 1, 1})) return true;
if (chk(i, 8, {1, 1, 0, 0, 0, 1, 0, 1})) return true;
if (chk(i, 8, {1, 0, 1, 0, 0, 0, 1, 1})) return true;
}
return false;
};
if (k <= 5) return check_dp();
return k % 2 ? check1() : check0();
}
int median(int n, int k, vector<int> a) {
::n = n, ::k = k, copy(a.begin(), a.end(), ::a + 1);
int l = 1, r = n, res = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) l = mid + 1, res = mid;
else r = mid - 1;
}
return res;
}
```
:::::
## [AGC018C Coins](https://www.luogu.com.cn/problem/AT_agc018_c)
> 给出 $n$ 个任务 $(a_i,b_i,c_i)$。你需要选择 $x$ 个任务获得 $a_i$ 的得分,另外选择 $y$ 个任务获得 $b_i$ 的得分,剩余 $z$ 个任务获得 $c_i$ 的得分,保证 $n=x+y+z$。最大化得分并输出。
>
> $n\le10^5$,2 秒,256 MB。
:::::success[题解]
反悔贪心,整体调整。
先令所有任务都选择 $c_i$,然后找出 $x$ 个选 $a_i$ 和 $y$ 个选 $b_i$。此时令 $a_i,b_i$ 都减去 $c_i$,问题转化为二元形式。
考虑做 exchange argument。若 $i$ 选择 $a_i$,$j$ 选择 $b_j$,则有 $a_i+b_j>a_j+b_i\iff a_i-b_i>a_j-b_j$。
因此按照 $a_i-b_i$ 降序排序,枚举一个分界点 $k$,则 $k$ 之前选择了 $x$ 个 $a_i$,$k$ 之后选择了 $y$ 个 $b_i$。需要计算前 $x,y$ 大数的和。
一个魔怔的做法是主席树 / 平衡树。但是本题的序列是静态的,直接用大根堆扫两遍预处理即可,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, x, y, z;
struct node {
int a, b, c;
} a[N];
i64 pre[N], suf[N];
priority_queue<int, vector<int>, greater<int>> q;
void _main() {
cin >> x >> y >> z, n = x + y + z;
i64 sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i].a >> a[i].b >> a[i].c;
a[i].a -= a[i].c, a[i].b -= a[i].c, sum += a[i].c;
}
sort(a + 1, a + n + 1, [](const node& x, const node& y) -> bool {
return x.a - x.b > y.a - y.b;
});
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i].a;
q.emplace(a[i].a);
while ((int)q.size() > x) pre[i] -= q.top(), q.pop();
}
while (!q.empty()) q.pop();
for (int i = n; i >= 1; i--) {
suf[i] = suf[i + 1] + a[i].b;
q.emplace(a[i].b);
while ((int)q.size() > y) suf[i] -= q.top(), q.pop();
}
i64 res = -1e18;
for (int i = x; i <= n - y; i++) chkmax(res, pre[i] + suf[i + 1]);
cout << res + sum;
}
```
:::::
## [P3488 [POI 2009] LYZ-Ice Skates](https://www.luogu.com.cn/problem/P3488)
> 现有种类为 $1\sim n$ 的物品各 $k$ 个,第 $i$ 类人可以获得种类 $\in[i,i+d]$ 的物品,你需要让每个人都获得一个物品。
>
> 给出 $q$ 次询问,每次询问将第 $i$ 类人的数目增加或减少一个值,在操作后判断是否存在合法方案。
>
> $n\le2\times10^5$,$q\le5\times10^5$,1 秒,125 MB。
:::::success[题解]
设第 $i$ 类人有 $a_i$ 个。建立二分图,左部点表示人,右部点表示物品,并且将每类物品拆成 $k$ 个点。将第 $i$ 类人连向编号在 $[i,i+d]$ 中的所有物品。
合法方案对应一组完美匹配,其中第 $i$ 个左部点匹配 $a_i$ 个右部点。根据 Hall 定理,只需判断 $\forall W\subseteq X,\sum\limits_{i\in W}a_i\le|N(W)|$ 是否成立。
我们只关注 $\sum\limits_{i\in W}a_i-|N(W)|$ 取得 $\max$ 的 $W$。考虑 $W\subseteq[l,r]$ 时,如果 $W$ 不取遍区间,则将新点加入 $W$ 时 $\sum\limits_{i\in W}a_i$ 增加而 $|N(W)|$ 不变,调整更优。因此,$W$ 的结构必然是一段区间。
记 $W=[l,r]$,则 $|N(W)|=k(r+d-l+1)$。我们有
$$
\begin{aligned}
&\sum\limits_{i\in W}a_i\le|N(W)|\\
\iff&\sum_{i=l}^r a_i\le k(r+d-l+1)\\
\iff&\sum_{i=l}^r a_i\le k(r-l+1)+kd\\
\iff&\sum_{i=l}^r(a_i-k)\le kd
\end{aligned}
$$
只要 $\sum\limits_{i=l}^r(a_i-k)$ 的最大值不大于 $kd$ 即可,且 $kd$ 是常数。用线段树维护 $a_i-k$ 的最大子段和,支持单点修改,复杂度 $O(q\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, q, k, d;
#define ls (rt << 1)
#define rs (rt << 1 | 1)
struct node {
i64 sum, pre, suf, val;
} val[N << 2];
node operator+ (const node& a, const node& b) {
return node{
a.sum + b.sum,
max(a.pre, a.sum + b.pre),
max(b.suf, b.sum + a.suf),
max({a.val, b.val, a.suf + b.pre})
};
}
void operator+= (node& a, i64 b) {a.sum += b, a.pre = a.pre + b, a.suf += b, a.val += b;}
void pushup(int rt) {val[rt] = val[ls] + val[rs];}
void build(int l = 1, int r = n, int rt = 1) {
if (l == r) return val[rt] = node{-k, -k, -k, -k}, void();
int mid = (l + r) >> 1;
build(l, mid, ls), build(mid + 1, r, rs), pushup(rt);
}
void update(int x, i64 c, int l = 1, int r = n, int rt = 1) {
if (l == r) return val[rt] += c;
int mid = (l + r) >> 1;
if (x <= mid) update(x, c, l, mid, ls);
else update(x, c, mid + 1, r, rs);
pushup(rt);
}
void _main() {
cin >> n >> q >> k >> d; build();
for (int x, c; q--; ) {
cin >> x >> c, update(x, c);
cout << (val[1].val <= 1LL * k * d ? "TAK" : "NIE") << '\n';
}
}
```
:::::
## [P3045 [USACO12FEB] Cow Coupons G](https://www.luogu.com.cn/problem/P3045)
> 现有 $n$ 个商品 $(x_i,y_i)$,保证 $x_i\ge y_i$。购买第 $i$ 个商品的价格为 $x_i$,你有 $k$ 张优惠券,使用后可以使价格变为 $y_i$。
>
> 你现在持有 $m$ 元钱,最大化购买的商品总数并输出。
>
> $k\le n\le5\times10^4$,1 秒,500 MB。
:::::success[题解]
先特判掉优惠券用不完的情形,即前 $k$ 小的 $y_i$ 之和大于 $m$ 的情况,按 $y_i$ 排序扫一次即可。
考虑钦定一个集合 $S$,表示购买哪些商品。此时的代价为 $\sum\limits_{i\in S}x_i$ 减去前 $k$ 大的 $x_i-y_i$ 之和。
考虑将商品按照 $x_i-y_i$ 降序排序,然后钦定一段前缀 $[1,x]$,在其中选出 $k$ 个使用优惠券。再考虑后缀 $[x+1,n]$ 中按照 $x_i$ 升序,尽量选择较多的商品。
可以用数据结构优化这个过程,需要支持加入删除、前 $k$ 小数的和。由于我比较魔怔,因此选用 FHQ-Treap 实现,在 Treap 上二分复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 5e4 + 5;
int n, k, m;
struct cow {
int x, y;
} a[N];
struct node {
u32 pri;
int val, sz, sum;
node *l, *r;
node(int x = 0) : pri(rand32()), val(x), sz(1), sum(x), l(nullptr), r(nullptr) {}
node* pushup() {
sz = 1, sum = val;
if (l) sz += l->sz, sum += l->sum;
if (r) sz += r->sz, sum += r->sum;
return this;
}
};
node* merge(node* a, node* b) {
if (!a || !b) return a ? a : b;
return a->pri < b->pri ? (a->r = merge(a->r, b), a->pushup())
: (b->l = merge(a, b->l), b->pushup());
}
void split(node* u, int k, node*& x, node*& y) {
if (!u) return x = y = nullptr, void();
if (u->val <= k) x = u, split(u->r, k, u->r, y), x->pushup();
else y = u, split(u->l, k, x, u->l), y->pushup();
}
node *L, *R;
void insert(node*& u, int k) {
node *x, *y; split(u, k, x, y);
u = merge(merge(x, new node(k)), y);
}
void erase(node*& u, int k) {
node *x, *y, *z; split(u, k, x, y), split(x, k - 1, x, z);
if (z) z = merge(z->l, z->r);
u = merge(merge(x, z), y);
}
int qsum(node* u, int k) {
int res = 0;
while (u && k > 0) {
int ls = u->l ? u->l->sz : 0, lsum = u->l ? u->l->sum : 0;
if (k > ls) res += lsum + u->val, k -= ls + 1, u = u->r;
else u = u->l;
} return res;
}
int qcnt(node* u, int k) {
int res = 0;
while (u && k > 0) {
int ls = u->l ? u->l->sz : 0, lsum = u->l ? u->l->sum : 0;
if (k >= lsum + u->val) res += ls + 1, k -= lsum + u->val, u = u->r;
else if (k >= lsum) {res += ls; break;}
else u = u->l;
} return res;
}
void _main() {
cin >> n >> k >> m;
for (int i = 1; i <= n; i++) cin >> a[i].x >> a[i].y;
sort(a + 1, a + n + 1, [](const cow& a, const cow& b) -> bool {
return a.y < b.y;
});
int sum = 0;
for (int i = 1; i <= k; i++) {
sum += a[i].y;
if (sum > m) return cout << i - 1, void();
}
sort(a + 1, a + n + 1, [](const cow& a, const cow& b) -> bool {
return a.x - a.y > b.x - b.y;
});
int res = 0;
for (int i = 1; i < k; i++) insert(L, a[i].y);
for (int i = k; i <= n; i++) insert(R, a[i].x);
for (int i = k; i <= n; i++) {
insert(L, a[i].y), erase(R, a[i].x);
int rc = qcnt(R, m - qsum(L, k));
chkmax(res, k + rc);
} cout << res;
}
```
:::::
## [TC13061 ColorfulCoins](https://archive.topcoder.com/ProblemStatement/pm/13061)
> 给定 $n$ 种面值的货币,满足 $1=a_1<a_2<\dots<a_n$ 且 $a_i\mid a_{i+1}$。每种面值的货币均对应一种未知的唯一颜色。
>
> 每次查询可指定一个金额 $x$,系统将返回构成该金额且总张数最少的货币颜色及数量组合。
>
> 求最少的查询次数,使得能唯一确定每种面值对应的颜色。
>
> $n\le60$,$a_i\le10^{18}$。
:::::success[题解]
确定 $a_n$ 只需询问一次 $+\infty$,因此考虑前 $n-1$ 个货币。
我们将 $\dfrac{a_{i+1}}{a_i}$ 视为一个进制,那么交互库寻找集合的过程是确定性的,相当于给出一个变进制数。
那么我们需要构造一个特征序列,使得所有货币每轮所属的变进制数的位置不同。我们注意到问题只与 $\dfrac{a_{i+1}}{a_i}$ 有关,所以提取出这个序列 $b_i$ 并升序排序。
对于上限 $k$,在 $q$ 次查询中,元素取值 $\in[0,k)$ 且非全 $0$ 的序列共 $k^q-1$ 种,为了让所有 $b_i\ge k$ 的进制都能分到互不相同的询问,有 $k^q>s$。其中 $s$ 表示进制 $\le k$ 的进制数目。
根据木桶原理,答案由所有 $q$ 取 $\max$ 得到。我的实现需要二分求 $q$,因此复杂度 $O(n\log n\log V)$。可以用 `std::log` 优化到 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 105;
int n, a[N];
int solve(int a, int b) {
int l = 0, r = 100, res = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (pow(a, mid) > b) res = mid, r = mid - 1;
else l = mid + 1;
} return res;
}
void _main() {
cin >> n;
if (n == 1) return cout << 1, void();
for (int i = 1; i <= n; i++) cin >> a[i];
map<int, int> mp;
for (int i = 1; i < n; i++) mp[a[i + 1] / a[i]]++;
int sum = 0, res = 0;
for (const auto& i : mp) {
sum += i.second;
res = max(res, solve(i.first, sum));
} cout << res;
}
```
:::::
## [ABC376G Treasure Hunting](https://www.luogu.com.cn/problem/AT_abc376_g)
> 给出一棵 $n+1$ 个点的有根树,根节点为 $0$。你从根节点开始游走,只能游走到父亲已经走过的点。每个点有 $\frac{a_i}{\sum a}$ 的概率为关键点,最小化到达关键点步数的期望值并输出,对 $998244353$ 取模。
>
> 多测,$\sum n\le2\times10^5$,2 秒,1024 MB。
:::::success[题解]
树上 exchange argument 模板题。双倍经验 UVA1205。
将所有概率乘上 $\sum a$,答案再除回去。然后把题意翻译成:找到一个拓扑序 $b_i$,最小化 $\sum\limits_{i=1}^n a_ib_i$。
拓扑序是合并连通块的过程,合并的顺序考虑用 exchange argument 确定。记 $c_A$ 为连通块节点数目,$w_A$ 为块中点权和。对于块 $A,B$,将其交换位置的答案变化量为
$$
c_B w_A-c_A w_B
$$
钦定上式 $<0$ 移项得 $c_B w_A<c_A w_B\iff\frac{c_B}{w_B}<\frac{c_A}{w_A}$。这是一个严格全序,符合要求。
按照树上 exchange argument 的做法,并查集 + set 维护即可。总复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, p[N], fa[N];
int find(int x) {return x == fa[x] ? x : fa[x] = find(fa[x]);}
i64 a[N], c[N], w[N];
struct node {
i64 w, c; int id;
node(i64 x = 0, i64 y = 0, int z = 0) : w(x), c(y), id(z) {}
bool operator< (const node& a) const {
if (w * a.c != c * a.w) return w * a.c > c * a.w;
return id < a.id;
}
};
set<node> q;
void _main() {
cin >> n;
iota(fa, fa + n + 1, 0);
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 1; i <= n; i++) cin >> a[i];
mint sum = accumulate(a + 1, a + n + 1, mint(0)), cost = sum;
copy(a, a + n + 1, w), fill(c, c + n + 1, 1);
c[0] = 0, w[0] = 0;
for (int i = 1; i <= n; i++) q.emplace(w[i], c[i], i);
while (!q.empty()) {
int u = q.begin()->id; q.erase(q.begin());
int v = find(p[u]);
if (v != 0) q.erase(node(w[v], c[v], v));
cost += c[v] * w[u];
c[v] += c[u], w[v] += w[u], fa[find(u)] = find(v);
if (v != 0) q.emplace(w[v], c[v], v);
}
cout << cost / sum << '\n';
}
```
:::::
## [AGC023F 01 on Tree](https://www.luogu.com.cn/problem/AT_agc023_f)
> 给出一棵 $n$ 节点的有根树,根节点为 $1$。点带权 $w_i$,且 $w_i\in\{0,1\}$。你需要确定一组拓扑序,最小化逆序对数并输出。
>
> $n\le2\times10^5$,2 秒,256 MB。
:::::success[题解]
有根树上的拓扑序问题,考虑树上 exchange argument。
对连通块维护两个值 $(a,b)$ 表示 $0$ 的数目和 $1$ 的数目。讨论 $n=2$ 的情形,此时有 $(a_1,b_1)$ 与 $(a_2,b_2)$ 合并,贡献分别为 $a_1b_2$ 和 $a_2b_1$。
钦定前者更优,那么 $a_1b_2<a_2 b_1\iff\frac{a_1}{b_1}<\frac{a_2}{b_2}$,显然是一个严格全序。于是 set 维护即可,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, a[N], b[N], p[N], fa[N];
int find(int x) {return x == fa[x] ? x : fa[x] = find(fa[x]);}
struct node {
int a, b, id;
node(int x = 0, int y = 0, int z = 0) : a(x), b(y), id(z) {}
bool operator< (const node& x) const {
if (1LL * a * x.b == 1LL * b * x.a) return id < x.id;
return 1LL * a * x.b < 1LL * b * x.a;
}
};
set<node> q;
void _main() {
cin >> n, iota(fa + 1, fa + n + 1, 1);
for (int i = 2; i <= n; i++) cin >> p[i];
for (int i = 1, op; i <= n; i++) {
cin >> op;
if (op == 0) a[i] = 1, q.emplace(1, 0, i);
else b[i] = 1, q.emplace(0, 1, i);
}
i64 res = 0;
while (!q.empty()) {
int u = q.rbegin()->id, v = find(p[u]);
q.erase(--q.end());
if (v != 0) q.erase(node(a[v], b[v], v));
res += 1LL * b[v] * a[u];
a[v] += a[u], b[v] += b[u], fa[find(u)] = v;
if (v != 0) q.emplace(a[v], b[v], v);
}
cout << res;
}
```
:::::
## [P10759 [BalticOI 2024] Jobs](https://www.luogu.com.cn/problem/P10759)
> 现有 $n$ 个任务,完成第 $i$ 个任务可以获得 $b_i$ 的得分,$b_i$ 可能为负。任务之间存在依赖关系,只有先完成任务 $p_i$ 才能完成任务 $i$。$p_i=0$ 表示无依赖。
>
> 你初始持有得分 $k$,可以选择一些任务以任意顺序完成,要求任意时刻 $k\ge0$。最大化利润并输出。
>
> $n\le3\times10^5$,1 秒,250 MB。
:::::success[题解]
先连边 $p_i\to i$,则每个任务形成了一棵以 $0$ 为根的有根树。将 $0$ 视为收益为 $0$ 的特殊任务,这就是一个树的拓扑序最优化问题。
考虑树上 exchange argument。用二元组 $(a,b)$ 刻画一个连通块,即该块的启动资金不小于 $a$,完成后可以获得 $b$ 的得分。
对于两个连通块 $(a_1,b_1)$ 和 $(a_2,b_2)$,讨论其前后关系:
- 若 $b_1\ge0\land b_2<0$:$(a_1,b_1)$ 必然在前。
- 若 $b_1<0\land b_2\ge0$:$(a_2,b_2)$ 必然在前。
- 若 $b_1\ge0\land b_2\ge0$:$a$ 小的在前。
- 若 $b_1<0\land b_2<0$:根据 [P3619](https://www.luogu.com.cn/problem/P3619) 的结论,$a+b$ 大的在前。
这些比较规则构成一个严格全序 $\prec$。接下来,按照套路用 set 维护连通块,按 $\prec$ 排序,每轮中取出权值最小的连通块与父亲所在的块合并。
当父亲为 $0$ 时说明到达终点,将这个块放进候选。最后将所有候选块按 $\prec$ 排序贪心即可。
复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 3e5 + 5;
int n, p[N], fa[N];
i64 k, a[N], b[N];
int find(int x) {return x == fa[x] ? x : fa[x] = find(fa[x]);}
struct node {
i64 a, b; int id;
node(i64 x = 0, i64 y = 0, int z = 0) : a(x), b(y), id(z) {}
bool operator< (const node& x) const {
if (b >= 0 && x.b < 0) return true;
if (b < 0 && x.b >= 0) return false;
if (b >= 0 && x.b >= 0) return a != x.a ? a < x.a : id < x.id;
return a + b != x.a + x.b ? a + b > x.a + x.b : id < x.id;
}
};
set<node> q;
void _main() {
cin >> n >> k, iota(fa, fa + n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> b[i] >> p[i];
a[i] = max(0LL, -b[i]), q.emplace(a[i], b[i], i);
}
vector<node> vec;
while (!q.empty()) {
int u = q.begin()->id, v = find(p[u]);
q.erase(q.begin());
if (v == 0) {
vec.emplace_back(a[u], b[u], u);
fa[u] = 0; continue;
}
q.erase(node(a[v], b[v], v));
chkmax(a[v], a[u] - b[v]), b[v] += b[u], fa[find(u)] = v;
q.emplace(a[v], b[v], v);
}
sort(vec.begin(), vec.end());
i64 res = 0;
for (auto& [a, b, id] : vec)
if (k >= a && b >= 0) k += b, res += b;
cout << res;
}
```
:::::
## [QOJ8130 Yet Another Balanced Coloring Problem](https://qoj.ac/problem/8130)
> 给出两棵大小为 $n,m$ 的有根树,根节点分别为 $n$ 和 $m$。保证两棵树的叶子节点均为 $1,2,\cdots,k$。构造一种对叶子的黑白染色方案,使得对于每棵树,每个子树中黑点与白点的数目相差不超过 $1$。输出方案或报告无解。
>
> 多测,$\sum(n+m)\le2\times10^5$,1 秒,256 MB。
:::::success[题解]
先考虑一棵树的情形。
叶向树问题,自底向上贪心。对于当前子树中未处理的叶子,我们在新图 $G$ 中将两个叶子连一条边,钦定其颜色不同。对 $G$ 做黑白染色就得到了构造,容易证明合法且有解。
两棵树的情形,考虑套用上面的做法。正确性仍然显然。
并且可以说明,这样做一定有解。注意到每个点的度数 $\le2$,则 $G$ 中链的情况是平凡的。而 DFS 过程相当于将两个匹配合并,有环也必为偶环。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, m;
vector<int> e1[N], e2[N], e[N];
int dfs1(int u, vector<int>* et) {
if (et[u].empty()) return u;
vector<int> vec;
for (int v : et[u]) {
int x = dfs1(v, et);
if (x != -1) vec.emplace_back(x);
}
while (vec.size() > 1) {
int x = vec.back(); vec.pop_back();
int y = vec.back(); vec.pop_back();
e[x].emplace_back(y), e[y].emplace_back(x);
}
return vec.empty() ? -1 : vec[0];
}
int col[N];
void dfs2(int u) {
for (int v : e[u]) {
if (col[v] != -1) continue;
col[v] = col[u] ^ 1, dfs2(v);
}
}
void _main() {
cin >> n >> m;
for (int i = 1; i <= max(n, m); i++) e1[i].clear(), e2[i].clear(), e[i].clear();
for (int v = 1, u; v < n; v++) cin >> u, e1[u].emplace_back(v);
for (int v = 1, u; v < m; v++) cin >> u, e2[u].emplace_back(v);
dfs1(n, e1), dfs1(m, e2);
int k = 0;
for (int i = 1; i <= min(n, m); i++) if (e1[i].empty()) k++;
fill(col + 1, col + k + 1, -1);
for (int i = 1; i <= k; i++) {
if (col[i] != -1) continue;
col[i] = 0, dfs2(i);
}
for (int i = 1; i <= k; i++) cout << (col[i] ? 'R' : 'B');
cout << '\n';
}
```
:::::
## [ABC304Ex Constrained Topological Sort](https://www.luogu.com.cn/problem/AT_abc304_h)
> 给出一张 $n$ 个点 $m$ 条边的有向图。再给定 $n$ 个二元组 $(l_i,r_i)$,要求构造一组拓扑序 $p_1\sim p_n$ 使得 $\forall i\in[1,n],p_i\in[l_i,r_i]$。
>
> 输出构造或报告无解。
>
> $n\le2\times10^5$,$m\le4\times10^5$,3 秒,1024 MB。
:::::success[题解]
首先特判掉图不是 DAG 的情形。
仔细思考后,我们发现可以直接推出每个节点的真实约束。具体地,考虑 $u\to v$ 边带来的约束:
- $l_u\le p_u\le r_u$。
- $l_v\le p_v\le r_v$。
- $p_u<p_v$。
分析得到
- $l_u\le p_u\le\min(r_u,r_v-1)$。
- $\max(l_u+1,l_v)\le p_v\le r_v$。
可以递推出所有点的真实约束。以 $l_u$ 的递推为例,我们在正图上跑拓扑排序,对于节点 $u$ 的后继 $v$,令 $l_v$ 对 $l_u+1$ chkmax 即可。对 $r_u$ 的递推同理,只要在反图上拓扑排序。
现在可以把这张图扔掉,问题变为构造一个 $1\sim n$ 的排列 $p_i$ 使得 $p_i\in[l_i,r_i]$。
根据经典贪心,将线段按右端点升序排序后,将 $p_i$ 排到尽量小的位置上即可。使用 set 维护,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, m, l[N], r[N], p[N], deg[N], ideg[N];
vector<int> e[N], ie[N];
struct node {
int l, r, id;
} a[N];
void _main() {
cin >> n >> m;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
e[u].emplace_back(v), deg[v]++;
ie[v].emplace_back(u), ideg[u]++;
}
for (int i = 1; i <= n; i++) cin >> l[i] >> r[i];
queue<int> q;
for (int i = 1; i <= n; i++) if (deg[i] == 0) q.emplace(i);
while (!q.empty()) {
int u = q.front(); q.pop();
for (int v : e[u]) {
chkmax(l[v], l[u] + 1);
if (--deg[v] == 0) q.emplace(v);
}
}
if (count(deg + 1, deg + n + 1, 0) != n) return cout << "No", void();
for (int i = 1; i <= n; i++) if (ideg[i] == 0) q.emplace(i);
while (!q.empty()) {
int u = q.front(); q.pop();
for (int v : ie[u]) {
chkmin(r[v], r[u] - 1);
if (--ideg[v] == 0) q.emplace(v);
}
}
for (int i = 1; i <= n; i++) a[i] = {l[i], r[i], i};
sort(a + 1, a + n + 1, [](const node& a, const node& b) -> bool {
return a.r < b.r;
});
set<int> st;
for (int i = 1; i <= n; i++) st.emplace(i);
for (int i = 1; i <= n; i++) {
auto it = st.lower_bound(a[i].l);
if (it == st.end() || *it > a[i].r) return cout << "No", void();
p[a[i].id] = *it, st.erase(it);
}
cout << "Yes\n";
for (int i = 1; i <= n; i++) cout << p[i] << ' ';
}
```
:::::
## [CF1784C Monsters (hard version)](https://www.luogu.com.cn/problem/CF1784C)
> 现有 $n$ 个元素 $a_i$。你可以进行两种操作:
>
> 1. 选择一个 $i$,令 $a_i\gets a_i-1$。
> 2. 将所有 $a_i\gets a_i-1$。若此操作使得 $\exists i,a_i=0$,则操作继续进行。
>
> 一操作可以进行多次,但二操作只能进行一次,目标为将所有元素变为 $0$,并且最小化一操作进行的次数。
>
> 对于每个前缀,求出上述问题的答案。
>
> 多测,$\sum n\le2\times10^5$,$1\le a_i\le n$,4 秒,500 MB。
:::::success[题解]
可以发现,先进行完所有一操作,再进行二操作是不劣的。记最终序列的最大值为 $m$,那么进行二操作时,序列中 $1\sim m$ 的数字需要出现至少一次。
将 $a_i$ 升序排序后,我们可以计算出位置 $i$ 上的目标元素,设其为 $f_i$。考虑 $f_i$ 形如 `1 1 ... 1 2 2 ... 2 ...... m m ... m`,并且必有 $f_i\le a_i$,则得到
$$
f_i=\min(f_{i-1}+1,a_i)
$$
答案即 $\sum(a_i-f_i)=\sum a_i-\sum f_i$。至此可以做到 $O(n^2)$。
以上是赛时会了的。以下是赛后改出来的。
考虑 $f_i$ 是一个递推式,将其展开得到
$$
\begin{aligned}
f_i&=\min(1,a_1+i-1,a_2+i-2,\cdots,a_i)\\
&=i+\min_{j=1}^i(a_j-j)
\end{aligned}
$$
转化为维护 $a_j-j$。将这个东西放到权值线段树上,定义 $b_x$ 为 $\le x$ 的元素数目。此时满足 $a_j=x$ 的 $\min(a_j-j)=x-b_x$。
枚举前缀时,我们需要插入数字 $x$,此时对于 $y\ge x$,$b_y\gets b_y+1$。转为维护 $x-b_x$ 后插入操作等价于后缀减 $1$。
现在观察 $\sum\limits_{i=1}^n f_i$,即
$$
\sum\limits_{i=1}^n f_i=\sum\limits_{x=1}^V\min_{y=0}^x(y-b_y)
$$
翻译成人话就是,求出 $x-b_x$ 的所有前缀 $\min$ 之和。因此我们要支持后缀加,前缀 $\min$ 求和,用楼房重建线段树维护即可,复杂度 $O(n\log^2 n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n;
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
i64 mn[N << 2], sum[N << 2], tag[N << 2];
void apply(int rt, int l, int r, i64 c) {
mn[rt] += c, tag[rt] += c;
int mid = (l + r) >> 1;
sum[rt] += c * (r - mid);
}
void pushdown(int rt, int l, int r) {
if (!tag[rt]) return;
int mid = (l + r) >> 1;
apply(ls, l, mid, tag[rt]), apply(rs, mid + 1, r, tag[rt]), tag[rt] = 0;
}
i64 ask(int rt = 1, int l = 1, int r = n, i64 c = 0) {
if (l == r) return min(c, mn[rt]);
int mid = (l + r) >> 1; pushdown(rt, l, r);
if (c <= mn[ls]) return c * (mid - l + 1) + ask(rs, mid + 1, r, c);
return ask(ls, l, mid, c) + sum[rt];
}
void pushup(int rt, int l, int r) {
mn[rt] = min(mn[ls], mn[rs]);
int mid = (l + r) >> 1;
sum[rt] = ask(rs, mid + 1, r, mn[ls]);
}
void build(int l = 1, int r = n, int rt = 1) {
tag[rt] = 0;
if (l == r) return mn[rt] = l, sum[rt] = 0, void();
int mid = (l + r) >> 1;
build(l, mid, ls), build(mid + 1, r, rs), pushup(rt, l, r);
}
void update(int tl, int tr, int c, int l = 1, int r = n, int rt = 1) {
if (tl <= l && r <= tr) return apply(rt, l, r, c), void();
int mid = (l + r) >> 1; pushdown(rt, l, r);
if (tl <= mid) update(tl, tr, c, l, mid, ls);
if (tr > mid) update(tl, tr, c, mid + 1, r, rs);
pushup(rt, l, r);
}
} sgt;
void _main() {
cin >> n, sgt.build();
i64 sum = 0;
for (int i = 1, x; i <= n; i++) {
cin >> x, sum += x;
sgt.update(x, n, -1);
i64 t = 1LL * i * (i + 1) / 2, m = -min(0LL, sgt.mn[1]), s = sgt.ask();
cout << sum - (t + m * (n - i) + m * (m + 1) / 2 + s) << ' ';
}
cout << '\n';
}
```
:::::
## [CF1208G Polygons](https://www.luogu.com.cn/problem/CF1208G)
> 给出 $n,k$。你要从正 $3\sim n$ 多边形中取出恰好 $k$ 个,放置在单位圆中,允许顶点重叠,最小化使用的顶点数并输出。
>
> $n\le10^6$,$1\le k\le n-2$,1 秒,250 MB。
:::::success[题解]
考虑正向贪心,也就是顺序扫描 $3,4,\cdots,n$ 边形,决策是否将这个正多边形放入。
假定我们已经放置了 $2$ 边形。观察最优解的形态,发现如下性质:选择放入正 $m$ 边形时,必然已经放入了 $m$ 的所有非平凡因子。证明考虑调整法,即将选择 $m$ 的因子优于选择 $m$。
因此选择 $m$ 的代价是 $\sum\limits_{i=2}^m[\gcd(i,m)=1]=\varphi(m)$。
另一种理解是,放入正 $m$ 边形时将单位圆分 $m$ 段,顶点标记为 $\frac{1}{m},\frac{2}{m},\cdots,\frac{m}{m}$。则每个顶点对代价有贡献,当且仅当标号是最简分数。这样也能得到代价是 $\varphi(m)$。
最后一步是简单的,直接线性筛出 $\varphi(3)\sim\varphi(n)$,升序排序后取走长为 $k$ 的一段前缀即可。计数排序可以做到 $O(n)$。
注意特判 $k\le2$ 的情形。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e6 + 5;
int n, k, f[N];
bitset<N> p;
vector<int> s;
void _main() {
cin >> n >> k;
if (k == 1) return cout << 3, void();
if (k == 2) return cout << 6, void();
f[1] = 1; p.set();
for (int i = 2; i <= n; i++) {
if (p[i]) s.emplace_back(i), f[i] = i - 1;
for (int j : s) {
if (i * j > n) break;
p[i * j] = 0;
if (i % j == 0) {
f[i * j] = f[i] * j; break;
}
f[i * j] = f[i] * (j - 1);
}
}
sort(f + 3, f + n + 1);
cout << accumulate(f + 3, f + k + 3, 0LL) + 2;
}
```
:::::
## [P8392 [BalticOI 2022] Uplifting Excursion (Day1) ](https://www.luogu.com.cn/problem/P8392)
> 现有 $2m+1$ 个物品,重量分别为 $-m,-m+1,\cdots,m-1,m$。第 $i$ 种物品有 $a_i$ 个。
>
> 你需要选择若干物品,使得重量之和恰为 $k$,最大化选择物品的数目并输出。
>
> $m\le300$,$-10^{18}\le k\le10^{18}$,$0\le a_i\le10^{12}$,4 秒,128 MB。
:::::success[题解]
直接对着题意做是多重背包,复杂度带 $k$,无法通过。
考虑反悔贪心,整体调整。通过一些尝试,我们可以给出一个平凡贪心,即按性价比降序排序顺次选择。
做完平凡贪心后,可以得到需要调整的 $k'$。这时有一个结论是,我们至多只会加入 / 删除 $2m$ 个物品,所以背包的值域是 $[-2m^2,2m^2]$ 的。证明可以看[这篇题解](https://www.luogu.com.cn/article/7fy9n6cb)。
于是用多重背包做整体调整即可。直接做是 $O(m^5)$ 的,二进制分组 $O(m^3\log m)$ 或单调队列 $O(m^3)$ 都可以通过。代码用二进制分组实现。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 305, M = 2e5 + 5;
int m, k;
int _a[2 * N], _c[2 * N], _f[2 * M + 5];
int *a = _a + N, *c = _c + N, *f = _f + M;
void _main() {
cin >> m >> k;
int sum = 0, cnt = 0;
for (int i = -m; i <= m; i++) {
cin >> a[i];
sum += i * a[i], cnt += a[i];
}
sum -= k;
if (sum == 0) return cout << cnt, void();
int res = 0;
if (sum > 0) {
for (int i = m; i >= 1; i--) {
if (sum == 0) break;
c[i] = min(a[i], sum / i);
sum -= c[i] * i, res += c[i];
}
} else {
for (int i = -m; i <= -1; i++) {
if (sum == 0) break;
c[i] = min(a[i], -sum / -i);
sum -= c[i] * i, res += c[i];
}
}
if (abs(sum) > M) return cout << "impossible", void();
vector<pair<int, int>> vec;
for (int i = -m; i <= m; i++) {
if (i == 0) continue;
int x = min(m, a[i] - c[i]), y = min(m, c[i]);
// x: remove y: add
for (int c = 1; x > 0; c <<= 1) {
int u = min(c, x);
vec.emplace_back(i * u, u);
x -= u;
}
for (int c = 1; y > 0; c <<= 1) {
int u = min(c, y);
vec.emplace_back(i * -u, -u);
y -= u;
}
}
memset(_f, 0x3f, sizeof(_f)), f[0] = 0;
for (auto [w, v] : vec) {
if (w > 0)
for (int i = M; i - w >= -M; i--) chkmin(f[i], f[i - w] + v);
else
for (int i = -M; i - w <= M; i++) chkmin(f[i], f[i - w] + v);
}
res += f[sum];
if (res > 1e18) cout << "impossible";
else cout << cnt - res;
}
```
:::::
## [CF1205D Almost All](https://www.luogu.com.cn/problem/CF1205D)
> 给出一棵 $n$ 个点的无根树,你需要为每条边赋一个边权,使得 $\forall d\in\left[1,\lfloor\frac{2n^2}{9}\rfloor\right]$,存在节点 $u,v$ 使得两点间距离为 $d$。
>
> $n\le10^3$,1 秒,250 MB。
:::::success[题解]
注意到 $\frac{2n^2}{9}=\frac{n}{3}\times\frac{2n}{3}$,联想 [P12038](https://www.luogu.com.cn/problem/P12038) 的结论:选取重心 $x$ 定根后,其子树一定能被分为两个集合 $S,T$ 使得 $\max(|S|,|T|)\le\frac{2n}{3}$。
给出构造式证明:
- 若 $x$ 的度数 $\le3$,必然有一个子树大小 $\in\left[\frac{1}{3}n,\frac{1}{2}n\right]$,取这个子树作为 $S$,剩余部分作为 $T$;
- 若 $x$ 的度数 $>3$,最小子树和次小子树的大小之和 $\le\frac{1}{2}{n}$,将其合并以后归纳构造。
实际上把子树按照大小升序排序,直接取走一段前缀即可实现上述过程。
拆成 $S,T$ 相当于按重心拆成两棵树。如果我们让一棵大小为 $n$ 的树的根链长度取遍 $1,2,\cdots,n-1$,则对 $S,T$ 做这个构造,令 $S$ 树的步长为 $1$,令 $T$ 树的步长为 $|S|$,此时整棵树的距离取遍 $1,2,\cdots,|S|\times|T|-1$。
钦定节点 $u$ 的根链长度 $d_u$,则叶向边 $u\to v$ 的边权赋为 $d_v-d_u$。因此只需满足 $d_v>d_u$,赋任意一组拓扑序均可。代码赋 DFS 序。
复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1005;
int n, x, sz[N], col[N];
vector<int> e[N];
void dfs1(int u, int fa) {
sz[u] = 1;
for (int v : e[u]) {
if (v == fa) continue;
dfs1(v, u), sz[u] += sz[v];
}
if (x == -1 && 2 * sz[u] >= n) x = u;
}
void dfs2(int u, int fa) {
col[u] = 1;
for (int v : e[u]) if (v != fa) dfs2(v, u);
}
int dn, dfn[N];
void dfs3(int u, int fa, int op, int mul) {
dfn[u] = ++dn;
if (fa != -1) cout << fa << ' ' << u << ' ' << (dfn[u] - dfn[fa]) * mul << '\n';
for (int v : e[u]) {
if (v == fa || col[v] != op) continue;
dfs3(v, u, op, mul);
}
}
void _main() {
cin >> n;
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
e[u].emplace_back(v), e[v].emplace_back(u);
}
x = -1, dfs1(1, -1), dfs1(x, -1);
sort(e[x].begin(), e[x].end(), [](int u, int v) {
return sz[u] < sz[v];
});
int cur = 0;
for (int u : e[x]) {
cur += sz[u]; dfs2(u, x);
if (cur >= n / 3) break;
}
dfs3(x, -1, 0, 1), dfs3(x, -1, 1, dn);
}
```
:::::
## [P4409 [ZJOI2006] 皇帝的烦恼](https://www.luogu.com.cn/problem/P4409)
> 给出 $n$ 个点的环,环上有点权 $a_i$。你需要为每个点分配一个正整数集合 $S_i$,使得 $|S_i|\ge a_i$ 且 $\forall i\in[0,n),S_i\cap S_{(i+1)\bmod n}=\varnothing$。最小化 $\left|\bigcup\limits_{i=1}^n S_i\right|$ 并输出。
>
> $n\le2\times10^4$,1 秒,125 MB。
:::::success[题解]
先考虑链上的情形。此时我们可以将 $S_0,S_2,\cdots$ 和 $S_1,S_3,\cdots$ 划分为两个等价类,保持等价类之间不交,等价类之内最大化交集。此时答案为
$$
\max_{i=0}^{n-1}(a_i+a_{(i+1)\bmod n})
$$
考虑偶数环的情形,此时等价类之间不交仍然成立,故直接输出即可。
在奇数环上,$0,n-1$ 被划进同一个等价类,这会导致上述策略不合法。一种贪心是划三个等价类,这是错的。考虑反例 `10 10 10 10 10`,划三类答案为 $30$,最优解为 $25$,因为 $S_5$ 和 $S_2,S_3$ 可以有交。
用一种本质的视角去刻画合法条件:$|S_0\cap S_{n-1}|=0$。这启示我们通过 DP 求出 $f_i=|S_0\cap S_i|_{\min}$,然后直接判定。
由于这个做法只能判定合法性,我们先二分答案 $k$。考虑 $f_i$ 的转移。此时:
- 必须不选择属于 $S_{i-1}$ 的元素;
- 尽量少选择属于 $S_0$ 的元素。
综上,我们希望最小化 $|S_{i-1}\cup S_0|$,容斥拆开:
$$
|S_{i-1}\cup S_0|=|S_0|+|S_{i-1}|-|S_0\cap S_{i-1}|
$$
记 $g_i=|S_0\cap S_i|_{\max}$,则有转移:
$$
\begin{aligned}
f_i&=\max\left(0,|S_i|-(|U|-(|S_0|+|S_{i-1}|-g_{i-1}))\right)\\
g_i&=\min\left(|S_i|,|S_0|-f_{i-1}\right)
\end{aligned}
$$
代入 $|S_i|=a_i,|S_0|=a_0,|U|=k$ 得转移
$$
\begin{aligned}
f_i&=\max(0,a_i-k+a_0+a_{i-1}-g_{i-1})\\
g_i&=\min(a_i,a_0-f_{i-1})
\end{aligned}
$$
此时答案 $k$ 合法,当且仅当其同时满足以下条件:
- $k\ge\max\limits_{i=0}^{n-1}(a_i+a_{(i+1)\bmod n})$;
- $\forall i,f_i\le g_i$;
- $f_{n-1}=0$。
一些实现细节:特判 $n=1$;二分下界取偶环答案;上界取 $3V$。总复杂度 $O(n\log V)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, a[N], f[N], g[N];
bool check(int k) {
f[0] = a[0], g[0] = a[0];
for (int i = 1; i < n; i++) {
f[i] = max(0, a[i] - k + a[0] + a[i - 1] - g[i - 1]);
g[i] = min(a[i], a[0] - f[i - 1]);
if (f[i] > g[i]) return false;
}
return f[n - 1] == 0;
}
void _main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) return cout << a[0], void();
int lo = 0;
for (int i = 0; i < n; i++) lo = max(lo, a[i] + a[(i + 1) % n]);
if (n % 2 == 0) return cout << lo, void();
int l = lo, r = 3e5, res = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) res = mid, r = mid - 1;
else l = mid + 1;
} cout << res;
}
```
:::::
## [QOJ5458 Shortest Path Query](https://qoj.ac/problem/5458)
> 给定一张 $n$ 个点 $m$ 条边的 DAG,每条边 $u_i\to v_i$ 有黑白两色,保证 $u_i<v_i$。$q$ 次询问,给定 $a,b,t$,求将黑边的边权视作 $a$,白边的边权视作 $b$ 时,$1\to t$ 的最短路长度,保证 $a,b\ge1$,保证 $1\to t$ 可达。
>
> $n,q\le5\times10^4$,$m\le10^5$,2 秒,1024 MB。
:::::success[题解]
预处理 $f_{u,x}$ 表示 $1\to u$ 走恰好 $x$ 条黑边,经过白边数目的最小值,查询答案为 $\min\limits_{x}(a\times x+b\times f_{u,x})$。
转二维平面分析,将 $(x,f_{u,x})$ 视作一个点,则询问是求 $ax_i+by_i$ 的最小值。根据斜率优化的结论,我们只需保留下凸壳上的点。
**定理** $n\times n$ 网格的整点凸壳顶点数至多 $O(n^{2/3})$。
根据定理,单调栈维护下凸壳后,DP 转移和询问都可暴力扫描。
复杂度 $O((m+q)n^{2/3})$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, m;
using node = pair<int, int>;
vector<node> e[N], c[N];
bool chk(node a, node b, node c) {
return 1LL * (b.se-a.se) * (c.fi-b.fi) >= 1LL * (c.se-b.se) * (b.fi-a.fi);
}
void _main() {
cin >> n >> m;
for (int i = 1, u, v, w; i <= m; i++) {
cin >> u >> v >> w;
e[u].emplace_back(v, w);
}
c[1].emplace_back(0, 0);
for (int u = 1; u <= n; u++) {
sort(c[u].begin(), c[u].end());
vector<node> st;
for (node& p : c[u]) {
while (st.size() > 1 && chk(st[st.size()-2], st.back(), p)) st.pop_back();
st.emplace_back(p);
}
c[u].swap(st);
for (auto [x, y] : c[u]) for (auto [v, w] : e[u]) {
if (w == 0) c[v].emplace_back(x + 1, y);
else c[v].emplace_back(x, y + 1);
}
}
int q; cin >> q;
for (int a, b, u; q--; ) {
cin >> a >> b >> u;
i64 res = 1e18;
for (auto [x, y] : c[u]) chkmin(res, 1LL * a * x + 1LL * b * y);
cout << res << '\n';
}
}
```
:::::
## [QOJ5500 Bars](https://qoj.ac/problem/5500)
> 给出 $n$ 个元素 $a_i$。你需要选择若干关键点,设你选择了 $k$ 个点 $b_i$,则得分为 $\sum\limits_{i=1}^{k-1}(b_{i+1}-b_i)(a_{b_i}+a_{b_{i+1}})$。最大化得分并输出。
>
>多测,$\sum n \le 3 \times 10^6$,6 秒,1024 MB。
:::::success[题解]
注意到$(b_{i+1}-b_i)(a_{b_i}+a_{b_{i+1}})$ 这个式子可以视为梯形面积的二倍。我们在二维平面上画出 $n$ 个点 $(i,a_i)$,则本题即选择一条折线,最大化折线与 $x$ 轴围成的面积。
不难发现选择一个凸包是最优的:

单调栈求出一个凸包即可,复杂度 $O(n)$。
**启示:观察题目所求的式子,找到其几何意义并尝试凸优化。**
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 5e5 + 5;
int n, a[N], f[N];
vector<int> st;
void _main() {
cin >> n, st.clear();
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) f[i] = a[i] * (i - 1);
for (int i = 1; i <= n; i++) {
while (st.size() >= 2) {
int p2 = st.back(), p1 = st[st.size() - 2];
if ((a[p2] - a[p1]) * (i - p2) > (a[i] - a[p2]) * (p2 - p1)) break;
st.pop_back();
}
if (!st.empty()) {
int j = st.back();
chkmax(f[i], f[j] + (a[i] + a[j]) * (i - j));
}
st.emplace_back(i);
}
int res = 0;
for (int i = 1; i <= n; i++) chkmax(res, f[i] + a[i] * (n - i));
cout << res << '\n';
}
```
:::::
:::::success[另解]
考虑 DP。但是这里每个位置的右侧贡献不好计算,于是我们贡献延后 DP,设 $f_i$ 为考虑了前 $i$ 个位置,钦定 $i$ 为关键点,仅计算 $i$ 的左侧贡献的最大得分。枚举上一个关键点 $j$ 有转移:
$$
f_i=\max_{j<i}(f_j+(i-j)(a_i+a_j))
$$
统计答案时再加入延后的贡献:
$$
\max_{i=1}^n(f_i+a_i(n-i))
$$
考虑斜率优化。设决策点 $k,j$ 满足 $k<j<i$,决策点 $j$ 优于决策点 $k$,则
$$
f_j+(a_i+a_j)(i-j)>f_k+(a_i+a_k)(i-k)
$$
整理得
$$
\dfrac{(f_j-a_j j)-(f_k-a_k k)+i(a_j-a_k)}{j-k}>a_i
$$
这里 $i,j,k$ 无法分离。我们考虑 DP 最优子结构的本质:如果 $k\to j\to i$ 是最优转移,那么有
$$
f_j=f_k+(a_j+a_k)(j-k)
$$
带入上式,消去 $f_k$ 并整理得
$$
\dfrac{a_j-a_k}{j-k}>\dfrac{a_i-a_j}{i-j}
$$
仍然只需维护上凸壳,复杂度 $O(n)$。
:::::
## [QOJ975 Game](https://qoj.ac/problem/975)
> 给出长为 $n$ 的序列 $a_i$。当现在位于 $x$ 时,有两种选择:
>
> 1. 结算:结束游戏并获得 $a_x$ 的得分。
> 2. 移动:需要 $x\ne1\land x\ne n$,以 $\frac{1}{2}$ 概率移动到 $x-1$,以 $\frac{1}{2}$ 概率移动到 $x+1$。
>
> 初始位置 $x$ 在 $[1,n]$ 中随机选择。最大化得分的期望,对 $998244353$ 取模。
>
> $n\le5\times10^5$,1 秒,256 MB。
:::::success[题解]
记 $f_i$ 为从 $i$ 开始的答案,容易写出转移:
$$
f_i=\max\left(a_i,\frac{f_{i-1}+f_{i+1}}{2}\right)
$$
转移带环,但是 $\max$ 无法高斯消元。因此观察性质。
设 $f_i=a_i$ 的点为关键点。我们发现,两个关键点之间,$f_i$ 是两侧的平均数。将 $(i,f_i)$ 画到二维平面上,则关键点之间的点两两共线:

上图中,红点为关键点,蓝点为非关键点。
贪心地,红点应当形成一个凸包。于是单调栈求出一个 $(i,a_i)$ 的凸包即可,复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 5e5 + 5;
int n, a[N];
vector<int> st;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
while (st.size() >= 2) {
int p2 = st.back(), p1 = st[st.size() - 2];
if ((a[p2] - a[p1]) * (i - p2) > (a[i] - a[p2]) * (p2 - p1)) break;
st.pop_back();
}
st.emplace_back(i);
}
mint res = a[1] + a[n];
for (int i = 1; i < (int)st.size(); i++) {
int p1 = st[i - 1], p2 = st[i];
res += mint(a[p1] + a[p2]) * (p2 - p1);
}
cout << res / (2 * n);
}
```
:::::
## [AGC044E Random Pawn](https://www.luogu.com.cn/problem/AT_agc044_e)
> 给出长为 $n$ 的环形序列 $a_i$。当现在位于 $x$ 时,有两种选择:
>
> 1. 结算:结束游戏并获得 $a_x$ 的得分。
> 2. 移动:代价为 $b_x$,以 $\frac{1}{2}$ 概率移动到 $x-1$,以 $\frac{1}{2}$ 概率移动到 $x+1$。
>
> 初始位置 $x$ 在 $[1,n]$ 中随机选择。最大化得分的期望,精度要求 $10^{-10}$。
>
> $n\le2\times10^5$,2 秒,1024 MB。
:::::success[题解]
考虑乱胡一个 DP。记 $f_i$ 为从 $i$ 点出发的答案,于是
$$
f_i=\max\left(a_i,\dfrac{f_{i-1}+f_{i+1}}{2}-b_i\right)
$$
上式中 $i-1,i+1$ 都是环上的下标。显然转移带环很难处理。
称 $f_i=a_i$ 的 $i$ 为关键点。可以发现,$a_i$ 的最大值处一定是关键点。因此从这一点断环为链后令 $a_{n+1}=a_1,b_{n+1}=b_1$,就变成了序列上的问题。
考虑序列上怎么处理。注意到 $b_i=0$ 就是上一题,因此消掉 $b_i$ 问题就解决了。考虑对 $f_i$ 加一个偏移量 $\Delta_i$,则
$$
f_i+\Delta_i=\max\left(a_i+\Delta_i,\dfrac{f_{i-1}+f_{i+1}}{2}-b_i+\Delta_i\right)
$$
化简并令常数项为 $0$ 得方程
$$
2\Delta_{i}=2b_i+\Delta_{i-1}+\Delta_{i+1}
$$
上式在确定 $\Delta_{i-1},\Delta_{i}$ 后可以递推。而递推初值可以任取,于是做完了,注意答案减去 $\Delta_i$ 即可。
复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 2e5 + 5;
int n, a[N], b[N], d[N];
vector<int> st;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
int p = max_element(a + 1, a + n + 1) - a;
rotate(a + 1, a + p, a + n + 1), rotate(b + 1, b + p, b + n + 1);
a[n + 1] = a[1], b[n + 1] = b[1];
for (int i = 2; i <= n; i++) d[i + 1] = 2 * d[i] - 2 * b[i] - d[i - 1];
for (int i = 1; i <= n + 1; i++) a[i] += d[i];
for (int i = 1; i <= n + 1; i++) {
while (st.size() >= 2) {
int p2 = st.back(), p1 = st[st.size() - 2];
if ((a[p2] - a[p1]) * (i - p2) > (a[i] - a[p2]) * (p2 - p1)) break;
st.pop_back();
}
st.emplace_back(i);
}
double res = 0;
for (int i = 1, j = 0; i <= n; i++) {
while (j + 1 < (int)st.size() && st[j + 1] < i) j++;
if (st[j] == i) {
res += a[i] - d[i];
} else {
int p1 = st[j], p2 = st[j + 1];
double k = a[p1] + 1.0 * (a[p2] - a[p1]) * (i - p1) / (p2 - p1);
res += k - d[i];
}
}
cout << fixed << setprecision(12) << res / n;
}
```
:::::
## [AGC032B Balanced Neighbors](https://www.luogu.com.cn/problem/AT_agc032_b)
> 对于无向简单连通图 $G=(V,E)$,设
>
> $$
>f(u)=\sum_{(u,v)\in E}v
>$$
>
> 给定正整数 $n$,要求构造一个无向简单连通图 $G=(V,E)$,使得 $V=\{1,2,3,\cdots,n\}$ 且 $f(u)$ 全相等。
>
> $3\le n\le100$,2 秒,1024 MB。
:::::success[题解]
其实不一定要从补图的角度出发。考虑分组构造:将 $1\sim n$ 的顶点分为若干组,不同组之间互相连边,同组之间不连边。
由于 $\sum\limits_{i=1}^n i=\frac{n(n+1)}{2}$,只要每组内部的和相同,设为 $C$,则 $f(u)$ 恒等于 $\frac{n(n+1)}{2}-C$。接下来随便写构造:
- 若 $n$ 为偶数:分组 $\{1,n\},\{2,n-1\},\cdots$,每组之和 $n+1$;
- 若 $n$ 为奇数:分组 $\{n\},\{1,n-1\},\{2,n-2\},\cdots$,每组之和 $n$。
模拟即可,复杂度 $O(n^2)$。
:::::
:::::info[代码]
```cpp line-numbers
int n;
void _main() {
cin >> n;
vector<vector<int>> vec;
if (n & 1) {
vec.push_back({n});
for (int i = 1; i <= n / 2; i++) vec.push_back({i, n - i});
} else {
for (int i = 1; i <= n / 2; i++) vec.push_back({i, n - i + 1});
}
vector<pair<int, int>> e;
for (int i = 0; i < (int)vec.size(); i++)
for (int u : vec[i])
for (int j = i + 1; j < (int)vec.size(); j++)
for (int v : vec[j]) e.emplace_back(u, v);
cout << e.size() << '\n';
for (auto i : e) cout << i << '\n';
}
```
:::::
## [ARC207B Balanced Neighbors 2](https://www.luogu.com.cn/problem/AT_arc207_b)
> 对于无向简单连通图 $G=(V,E)$,记 $d(u,v)$ 为两点间距离,设
>
> $$
>f(u)=\sum_{0<d(u,v)\le2}v
>$$
>
> 给定正整数 $n$,要求构造一个无向简单连通图 $G=(V,E)$,使得 $V=\{1,2,3,\cdots,n\}$ 且 $f(u)$ 全相等。给出构造或报告无解。
>
> $2\le n\le200$,2 秒,1024 MB。
:::::success[题解]
手玩或者写一个 $O(2^{n(n+1)/2})$ 的暴力可以验证 $n\le5$ 无解,而 $n=6,7$ 均有解。猜想 $n>5$ 一定有解。
观察样例,以 $3,4$ 为例,标记出其 $1$ 邻域和 $2$ 邻域:


还可以依次验证 $1\sim6$,得到如下构造:节点 $i$ 恰有 $n-i+1$ 一个点不可达。正确性容易说明。
考虑如何实现这个情况。以 $n=8$ 为例,构造一个二分图,左部点为 $1,3,5,7$,右部点为 $2,4,6,8$。除钦定不可达的点对外,左右部点都要连边。这样右部点除不可达点外,是左部点的 $1$ 邻域,所有左部点都是其 $2$ 邻域。

发现 $n$ 为偶数时可以套用这一构造。下面考虑 $n$ 为奇数的情况。
可以在上述基础上调整。观察搜出来的 $n=7$ 构造,可以得到这样一种调整:

首先,加入 $9$ 不会破坏 $f(1)\sim f(8)$ 全相等。

同时,所有右部点为 $9$ 的 $1$ 邻域,左部点为 $9$ 的 $2$ 邻域,并且 $f(9)=36$,恰与 $f(1)\sim f(8)$ 相同。
$n\le4$ 时上述方法构造的图不连通,$n=5$ 容易验证不可行。这也说明了 $n\le5$ 时无解的猜想。
按照上述方法构造即可,复杂度 $O(n^2)$。
:::::
:::::info[代码]
```cpp line-numbers
int n;
void _main() {
cin >> n; int m = n / 2 * 2;
if (n <= 5) return cout << -1, void();
vector<pair<int, int>> e;
for (int i = 1; i <= m; i += 2) {
for (int j = 2; j <= m; j += 2) {
if (i + j != m + 1) e.emplace_back(i, j);
}
}
if (n & 1) for (int i = 2; i < n; i += 2) e.emplace_back(n, i);
cout << e.size() << '\n';
for (auto i : e) cout << i << '\n';
}
```
:::::
## [P14662 异邻或居](https://www.luogu.com.cn/problem/P14662)
> 对于无向简单连通图 $G=(V,E)$,设
> $$
>f(u)=\bigoplus_{(u,v)\in E}v
>$$
>
> 给定正整数 $n$,要求构造一个无向简单连通图 $G=(V,E)$,使得 $V=\{1,2,3,\cdots,n\}$ 且 $f(u)$ 全相等。给出方案或报告无解。
>
> 多测,$T=100$,$1\le n\le100$,1 秒,512 MB。
:::::::success[题解]
首先特判 $n=1$。
::::info[定理 1]{open}
设 $k\in\mathbb{N}^+$,则 $n=2^k$ 时无解。
::::
:::success[定理 1 的证明]
考虑节点 $n$ 的最高二进制位为 $1$,且仅有节点 $n$ 的该位为 $1$。
则对于 $f(n)$,该位必然为 $0$。又因为图为连通图,所以总存在一个节点 $u\in[1,n)$,$(u,n)\in E$,此时 $f(u)$ 的该位必然为 $1$,则 $f(u)\ne f(n)$。
:::
接下来的构造需要注意到 [P3908](https://www.luogu.com.cn/problem/P3908) 的结论:
::::info[定理 2]{open}
$$
S(n)=\bigoplus_{i=1}^n i=\left\{\begin{matrix}
n & n\equiv0\pmod4 \\
1 & n\equiv1\pmod4 \\
n+1 & n\equiv2\pmod4 \\
0 &n\equiv3\pmod4
\end{matrix}\right.
$$
::::
:::success[定理 2 的证明]
设 $k\in\mathbb{N^+}$。显然 $n=1,2,3,4$ 时 $S(n)$ 符合规律,用数学归纳法证明:
- 当 $n=4k$ 时,$S(n)=S(4k)=S(4k-1)\oplus4k=0\oplus4k=4k=n$。
- 当 $n=4k+1$ 时,$S(n)=S(4k+1)=S(4k)\oplus(4k+1)=4k\oplus(4k+1)=1$。
- 当 $n=4k+2$ 时,$S(n)=S(4k+2)=S(4k+1)\oplus(4k+2)=1\oplus(4k+2)=1+4k+2=4k+3=n+1$。
- 当 $n=4k+3$ 时,$S(n)=S(4k+3)=S(4k+2)\oplus(4k+3)=(4k+3)\oplus(4k+3)=0$。
证毕。
:::
判掉 $n=2^k$ 后,接下来按 $n\bmod4$ 分类讨论:
:::::info[$n\equiv3\pmod4$]
构造一个以 $n$ 为根的菊花图。
::::success[正确性]{open}
- $f(n)=S(n-1)=n-1+1=n$。
- $\forall i\in[1,n),f(i)=n$。
::::
边数为 $n-1$。
:::::
:::::info[$n\equiv2\pmod4$]
分为三组 $A=\{1,n\},B=\{2,n-1\},C=\{3,4,\cdots,n-2\}$。组内的点相互之间不连边,组与组之间两两连边。
::::success[正确性]{open}
- $A$ 集合的编号异或和 $a=1\oplus n=n+1$。
- $B$ 集合的编号异或和 $a=2\oplus(n-1)=n+1$。
- $C$ 集合的编号异或和 $c=S(n-2)\oplus1\oplus2=(n-2)\oplus1\oplus2=n+1$。
- 因此 $a=b=c$。取补图显然成立。
::::
边数为 $2\times2+2(n-4)+2(n-4)=4n-12$。
:::::
:::::info[$n\equiv1\pmod4$]
取若干段区间 $A_i=[4i-6,4i-3]$,约定 $A_1=\{1\}$。对于区间 $A_i=\{4i-6,4i-5,4i-4,4i-3\}$ 内部连边 $(4i-6,4i-4),(4i-6,4i-3),(4i-5,4i-4),(4i-5,4i-3)$。
对于 $A_1$,将 $i=2,3,\cdots,n$ 都连边 $(i,1)$。
::::success[正确性]{open}
- $f(1)=S(n)\oplus1=1\oplus1=0$。
- $f(4i-5)=f(4i-6)=(4i-4)\oplus(4i-3)\oplus1=(4i-4)\oplus(4i-4)=0$。
- $f(4i-3)=f(4i-4)=(4i-6)\oplus(4i-5)\oplus1=(4i-6)\oplus(4i-6)=0$。
::::
边数为 $n-1+4\times\dfrac{n-1}{4}=2n-2$。
:::::
:::::info[$n\equiv0\pmod4$]
分为三组 $A=\{n\},B=\{\operatorname{lowbit}(n),n-\operatorname{lowbit}(n)\},C=V\backslash A\backslash B$。组内的点相互之间不连边,组与组之间两两连边。
::::success[正确性]{open}
- $A$ 集合的编号异或和 $a=1$。
- $B$ 集合的编号异或和 $a=\operatorname{lowbit}(n)\oplus(n-\operatorname{lowbit}(n))=1$。
- $C$ 集合的编号异或和 $c=S(n)\oplus a\oplus b=S(n)=1$。
- 因此 $a=b=c$。取补图显然成立。
::::
边数为 $1\times2+1\times(n-3)+2\times(n-3)=3n-7$。
:::::
至此完成构造。
:::::::
::::::info[代码]
```cpp line-numbers
const int N = 105;
int n;
vector<pair<int, int>> vec;
void A(int u, int v) {vec.emplace_back(u, v);}
void E() {
cout << vec.size() << '\n';
for (const auto& e : vec) cout << e << '\n';
}
void P(vector<int> a, vector<int> b, vector<int> c) {
for (int i : a) for (int j : b) A(i, j);
for (int i : b) for (int j : c) A(i, j);
for (int i : a) for (int j : c) A(i, j);
}
void _main() {
cin >> n;
if (n == 1) return cout << 0 << '\n', void();
if ((1 << lg(n)) == n) return cout << -1 << '\n', void();
vec.clear();
switch (n & 3) {
case 0: {
vector<int> c;
for (int i = 1; i < n; i++) {
if (i != lowbit(n) && i != n - lowbit(n)) c.emplace_back(i);
}
P({n}, {lowbit(n), n - lowbit(n)}, c);
break;
}
case 1: {
// vector<int> c;
// for (int i = 4; i <= n; i++) c.emplace_back(i);
// P({1}, {2, 3}, c);
for (int i = 2; i <= n; i += 4) A(i, i + 2), A(i, i + 3), A(i + 1, i + 2), A(i + 1, i + 3);
for (int i = 2; i <= n; i++) A(1, i);
break;
}
case 2: {
vector<int> c;
for (int i = 3; i < n - 1; i++) c.emplace_back(i);
P({1, n}, {2, n - 1}, c);
break;
}
case 3:
for (int i = 1; i < n; i++) A(i, n);
break;
} E();
}
```
::::::
## [ARC121D 1 or 2](https://www.luogu.com.cn/problem/AT_arc121_d)
> 给出一个长为 $n$ 的序列 $a_i$。一次操作可以从 $a$ 中选择一个或两个数,将它们的和插入集合 $S$,然后删去这些数。最小化 $a_i$ 为空时的 $\max S-\min S$ 并输出。
>
> $n\le5000$,$-10^9\le a_i\le10^9$,2 秒,1024 MB。
:::::success[题解]
考虑钦定一个集合 $S$,表示 $S$ 中的数是单独被选出来的。对于 $x\in S$,将其描述为 $x\to0$ 的双选,将操作化归为一种。
枚举 $S$ 的大小,在序列中插入 $|S|$ 个 $0$,则问题转化为将所有数字两两匹配,最小化整体极差。
结论:将 $a_i$ 升序排序后,匹配 $1\to n,2\to n-1,\cdots$ 为最优解。
::::success[证明]{open}
考虑序列 $a_1,a_2,\cdots,a_{2k}$。假定最优解中 $a_1\to a_{2k}$ 没有配对。记此时的配对为 $a_1\to x,a_{2k}\to y$。
调整法,将配对修改为 $a_1\to a_{2k},x\to y$。容易说明,局部 $\min$ 必然不会更小,局部 $\max$ 必然不会更大,即调整不劣。
同理,也可以对 $a_2\to a_{2k-1},a_3\to a_{2k-2},\cdots$ 执行上述论证。在有限步调整后,策略必然是首尾配对的贪心策略。
::::
于是用插入排序维护序列,每轮暴力计算,复杂度 $O(n^2)$。
**启示:引入单位元实现操作的化归;相交 & 相离劣于包含。**
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 1e4 + 5, inf = 4e9;
int n;
void _main() {
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
int res = inf;
for (int k = 0; k <= n; k++) {
int mx = -inf, mn = inf;
for (int i = 0, j = a.size() - 1; i <= j; i++, j--) {
if (i == j) chkmax(mx, a[i]), chkmin(mn, a[i]);
else chkmax(mx, a[i] + a[j]), chkmin(mn, a[i] + a[j]);
}
chkmin(res, mx - mn);
a.insert(lower_bound(a.begin(), a.end(), 0), 0);
}
cout << res;
}
```
:::::
## [P12568 [UOI 2023] An Array and Range Additions](https://www.luogu.com.cn/problem/P12568)
> 给出一个长为 $n$ 的序列 $a_i$。一次操作选择一个区间 $[l,r]$ 和任意整数 $x$,令 $\forall i\in[l,r],a_i\gets a_i+x$。求使得 $a_i$ 中元素两两不同的最小操作次数。
>
> $n\le2\times10^5$,2 秒,256 MB。
:::::success[题解]
首先,由于 $x$ 可以选的充分大,我们一定可以让一个区间在操作后与外部不同。贪心地,我们将数组分为若干极长段,使得段内没有重复元素,然后用操作将每段分开。
记段数为 $c$。若 $c$ 为偶数 $2k$,此时 $k$ 次操作产生 $2k$ 个分隔,所以操作够用,直接输出 $k$ 即可。
若 $c$ 为奇数 $2k+1$,此时我们如果再用 $k$ 次操作,序列就不能被完全覆盖。具体来说,极长的前后缀不会被覆盖。因此,能在 $k$ 次操作内解决问题的充要条件为:可以找到合法前缀 $[1,l]$ 和后缀 $[r,n]$,满足:
- $[1,l]\cup[r,n]$ 内元素两两不同;
- 中间剩余部分 $(l,r)$ 的分段数 $\le k-2$。
若无法找到就必须多花一次操作处理前后缀,答案变为 $k+1$。
接下来解决这个问题。我们先预处理 $f_i$ 表示以 $i$ 为起点的合法段,最多能延伸到哪里。形式化地,$f_i$ 为 $i$ 之后第一个出现重复元素的位置。
通过不断令 $i\gets f_i$ 向后跳,我们可以求出覆盖 $[l,r]$ 所需的段数 $f(l,r)$。可以对 $f$ 做倍增优化。
接下来我们可以用双指针来维护 $l,r$。列出 $l,r$ 满足的条件:
- $[1,l]$ 内元素两两不同;
- $[r,n]$ 内元素两两不同;
- $[1,l],[r,n]$ 中元素无交集;
- $f(l+1,r-1)\le k-2$。
对前两个约束,可以直接得到 $l_{\max}$ 和 $r_{\min}$。第三个约束可以通过记录 $[1,l]$ 中所有元素最后出现位置的最大值来解决。通过这些范围取交集得到 $r$ 以后,直接判定 $f(l+1,r-1)$ 即可。
复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, m, a[N], d[N], nxt[N], pos[N], last[N], f[20][N];
int check(int l, int r) {
if (l > r) return 0;
int res = 1;
for (int i = lg(n + 1); i >= 0; i--) {
if (f[i][l] <= r) l = f[i][l], res += 1 << i;
}
return res;
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], d[i] = a[i];
sort(d + 1, d + n + 1), m = unique(d + 1, d + n + 1) - d - 1;
for (int i = 1; i <= n; i++) a[i] = lower_bound(d + 1, d + m + 1, a[i]) - d;
bitset<N> S;
int cnt = 1;
for (int i = 1; i <= n; i++) {
if (S.test(a[i])) cnt++, S.reset();
S.set(a[i]);
}
if (cnt == 1) return cout << 0, void();
if (cnt % 2 == 0) return cout << cnt / 2, void();
int k = (cnt - 1) / 2;
if (a[1] == a[n]) return cout << k + 1, void();
nxt[n + 1] = n + 1;
for (int i = n; i >= 1; i--) {
nxt[i] = nxt[i + 1];
if (pos[a[i]]) nxt[i] = min(nxt[i], pos[a[i]]);
pos[a[i]] = i;
}
copy(nxt + 1, nxt + n + 2, f[0] + 1);
for (int i = 1; (1 << i) <= n + 1; i++) {
for (int j = 1; j <= n + 1; j++) f[i][j] = f[i - 1][f[i - 1][j]];
}
bitset<N> pre, suf;
int pmax = n, smin = 1;
for (int i = 1; i <= n; i++) {
if (pre.test(a[i])) {pmax = i - 1; break;}
pre[a[i]] = 1;
}
for (int i = n; i >= 1; i--) {
if (suf.test(a[i])) {smin = i + 1; break;}
suf[a[i]] = 1;
}
pre.reset();
for (int i = 1; i <= n; i++) last[a[i]] = i;
int to = 1;
for (int i = 1; i <= pmax; i++) {
pre[a[i]] = 1, to = max(to, last[a[i]] + 1);
int r = max({smin, i, to});
if (check(i + 1, r - 1) <= cnt - 2) return cout << k, void();
} cout << k + 1;
}
```
:::::
## [P14593 [LNCPC 2025] 猫猫虫打 CF](https://www.luogu.com.cn/problem/P14593)
> 给出 $n$ 个元素 $(a_i,b_i)$。你初始持有非负整数 $x=0$,每次可以选择一个没选过且 $x\le a_i$ 的元素,然后令 $x\gets\max(x,b_i)$ 并获得 $1$ 的得分。最大化得分并输出。
>
> $n\le10^6$,2 秒,512 MB。
:::::success[题解]
考虑按某种顺序排序以后直接 DP。
我们做一个 exchange argument,考虑两个元素 $(a_1,b_1),(a_2,b_2)$,可以先 $1$ 后 $2$ 而不能先 $2$ 后 $1$。用数学语言刻画就是 $a_1<b_2\land a_2>b_1$。
这个东西不满足传递性,所以不能直接排序。考虑找一个必要条件,将两边加起来得到 $a_1+b_1<a_2+b_2$,或者加一乘起来得 $(a_1+1)(b_1+1)<(a_2+1)(b_2+1)$,总之找到一个严格全序的条件排序即可。
排序完成后,我们进行 DP,设 $f_{i,j}$ 表示考虑了前 $i$ 个元素,当前的 $x$ 为 $j$ 的最大得分。转移为:
- $f_{i,j}\to f_{i+1,j}$;
- $f_{i,j}+1\to f_{i+1,\max(j,b_i)}$,其中 $j\le a_i$。
直接做为 $O(nV)$,不难发现第二维可以离散化降到 $O(n^2)$。
考虑将第一维滚动数组,则第一条转移消去。对第二条转移,我们对 $\max$ 分类讨论:
- $j\le a_i\land j\le b_i$ 时,$f_{i,j}+1\to f_{i+1,b_i}$;
- $j\le a_i\land j>b_i$ 时,$f_{i,j}+1\to f_{i+1,j}+1$。
第一条转移相当于对 $[0,\min(a_i,b_i)]$ 查询区间 $\max$ 然后做单点更新,第二条转移是对 $(b_i,a_i]$ 做区间 $+1$。线段树维护 $f$ 数组即可,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 2e6 + 5;
#define x first
#define y second
using node = pair<int, int>;
int n, m, d[N];
int P(int x) {return lower_bound(d + 1, d + m + 1, x) - d;}
node a[N];
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
int val[N << 2], add[N << 2];
void pushup(int rt) {val[rt] = max(val[ls], val[rs]);}
void apply(int rt, int c) {val[rt] += c, add[rt] += c;}
void pushdown(int rt) {
if (!add[rt]) return;
apply(ls, add[rt]), apply(rs, add[rt]), add[rt] = 0;
}
void set(int x, int c, int l = 0, int r = m, int rt = 1) {
if (l == r) return val[rt] = c, void();
int mid = (l + r) >> 1; pushdown(rt);
if (x <= mid) set(x, c, l, mid, ls);
else set(x, c, mid + 1, r, rs);
pushup(rt);
}
void update(int tl, int tr, int c, int l = 0, int r = m, int rt = 1) {
if (tl <= l && r <= tr) return apply(rt, c), void();
int mid = (l + r) >> 1; pushdown(rt);
if (tl <= mid) update(tl, tr, c, l, mid, ls);
if (tr > mid) update(tl, tr, c, mid + 1, r, rs);
pushup(rt);
}
int ask(int tl, int tr, int l = 0, int r = m, int rt = 1) {
if (tl <= l && r <= tr) return val[rt];
int mid = (l + r) >> 1, res = 0; pushdown(rt);
if (tl <= mid) res = max(res, ask(tl, tr, l, mid, ls));
if (tr > mid) res = max(res, ask(tl, tr, mid + 1, r, rs));
return res;
}
} sgt;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], d[i] = a[i].x, d[i + n] = a[i].y;
sort(d + 1, d + 2 * n + 1);
m = unique(d + 1, d + 2 * n + 1) - d - 1;
sort(a + 1, a + n + 1, [](const node& a, const node& b) -> bool {
return a.x + a.y < b.x + b.y;
});
for (int i = 1; i <= n; i++) {
int pa = P(a[i].x), pb = P(a[i].y);
sgt.set(pb, sgt.ask(0, min(pa, pb)) + 1);
if (pb < pa) sgt.update(pb + 1, pa, 1);
} cout << sgt.ask(0, m);
}
```
:::::
## [ZR3277 套娃](https://zhengruioi.com/problem/3277)
> 给出一个长为 $n$ 的序列 $a_i$。称子序列 $b$ 合法当且仅当将 $b$ 升序排序后 $\forall k,b_k\ge k-1$。对原序列的每个前缀,将其划分为若干合法子序列,最小化子序列数目并输出。
>
> $n\le10^6$,$0\le a_i<n$,0.5 秒,1024 MB。
:::::success[题解]
对于容量阈值 $x$,其所在的序列中只能容纳 $x$ 个容量 $<x$ 的元素。
设前缀中共有 $c_i$ 个容量 $<i$ 的元素。贪心地,答案有一个下界 $\lceil\frac{c_i}{i}\rceil$,将所有下界取 $\max$ 即为最少组数。我们猜想这个下界可以取到。
::::success[充分性]
建立二分图,其中 $n$ 个左部点 $l_i$ 和右部点 $r_i$。
我们先考虑判定性问题,即判定答案 $k$ 是否合法。可以使用最大流的方法,建立超级源点 $S$ 和汇点 $T$,如下建图:
- $S\to l_i$:容量为 $k$,表示容量的物理限制;
- $l_i\to r_j$,其中 $j\le i$:容量为 $+\infty$;
- $r_i\to T$:容量为 $c_i$,表示需要安置的元素数目。
若 $S\to T$ 的最大流为 $n$,说明所有元素都有合法匹配。答案合法。
将最大流转化为最小割,相当于网络流的集合划分模型。
考虑割去前 $x$ 条边,即割断 $S\to l_1\sim l_x$,代价为 $x\times k$。右部也应当割掉容量 $>x$ 的 $r_i\to T$ 的边。则最小割容量为 $xk+n-c_x$。
由方程 $xk+n-c_x=n$ 得 $k\ge\lceil\frac{c_x}{x}\rceil$,充分性证毕。
::::
这样直接求 $\max\limits_{i=1}^n\lceil\frac{c_i}{i}\rceil$ 即为 $O(n^2)$。
我们对值域扫描线,考虑每个 $i$ 会增加哪些前缀的答案。对于容量阈值 $i$,若使得前缀答案 $\ge j+1$,则 $\lceil\frac{c_i}{i}\rceil\ge j+1\implies c_i\ge j\times i+1$。
对于扫描到的位置 $i$,我们找到第 $j\times i+1$ 个元素的位置 $p$,则 $[p,n]$ 中的答案需要对 $j+1$ 做 chkmax。我们只对 $p$ 位置更新答案,最后答案做前缀 $\max$ 即可。
事实上,$j$ 只需枚举到 $c_i-1$,因为 $j\ge c_i$ 时产生的约束已经在 $i-1$ 前处理过,并且更优。由于 $\sum c_i=n$,因此 $j$ 的循环只会执行 $O(n)$ 次。
使用树状数组倍增维护第 $j\times i+1$ 个位置,总复杂度 $O(n\log n)$ 且常数较小,可以通过。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e6 + 5;
int n, a[N], ans[N];
vector<int> pos[N];
struct BIT {
int tr[N];
void add(int x, int c) {
for (; x <= n; x += lowbit(x)) tr[x] += c;
}
int kth(int k) {
int p = 0, s = 0;
for (int i = lg(n); i >= 0; i--) {
if (p + (1 << i) <= n && s + tr[p + (1 << i)] < k) p += 1 << i, s += tr[p];
}
return p + 1;
}
} B;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], pos[a[i] + 1].emplace_back(i);
fill(ans + 1, ans + n + 1, 1);
for (int i = 1, cnt = 0; i <= n; i++) {
for (int j : pos[i]) B.add(j, 1), cnt++;
for (int j = 0; j < (int)pos[i].size(); j++) {
if (j * i + 1 > cnt) break;
int k = B.kth(j * i + 1);
chkmax(ans[k], j + 1);
}
}
for (int i = 1; i <= n; i++) chkmax(ans[i], ans[i - 1]), cout << ans[i] << ' ';
}
```
:::::
## [CF2196D Double Bracket Sequence](https://www.luogu.com.cn/problem/CF2196D)
> 给出一个长为 $n$ 的括号串 $s_i$,字符集为 `()[]`。你可以任意修改一些位置,修改后需满足所有圆括号 & 方括号构成的子序列是一个合法括号串。最小化修改次数并输出。
>
> 多测,$\sum n\le2\times10^5$,$n$ 为偶数,2 秒,250 MB。
:::::success[题解]
容易发现已匹配完成的就不用改了,所以我们先跑两次括号匹配,将已匹配的字符删去。
考虑一种平凡贪心,对于剩余字符串,我们总让相邻两个匹配。此时的答案即长度的一半。
我们会发现一个反例:`)(`。这种情况需要 $2$ 次操作。仔细思考一下,这种反例只会出现至多一次。那么我们考虑直接特判,来推一下充要条件:
- 所有失配左括号的数目为奇数;
- 最左端的左括号出现位置大于最右端的右括号。
第一个条件可以推出,必然会有一个左括号只能与右括号匹配。第二个条件说明无论如何安排,必有 `)(` 或 `](` 型出现。
复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n;
char s[N];
void _main() {
cin >> n >> (s + 1);
stack<int> s1, s2;
vector<int> L, R;
for (int i = 1; i <= n; i++) {
if (s[i] == '(') s1.emplace(i);
else if (s[i] == '[') s2.emplace(i);
else if (s[i] == ')') s1.empty() ? (R.emplace_back(i), 0) : (s1.pop(), 0);
else s2.empty() ? (R.emplace_back(i), 0) : (s2.pop(), 0);
}
int c1 = s1.size() + s2.size(), c2 = R.size(), l = n + 1, r = 0;
for (int i : R) r = max(r, i);
while (!s1.empty()) l = min(l, s1.top()), s1.pop();
while (!s2.empty()) l = min(l, s2.top()), s2.pop();
int res = (c1 + c2) / 2;
if (c1 % 2 && l > r) res++;
cout << res << '\n';
}
```
:::::
## [UOJ1067 拆弹专家](https://uoj.ac/problem/1067)
> 给出两个长为 $n$ 的序列 $a_i,b_i$,保证 $a_i$ 和 $b_i$ 构成的多重集相同。现有 $q$ 时刻,第 $i$ 个时刻中你可以任意重排序列 $a_i$ 下标在 $[l_i,r_i]$ 中的数字。求 $\forall1\le i\le n,a_i=b_i$ 的最早时刻,或报告无解。
>
> $n\le10^4$,$q\le2\times10^6$,1 秒,512 MB。
:::::warning[提示]{open}
讲的是被卡常的做法,无法通过本题。
:::::
:::::success[题解]
考虑对 $a_i$ 赋一个目标位置 $x_i$,相同数字就按位置依次匹配。一次操作转化为将区间 $[l_i,r_i]$ 任意重排,求 $\forall i,x_i=i$ 的最早时刻。
贪心地,一次操作一定是将 $x_{[l,r]}$ 升序排序,从逆序对数的角度容易说明正确性。
因此我们只需维护两个操作:区间升序排序、判定序列是否有序。
一个标准的做法是 ODT & 线段树分裂合并。具体地,我们维护若干连续段表示排好序的区间,每个区间开一棵权值线段树,ODT 分裂合并时同时对线段树分裂合并。在线段树上维护子树 min & max,就能算出归位的数的数目,复杂度 $O(q\log n)$。
然而这个题极度卡常,线段树底层分块都只有 97pts,卡不动了,爆。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e4 + 5, M = 3e5 + 5, B = 200, inf = 1e9;
int n, q, a[N], b[N], x[N], cnt;
vector<int> pos[N];
int tot, ls[M], rs[M], sum[M], lo[M], hi[M], top, st[M];
u64 mask[M];
int create() {
int x = top ? st[top--] : ++tot;
return ls[x] = rs[x] = sum[x] = mask[x] = 0, lo[x] = inf, hi[x] = -inf, x;
}
void pushup(int x) {
if (!x) return;
sum[x] = sum[ls[x]] + sum[rs[x]];
lo[x] = min(lo[ls[x]], lo[rs[x]]), hi[x] = max(hi[ls[x]], hi[rs[x]]);
}
void insert(int x, int l, int r, int& rt) {
if (!rt) rt = create();
if (l == r) {
mask[rt] |= 1ULL << ((x - 1) & 63);
chkmin(lo[rt], x), chkmax(hi[rt], x);
return sum[rt]++, void();
}
int mid = (l + r) >> 1, b = (x - 1) >> 6;
if (b <= mid) insert(x, l, mid, ls[rt]);
else insert(x, mid + 1, r, rs[rt]);
pushup(rt);
}
void build(int x, int id) {
sum[x] = popcount(mask[x]);
lo[x] = mask[x] ? (id + ctz(mask[x])) : inf;
hi[x] = mask[x] ? (id + lg(mask[x])) : -inf;
}
void split(int k, int l, int r, int& x, int& y) {
if (!x || k == sum[x]) return y = 0, void();
if (k == 0) return y = x, x = 0, void();
y = create();
if (l == r) {
mask[y] = mask[x];
for (int i = 0; i < k; i++) mask[y] &= mask[y] - 1;
mask[x] ^= mask[y];
return build(x, l * 64 + 1), build(y, l * 64 + 1), void();
}
int mid = (l + r) >> 1;
if (k < sum[ls[x]]) split(k, l, mid, ls[x], ls[y]), rs[y] = rs[x], rs[x] = 0;
else if (k == sum[ls[x]]) rs[y] = rs[x], rs[x] = 0;
else split(k - sum[ls[x]], mid + 1, r, rs[x], rs[y]);
pushup(x), pushup(y);
}
int merge(int l, int r, int x, int y) {
if (!x || !y) return x ? x : y;
if (l == r) {
mask[x] |= mask[y], sum[x] = popcount(mask[x]);
lo[x] = min(lo[x], lo[y]), hi[x] = max(hi[x], hi[y]);
return st[++top] = y, x;
}
sum[x] += sum[y]; int mid = (l + r) >> 1;
ls[x] = merge(l, mid, ls[x], ls[y]);
rs[x] = merge(mid + 1, r, rs[x], rs[y]);
return st[++top] = y, pushup(x), x;
}
struct node {
int l, r, rt;
node(int a, int b, int c) : l(a), r(b), rt(c) {}
bool operator< (const node& a) const {return l < a.l;}
};
set<node> odt;
using point = set<node>::iterator;
point add(int l, int r, int x) {
if (lo[x] == l && hi[x] == r) cnt += r - l + 1;
return odt.emplace(l, r, x).first;
}
void remove(point& it) {
auto [l, r, x] = *it;
if (lo[x] == l && hi[x] == r) cnt -= r - l + 1;
odt.erase(it);
}
point split(int x) {
point it = odt.lower_bound(node(x, 0, 0));
if (it != odt.end() && it->l == x) return it;
auto [l, r, rt] = *(--it); remove(it);
int nx = 0; split(x - l, 0, B, rt, nx);
add(l, x - 1, rt);
return add(x, r, nx);
}
void modify(int l, int r) {
point itr = split(r + 1), itl = split(l);
int nx = 0;
for (point it = itl; it != itr; ) {
point cur = it++;
nx = merge(0, B, nx, cur->rt), remove(cur);
} add(l, r, nx);
}
void _main() {
read(n, q), read(a + 1, a + n + 1), lo[0] = inf, hi[0] = -inf;
for (int i = 1; i <= n; i++) read(b[i]), pos[b[i]].emplace_back(i);
for (int i = n; i >= 1; i--) x[i] = pos[a[i]].back(), pos[a[i]].pop_back();
for (int i = 1; i <= n; i++) {
int rt = 0; insert(x[i], 0, B, rt);
add(i, i, rt);
}
if (cnt == n) return cout << 0, void();
for (int i = 1, l, r; i <= q; i++) {
read(l, r); modify(l, r);
if (cnt == n) return cout << i, void();
} cout << q + 1;
}
```
:::::
## [AT1202Contest_j Hated Number](https://www.luogu.com.cn/problem/AT1202Contest_j)
> 给出 $x,m$。你需要构造一个整数集合 $S$,满足:
> - $|S|\le20$;
> - $\forall i\in S,1\le i\le10^5$;
> - $\forall1\le k\le m\land k\ne x,\exists T\subseteq S,\sum\limits_{i\in T}i=k$;
> - $\forall T\subseteq S,\sum\limits_{i\in T}i\ne x$。
>
> 输出构造或报告无解。
>
> 多测,$T\le100$,$1\le x\le m\le10^5$,2 秒,1024 MB。
:::::success[题解]
考虑没有 $x$ 的限制时咋做。最简单的想法就是拆二进制,构造 $S=\{1,2,4,\cdots\}$。
考虑 $x=m$ 咋做,可以在拆二进制的基础上改一下。我们找出 $2^{i+1}-1<x$ 的最小的 $i$,构造 $S=\{1,2,4,\cdots,2^i,x-2^i\}$。前半段覆盖了 $[1,2^{i+1}-1]$,加上 $x-2^i$ 就覆盖了 $[1,x-1]$。
记 $k=x-2^i$,如果 $k$ 是 $2$ 的幂就爆了,修一下:
- 若 $k=1$,考虑构造 $\{1,2,4,\cdots,2^i-2,k+2\}$。
- 若 $k\ge2$,考虑构造 $\{1,2,4,\cdots,2^i-1,k+1\}$。
现在我们可以覆盖 $[1,x-1]$ 且不覆盖 $x$。下一步就是造出 $[x+1,m]$。
从 $x+1$ 开始倍增,依次加入 $(x+1)\times2^i$。但是这个依然会爆,原因是 $2x+1,3x+2,\cdots$ 这种数造不出来。但是扔一个 $2x+1$ 进去就解决了。
检查一下 $S$,如果值域不符合要求,或者出现了相同数据就断言无解。$|S|$ 不会超过 $2\log n+2$,可以通过。
:::::
:::::info[代码]
```cpp line-numbers
int m, x;
vector<int> vec;
void work() {
int i = 0;
for (; (1 << (i + 1)) - 1 < x; i++)
vec.emplace_back(1 << i);
int k = x - (1 << i);
if (k == 0) return;
if (popcount(k) != 1) return vec.emplace_back(k), void();
if (k == 1 && i >= 4) vec.back() -= 2, vec.emplace_back(3);
else vec.back() -= 1, vec.emplace_back(k + 1);
}
void _main() {
cin >> x >> m;
vec.clear(), work();
if (2 * x + 1 <= m) vec.emplace_back(2 * x + 1);
for (int i = x + 1; i <= m; i *= 2)
vec.emplace_back(i);
sort(vec.begin(), vec.end());
if (vec[0] == 0) return cout << -1 << '\n', void();
for (int i = 1; i < (int)vec.size(); i++)
if (vec[i] == vec[i - 1]) return cout << -1 << '\n', void();
cout << vec.size() << '\n';
for (int i : vec) cout << i << ' ';
cout << '\n';
}
```
:::::
## [AGC006B](https://www.luogu.com.cn/problem/AT_agc006_b) & [D](https://www.luogu.com.cn/problem/AT_agc006_d) Median Pyramid
> 现有一个 $n$ 层金字塔,第 $i$ 层有 $2i-1$ 个格子,现在从最后一层开始,按照如下规则填写数字:每个格子上的数字是其左下、正下、右下三个格子上数字的中位数。例如:
>
> 
>
> 设第一行的数字为 $x$,最后一行的数字为 $p_1 \sim p_{2n-1}$。要求 $p_1 \sim p_{2n-1}$ 是 $1 \sim 2n-1$ 的排列。
>
> - [AGC006B](https://www.luogu.com.cn/problem/AT_agc006_b):给出 $x$,构造一组 $p_1 \sim p_{2n-1}$,或报告无解。
> - [AGC006D](https://www.luogu.com.cn/problem/AT_agc006_d):给出 $p_1 \sim p_{2n-1}$,求 $x$。
>
> $n \le 10^5$,2 秒,256 MB。
:::::success[题解]
考虑判定版本:套路地二分答案 $x$,将 $\ge x$ 的数记作 $1$,$<x$ 的数记作 $0$,只要判定塔顶是否是 $1$。
观察中位数的选取情形:
- `0 0 0` 中位数为 $0$。
- `0 0 1` 中位数为 $0$。
- `0 1 1` 中位数为 $1$。
- `1 1 1` 中位数为 $1$。
注意到一个事实,如果最底层有相邻的 `00` 或 `11`,则这对数可以传递上去,且离中心近的数对更有优势。
受上述启发得到构造方法:在中心处放置 `011`,这样 `11` 可以传递到塔顶。具体地,将中线构造为 $x-1,x,x+1$,其余位置按照顺序填入即可。
继续讨论判定方式。可以证明,我们只要从中心开始,找到最近的邻项相等数对,这就是塔顶的数字。由于 $2n-1$ 是奇数,所以不会存在两个到中心距离相等的数对。
构造版本 $O(n)$,判定版本 $O(n \log n)$。
:::::
:::::info[代码]
[AGC006B](https://www.luogu.com.cn/problem/AT_agc006_b):
```cpp line-numbers
const int N = 2e5 + 5;
int n, x, p[N];
void _main() {
cin >> n >> x;
if (x == 1 || x == 2 * n - 1) return cout << "No", void();
cout << "Yes\n";
p[n] = x, p[n - 1] = x - 1, p[n + 1] = x + 1;
int k = 1;
for (int i = 1; i < x - 1; i++) {
while (n - 1 <= k && k <= n + 1) k++;
p[k++] = i;
}
for (int i = x + 2; i < 2 * n; i++) {
while (n - 1 <= k && k <= n + 1) k++;
p[k++] = i;
}
for (int i = 1; i < 2 * n; i++) cout << p[i] << '\n';
}
```
[AGC006D](https://www.luogu.com.cn/problem/AT_agc006_d):
```cpp line-numbers
const int N = 2e5 + 5;
int n, a[N], b[N];
bool check(int x) {
for (int i = 1; i <= 2*n-1; i++) b[i] = (a[i] >= x);
for (int i = n, j = n; i >= 2 && j <= 2*n-2; i--, j++) {
if (b[i] == b[i-1]) return b[i];
if (b[j] == b[j+1]) return b[j];
}
return b[1];
}
void _main() {
cin >> n;
for (int i = 1; i <= 2*n-1; i++) cin >> a[i];
int l = 1, r = 2*n-1, res = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) res = mid, l = mid + 1;
else r = mid - 1;
} cout << res;
}
```
:::::
## [P3599 Koishi Loves Construction](https://www.luogu.com.cn/problem/P3599)
> 给出 $n$,要求解决如下两个问题:
>
> - 构造一个 $1\sim n$ 的排列,满足其 $n$ 个前缀和模 $n$ 互不相同;
> - 构造一个 $1\sim n$ 的排列,满足其 $n$ 个前缀积模 $n$ 互不相同。
>
> 输出构造或报告无解。
>
> 多测,$T\le10$,$1\le n\le10^5$,1 秒,125 MB。
:::::success[题解]
可以通过打表来观察结构。
特判 $n=1$,然后先考虑第一问,容易发现 $n$ 为奇数无解,否则可以构造 $n,1,n-2,3,n-4,5,\cdots$ 满足条件。
考虑第二问。使用 $O(n\times n!)$ 的暴力理论上可以得到 $n=2,3,4,5,7,11,13$ 有解。特判 $n=4$ 后猜想当且仅当 $n$ 为质数有解。
可以观察到 $n$ 必须在最后一位,因此从结果出发反推,可以发现前缀积序列为 $1,2,3,\cdots,n-1,0$。那么考虑构造 $1,2,\frac{3}{2},\frac{4}{3},\cdots,\frac{n}{n-1}$。由于 $n$ 是质数,$1\sim n-1$ 都有逆元。
还有一种做法是取原根,然后把第二问转化成第一问。
复杂度 $O(n\log n)$,线性逆元可以做到 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int op, n;
i64 mpow(i64 a, int b) {
i64 res = 1; for (; b; b >>= 1) {
if (b & 1) res = res * a % n;
a = a * a % n;
} return res;
}
void _main() {
cin >> n;
if (n == 1) return cout << "2 1\n", void();
if (op == 1) {
if (n & 1) return cout << 0 << '\n', void();
cout << 2 << ' ';
for (int i = 1, x = n, y = 1; i <= n; i++) {
if (i & 1) cout << x << ' ', x -= 2;
else cout << y << ' ', y += 2;
}
} else {
if (n == 4) return cout << "2 1 3 2 4\n", void();
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return cout << 0 << '\n', void();
cout << "2 1 ";
for (int i = 2; i < n; i++) cout << mpow(i - 1, n - 2) * i % n << ' ';
cout << n;
}
cout << '\n';
}
```
:::::
## [CodeChef Divisible Subset](https://vjudge.net/problem/CodeChef-DIVSUBS)
> 给出一个大小为 $n$ 的多重集 $S$,从中找出一个非空子集 $T$,使得 $\sum\limits_{x\in T}x\equiv0\pmod n$。
>
> 输出构造或报告无解。
>
> 多测,$\sum n\le10^5$,1 秒。
:::::success[题解]
我们断言,将 $S$ 任意排列为序列 $a_i$,并将子集退化为区间,必然有解。
先考虑怎么找构造。记 $a_i$ 的前缀和为 $s_i$,则只要找到 $s_{l-1}\equiv s_r\pmod n$ 的 $l,r$ 即可。顺序扫描并用哈希表维护即可,复杂度 $O(n)$。
考虑 $s_0\sim s_n$ 有 $n+1$ 个数字,而模 $n$ 意义下只有 $n$ 个不同的数,根据鸽巢原理,我们一定能找到一对相同的 $s_i$。这就证明了有解性。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n;
i64 a[N], s[N];
umap<i64, int> mp;
void _main() {
cin >> n; mp.clear();
for (int i = 1; i <= n; i++) cin >> a[i], s[i] = s[i - 1] + a[i];
mp[s[0]] = 0;
for (int r = 1; r <= n; r++) {
if (mp.find(s[r] % n) != mp.end()) {
int l = mp[s[r] % n] + 1;
cout << r - l + 1 << '\n';
for (int i = l; i <= r; i++) cout << i << ' ';
cout << '\n'; break;
}
mp[s[r] % n] = r;
}
}
```
:::::
## [CF618F Double Knapsack](https://www.luogu.com.cn/problem/CF618F)
> 给出大小为 $n$,值域为 $[1,n]$ 的多重集 $A,B$。找出非空子集 $S\subseteq A,T\subseteq B$,使得 $\sum\limits_{x\in S}x=\sum\limits_{x\in T}x$。输出构造或报告无解。
>
> $n\le10^6$,2.5 秒,250 MB。
:::::success[题解]
我们断言,将 $A,B$ 任意排列为序列,$S,T$ 取两个子段必然有解。
记 $s_i$ 为 $a_i$ 序列的前缀和,$t_i$ 为 $b$ 序列的前缀和。
不妨设 $s_n\le t_n$。对于每个 $i$,我们取出 $s_i\ge t_j$ 的最大的 $j$。根据定义,$s_i<t_{j+1}=t_j+b_{j+1}$。移项得 $s_i-t_j<b_{j+1}\le n$。
于是 $s_i-t_j\in[0,n)$。而 $i\in[0,n]$ 有 $n+1$ 个,$s_i-t_j$ 只有 $n$ 个,根据鸽巢原理,必有两个相同的 $s_i-t_j$。
不妨设 $s_{l_1}-t_{l_2}=s_{r_1}-t_{r_2}$ 且 $r_1>l_1,r_2>l_2$,移项得 $s_{r_1}-s_{l_1}=t_{r_2}-t_{l_2}$。此时 $(l_1,r_1]$ 和 $(l_2,r_2]$ 即为合法子段。
维护 $j$ 是简单的,注意到 $s_i,t_i$ 单调,双指针即可。复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 1e6 + 5;
int n, a[N], b[N];
vector<pair<int, int>> mp[N];
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], a[i] += a[i - 1];
for (int i = 1; i <= n; i++) cin >> b[i], b[i] += b[i - 1];
bool fl = false;
if (a[n] > b[n]) fl = true, swap(a, b);
for (int i = 0, j = 0; i <= n; i++) {
while (j < n && b[j + 1] <= a[i]) j++;
mp[a[i] - b[j]].emplace_back(i, j);
if (mp[a[i] - b[j]].size() == 1) continue;
auto [l1, l2] = mp[a[i] - b[j]][0];
auto [r1, r2] = mp[a[i] - b[j]][1];
if (l1 > r1) swap(l1, r1), swap(l2, r2);
if (fl) swap(l1, l2), swap(r1, r2);
cout << r1 - l1 << '\n';
for (int i = l1 + 1; i <= r1; i++) cout << i << ' ';
cout << '\n' << r2 - l2 << '\n';
for (int i = l2 + 1; i <= r2; i++) cout << i << ' ';
return;
}
}
```
:::::
## [P14511 [NFLSPC #8] 轨道交通](https://www.luogu.com.cn/problem/P14511)
> 给定二维平面上 $n$ 种颜色的点各 $n+1$ 个。要求在每种颜色中选出两个不同的点连一条线段,且所有 $n$ 条线段两两交点个数最少。输出构造方案。
>
> 如果两条线段共线,则交点数定义为 $+\infty$,且所有 $+\infty$ 认为相等。
>
> 多测,$\sum n\le2\times10^3$,$|x_i|,|y_i|\le10^9$,2 秒,128 MB。
:::::success[题解]
我们断言:存在一种方案,使得交点数为 $0$。下面给出构造式证明。
如果我们能在 $x$ 轴上找到 $n$ 个两两不交的区间,那么这 $n$ 条线段在二维平面上也不会相交。因此,将所有点按 $x_i$ 升序排序。
进行 $n$ 轮扫描,记录当前轮次中,每种颜色第一次出现的点的编号。当扫描到某点,其颜色已经出现过,则将两点连成一条线段,并立刻终止扫描。
终止循环后,将下一轮循环的起点设为本轮点的下一个点。这样保证了两条线段在 $x$ 轴上投影不交,则二维平面上必然不会相交。
下证:上述构造必然能找到合法解。
注意到,每轮扫描终止时,其他未匹配的颜色至多出现 $1$ 次。共有 $n$ 条线段,进行 $n$ 轮循环,则对于一种颜色被匹配前,至多会在 $n-1$ 轮中被删除,至多删去 $n-1$ 个点。
组成线段的两个端点,加上 $n-1$ 个点,上限恰为 $n-1+2=n+1$,因此备选点是充足的。
至此构造完毕,复杂度 $O(n^2\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1005;
int n;
using node = tuple<int, int, int, int>; // {x, y, col, id}
pair<int, int> ans[N];
int tag[N], pre[N];
void _main() {
cin >> n;
vector<node> a;
for (int i = 1; i <= n; i++) {
for (int j = 1, x, y; j <= n + 1; j++) {
cin >> x >> y;
a.emplace_back(x, y, i, j);
}
}
sort(a.begin(), a.end());
fill(tag + 1, tag + n + 1, 0);
for (int k = 1, cur = 0; k <= n; k++) {
fill(pre + 1, pre + n + 1, -1);
for (int i = cur; i < (int)a.size(); i++) {
auto [x, y, col, id] = a[i];
if (tag[col]) continue;
if (pre[col] != -1) {
ans[col] = make_pair(pre[col], id), tag[col] = true;
cur = i + 1; break;
} else {
pre[col] = id;
}
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << '\n';
}
```
:::::
## [P12543 [APIO2025] 转杆](https://www.luogu.com.cn/problem/P12543)
> 二维平面上有 $n$ 条直线,第 $i$ 条直线与 $x$ 轴正方向逆时针成 $v_i$ 的角度。定义这 $n$ 条直线的得分为
>
> $$
>\sum_{0\le i<j\le n-1}\operatorname{acute}(i,j)
>$$
>
> 其中,$\operatorname{acute}(i,j)$ 表示直线 $i,j$ 形成的非钝角度数。
>
> 一次操作选择若干直线,将这些直线旋转一个特定角度。操作后的得分不能低于原本的得分。最大化得分,并构造一组操作方案。
>
> $n\le10^5$,要求每次操作旋转的直线总数目 $\le2\times10^6$。3 秒,1024 MB。
:::::success[题解]
考虑 $n=2$ 的情形,显然两条直线垂直最优。
猜想最优解的形态为:直线两两匹配,匹配的直线之间相互垂直。
可以感性理解一下:先考虑调整法,直觉说明调整不优;再考虑两条垂直直线不会影响其他直线的贡献。因此这种形态看上去是比较对的。
不过实际上上述说明存在问题,参见 [discuss](https://www.luogu.com.cn/discuss/1087137)。然而我们注意到 APIO 可以通过提交验证猜想,写一个 $O(2^n)$ 即可。
再讨论如何最优化。结论:将直线按照所成角度升序排序,则将 $i$ 与 $i+\lfloor\frac{n}{2}\rfloor$ 配对最优,操作次数 $\lfloor\frac{n}{2}\rfloor$。
证明我不会,可以看题解区。总之这样复杂度是 $O(n\log n)$,交上去发现过了,那就有牌了。
:::::
:::::info[代码]
```cpp line-numbers
void energy(int n, vector<int> v){
vector<pair<int, int>> vec;
for (int i = 0; i < n; i++) vec.emplace_back(v[i], i);
sort(vec.begin(), vec.end());
for (int i = 0; i + n / 2 < n; i++) {
int x = vec[i].second, y = vec[i + n / 2].second;
rotate({x}, v[y] - v[x] + 75000);
}
}
```
:::::
## [P8347 「Wdoi-6」另一侧的月](https://www.luogu.com.cn/problem/P8347)
> 给出一棵 $n$ 个节点的无根树,A & B 在树上进行博弈。两人交替操作,一次操作选择一个节点,删去节点和与之相连的所有边,形成若干连通块,再选择一个连通块保留。若结束后只剩一个节点,则操作方失败。假定两人绝顶聪明,求游戏的获胜方。
>
> 多测,$T\le5$,$n\le10^5$,1 秒,250 MB。
:::::success[题解]
结论:先手必胜,当且仅当存在一个节点的度数为偶数。
考虑证明。记上述状态为 A,所有点度数全奇为 B。显然 $n=1$ 属于 B 状态,由数学归纳法只需证:
- B 的所有后继状态均为 A;
- A 的后继状态中必然存在一个 B 状态。
第一条性质:设删去的节点为 $u$,则容易说明 $u$ 的邻域度数全变为偶,选任意一个连通块都是 A 状态。
第二条性质:找到深度最大的偶度数点并保留其子树,则子树中一定全是奇度数点,转化为 B 状态。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, deg[N];
void _main() {
cin >> n;
fill(deg + 1, deg + n + 1, 0);
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
deg[u]++, deg[v]++;
}
for (int i = 1; i <= n; i++) if (deg[i] % 2 == 0)
return cout << "Hifuu\n", void();
cout << "Luna\n";
}
```
:::::
## [CF1667C Half Queen Cover](https://www.luogu.com.cn/problem/CF1667C)
> 现有一个 $ n\times n$ 的网格。你需要在其上防止若干半皇后,使得所有格子都被攻击。一个半皇后能攻击的范围是同行同列、同主对角线上的格子。如图所示:
>
> 
>
> 最小化半皇后的数目 $k$ 并输出构造。
>
> $n\le10^5$,1 秒,250 MB。
:::::success[题解]
先分析 $k$ 的理论下界。
考虑在左上角 $k\times k$ 的子矩形中放置半皇后。行列的限制是容易的,问题主要是对角线的约束。
对于右下角的 $(n-k)\times(n-k)$ 网格,其可以划分为 $2(n-k)-1$ 条对角线,且每个半皇后恰好覆盖一条。列出不等式
$$
k\ge2(n-k)-1
$$
解得 $k\ge\lfloor\frac{2n+1}{3}\rfloor$。接下来我们断言这个下界可以取到。
手玩 $n$ 为奇数且较小的情况,可以找到这样的构造:

也就是构造两条骑士形的路线。
当 $n$ 是偶数时,两个点可能会覆盖同一条对角线,不过精细分析一下,此时所有对角线仍能被覆盖,故依然按照这个做法构造即可。
:::::
:::::info[代码]
```cpp line-numbers
int n, k;
void _main() {
cin >> n; k = (2 * n + 1) / 3;
cout << k << '\n';
for (int i = 1, j = 1; i <= k; i++, j += 2) {
if (j > k) j = 2;
cout << j << ' ' << i << '\n';
}
}
```
:::::
## [P10612 [BalticOI 2001] Box of Mirrors](https://www.luogu.com.cn/problem/P10612)
> 现有一个 $n\times m$ 的盒子,盒子四周开有小孔,按逆时针顺序从 $1$ 到 $2(n+m)$ 标号。你需要在所有格子上放置若干斜 $45\degree$ 向上的镜子,使得从孔洞 $i$ 射入的光线经反射从孔洞 $a_i$ 射出。输出构造,数据保证有解。
>
> $n,m\le100$,1 秒,512 MB。
:::::success[题解]
首先,由于光路可逆,只需考虑左下方标号为 $1\sim n+m$ 的小孔。
通过手玩可以发现:在一个格子放置镜子,可以交换进入格子的两条光路的终点。考虑枚举格子 $(i,j)$,并决策这个格子是否需要放置镜子。
我们维护 $i$ 行上向右光线的终点 $r_i$ 和 $j$ 列上向上光线的终点 $u_j$。根据标号规则,如果不放镜子,向右光线的终点标号必然小于向上光线的终点标号。
注意到,对于格子 $(i,j)$,该处的向右光线和向上光线在离开格子后必然不会再次相交。因此,格子 $(i,j)$ 是纠正 $r_i$ 和 $u_j$ 大小关系的最后机会。
考虑从左下到右上枚举格子 $(i,j)$ 并决策。若 $r_i>u_j$ 就在 $(i,j)$ 放置镜子,并交换 $r_i,u_j$,否则不放镜子。此时 $r_i,u_j$ 已经是局部最终态,故上述调整可以得到全局最优。
复杂度 $O(nm)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 405;
int n, m, a[N], r[N], u[N], ans[N][N];
void _main() {
cin >> n >> m;
for (int i = 1; i <= 2 * (n + m); i++) cin >> a[i];
for (int i = 1; i <= n; i++) r[i] = a[i];
for (int j = 1; j <= m; j++) u[j] = a[j + n];
for (int i = n; i >= 1; i--)
for (int j = 1; j <= m; j++)
if (r[i] > u[j]) swap(r[i], u[j]), ans[i][j] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << ans[i][j] << ' ';
cout << '\n';
}
}
```
:::::
## [P7515 [省选联考 2021 A 卷] 矩阵游戏](https://www.luogu.com.cn/problem/P7515)
> 给出一个 $(n-1)\times(m-1)$ 的矩阵 $b_{i,j}$,你需要构造一个 $n\times m$ 的非负整数矩阵 $a_{i,j}$,满足 $0\le a_{i,j}\le10^6$,且 $b_{i,j}=a_{i,j}+a_{i,j+1}+a_{i+1,j}+a_{i+1,j+1}$。输出构造或报告无解。
>
> 多测,$T\le10$,$n,m\le300$,1 秒,512 MB。
:::::success[题解]
根据黑白染色的套路,我们将方程两边同乘 $(-1)^{i+j}$ 有
$$
(-1)^{i+j}b_{i,j}=(-1)^{i+j}a_{i,j}-(-1)^{i+j+1}a_{i,j+1}-(-1)^{i+j+1}a_{i+1,j}+(-1)^{i+j+2}a_{i+1,j+1}
$$
记 $c_{i,j}=(-1)^{i+j}a_{i,j}$,那么
$$
(-1)^{i+j}b_{i,j}=c_{i,j}+c_{i+1,j+1}-c_{i+1,j}-c_{i,j+1}
$$
于是将题目转化为构造矩阵 $c_{i,j}$。
不妨钦定 $c_{i,1}=c_{1,j}=0$,根据方程先递推出一组 $c_{i,j}$,然后调整。
我们考虑对第 $i$ 行加一个数 $x_i$,第 $j$ 行减一个数 $y_j$,上面的方程仍然成立。分类讨论 $x_i,y_j$ 的约束:
- 若 $i+j$ 为奇数,有 $-10^6\le b_{i,j}+x_i-y_j\le0$;
- 若 $i+j$ 为偶数,有 $0\le b_{i,j}+x_i-y_j\le10^6$。
将不等式移项后可以整理出 $x_i-y_j$ 的范围。我们将 $x,y$ 视为同一种未知数,可以用差分约束跑出一组 $x_i,y_j$,并且可以判掉无解。
使用 LLL+SLF 优化的 SPFA 可以通过。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 305, M = 1e6;
i64 n, m, a[N][N], b[N][N];
vector<pair<int, i64>> e[N * 2];
void add(int u, int v, i64 w) {e[u].emplace_back(v, w);}
const i64 inf = 1e18;
i64 dis[2 * N], cnt[2 * N], vis[2 * N];
bool spfa() {
fill(dis + 1, dis + n + m + 1, -inf);
fill(cnt, cnt + n + m + 1, 0), fill(vis, vis + n + m + 1, 0);
deque<int> q = {0}; cnt[0] = 1, vis[0] = true;
i64 num = 1, sum = 0;
while (!q.empty()) {
int u = q.front();
while (num * dis[u] < sum) q.pop_front(), q.emplace_back(u), u = q.front();
q.pop_front(), num--, sum -= dis[u], vis[u] = false;
if (++cnt[u] > n + m + 1) return false;
for (auto [v, w] : e[u])
if (dis[v] < dis[u] + w) {
dis[v] = dis[u] + w;
if (vis[v]) continue;
vis[v] = true, num++, sum += dis[v];
if (!q.empty() && dis[v] > dis[q.front()]) q.emplace_front(v);
else q.emplace_back(v);
}
} return true;
}
void _main() {
for (int i = 0; i <= n + m; i++) e[i].clear();
memset(a, 0, sizeof(a)), memset(b, 0, sizeof(b));
cin >> n >> m;
for (int i = 1; i < n; i++)
for (int j = 1; j < m; j++) {
cin >> b[i][j];
if ((i + j) & 1) b[i][j] = -b[i][j];
}
for (int i = 1; i < n; i++)
for (int j = 1; j < m; j++)
a[i + 1][j + 1] = b[i][j] - a[i][j] + a[i][j + 1] + a[i + 1][j];
for (int i = 1; i <= n + m; i++) add(0, i, 0);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if ((i + j) & 1) add(j + n, i, -M - a[i][j]), add(i, j + n, a[i][j]);
else add(j + n, i, -a[i][j]), add(i, j + n, a[i][j] - M);
}
if (!spfa()) return cout << "NO\n", void();
cout << "YES\n";
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int val = a[i][j] + dis[i] - dis[j + n];
if ((i + j) & 1) cout << -val << ' ';
else cout << val << ' ';
} cout << '\n';
}
}
```
:::::
## [P8156 「PMOI-5」奇怪的方程](https://www.luogu.com.cn/problem/P8156)
> 你需要构造一个 $n\times n$ 的矩阵 $a_{i,j}$。每行每列的和已经给定,并且给出 $m$ 个位置的值。要求 $a_{i,j}\in[-2^{63},2^{63})$ 且是整数。输出构造或报告无解。
>
> 多测,$\sum n^2\le4\times10^6$,$0\le m\le n^2$,1 秒,512 MB。
:::::success[题解]
先考虑给出的值如何处理。将对应行列和减去这个值,那么就相当于一部分格子不存在,我们要填数去满足和的约束。
考虑图论建模,对于每个存在的格子 $(x,y)$,连边 $x\to y$ 形成一张二分图。二分图的左右部点都带权,存下对应的行列和。那么问题就转化为赋一组边权,使得每个点的出边权值之和等于这个点的点权。
注意到二分图不一定连通,而每个连通块显然独立,可以单独处理。对于连通二分图的一种合法方案,左部点点权和必然等于右部点点权和,可以用带权并查集维护,判掉无解。
剩余情况我们发现限制非常松,于是断言有解。但是图上只要带环,在环权值和不变的情况下,就可以进行局部调整,也就有无穷组解,这不利于我们找构造。
考虑直接 DFS 出一棵生成树,剩余边权填 $0$,把问题转化到树上。此时未知数和限制的数目恰好相同,并且在树上解方程有很好的性质:
考虑每个叶子的出度都是 $1$,因此返祖边的边权就是叶子的点权;将其父亲的点权减去叶子点权后,删去这个叶子,其父亲就变成了新的叶子,归纳构造即可,于是总是有解。
复杂度可以做到 $O(n^2)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2005;
int n, m, fa[2 * N];
bool vis[N][N];
i64 a[2 * N], ans[N][N], sl[2 * N], sr[2 * N];
int find(int x) {return x == fa[x] ? x : fa[x] = find(fa[x]);}
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return false;
fa[x] = y, sl[y] += sl[x], sr[y] += sr[x];
return true;
}
vector<tuple<int, int, int>> e[N << 1];
void dfs(int u, int fa, int x, int y) {
for (auto [v, nx, ny] : e[u]) if (v != fa) dfs(v, u, nx, ny);
if (x != -1 && y != -1) ans[x][y] = a[u], a[fa] -= a[u], a[u] = 0;
}
void _main() {
cin >> n >> m;
iota(fa + 1, fa + 2 * n + 1, 1), fill(sl + 1, sl + 2 * n + 1, 0), fill(sr + 1, sr + 2 * n + 1, 0);
for (int i = 1; i <= 2 * n; i++) e[i].clear();
for (int i = 1; i <= n; i++) fill(ans[i] + 1, ans[i] + n + 1, 0), fill(vis[i] + 1, vis[i] + n + 1, 0);
for (int i = 1; i <= 2 * n; i++) cin >> a[i];
for (i64 i = 1, p, q; i <= m; i++) {
cin >> p >> q;
int x = (p - 1) / n + 1, y = (p - 1) % n + 1;
ans[x][y] = q, vis[x][y] = true, a[x] -= q, a[y + n] -= q;
}
copy(a + 1, a + n + 1, sl + 1), copy(a + n + 1, a + 2 * n + 1, sr + n + 1);
for (int x = 1; x <= n; x++)
for (int y = 1; y <= n; y++) {
if (vis[x][y]) continue;
if (!unite(x, y + n)) continue;
e[x].emplace_back(y + n, x, y), e[y + n].emplace_back(x, x, y);
}
for (int i = 1; i <= 2 * n; i++)
if (i == fa[i] && sl[i] != sr[i]) return cout << "No Solution\n", void();
for (int i = 1; i <= 2 * n; i++) if (i == fa[i]) dfs(i, 0, -1, -1);
cout << "OK\n";
for (int x = 1; x <= n; x++) for (int y = 1; y <= n; y++) cout << ans[x][y] << ' ';
cout << '\n';
}
```
:::::
## [QOJ18202 DFS Order 6](http://qoj.ac/problem/18202/)
> 给定 $n$ 个长为 $n$ 的排列 $a_i$。构造一张 $n$ 个点的简单无向图 $G$,使得 $\forall i\in[1,n]$,以点 $i$ 为根的 DFS 序恰为 $a_i$。
>
> 在本题中,DFS 算法按照邻居的编号升序进行访问,从而 DFS 序唯一。
>
> 输出构造或报告无解。
>
> 多测,$\sum n^2\le4\times10^4$,1 秒,2048 MB。
:::::success[题解]
正难则反,从加边转为删边。初始取 $K_n$ 为构造,考虑删去若干条边,直到 $G$ 合法。
重复如下操作直到 $G$ 的形态不变:对 $i=1,2,\cdots,n$ 分别进行 DFS。记当前位于节点 $u$,设其后继为 $v$。若 $a_i$ 的对应位是 $v$ 则继续 DFS,否则删去 $u\to v$ 的边。
下面说明,不合法的 $u\to v$ 边必须被删去。记 $a_i$ 的对应位节点为 $w$,分类讨论:
- 若 $v<w$,DFS 会被诱导走入更小的 $v$,无法对 $w$ 进行访问,必须删去。
- 若 $v>w$,DFS 希望访问 $v$,但目标序列表明应当访问 $w$。这意味着,在正确的 DFS 树中,$u$ 是一个回溯点,让 $u$ 的某个祖先去访问 $w$,从而 $u$ 决不能走入 $v$,必须删去。
调整结束后,若 $G$ 合法则输出构造,不合法则报告。
调整至多进行 $O(n)$ 轮,直接模拟的复杂度为 $O(n^4)$。使用这篇 [blog](https://www.luogu.com.cn/article/3wrdor73) 提及的技巧可以做到 $O\left(\dfrac{n^4}{w}\right)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 205;
int n, a[N][N];
bitset<N> e[N], vis;
void dfs(int u, int* dfn, int& dn, bool& ch) {
vis[u] = 1;
while (true) {
int v = (e[u] & ~vis)._Find_first();
if (v > n) break;
if (v == dfn[dn]) dfs(v, dfn, ++dn, ch);
else e[u][v] = e[v][u] = 0, ch = 1;
}
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) {
e[i].set();
for (int j = 1; j <= n; j++) cin >> a[i][j];
}
bool ch = true;
while (ch) {
ch = false;
for (int i = 1; i <= n; i++) {
vis.reset();
int dn = 2; dfs(i, a[i], dn, ch);
}
}
for (int i = 1; i <= n; i++) {
vis.reset();
int dn = 2; dfs(i, a[i], dn, ch);
if (dn <= n) return cout << "No\n", void();
}
cout << "Yes\n";
vector<pair<int, int>> vec;
for (int i = 1; i <= n; i++)
for (int j = 1; j < i; j++) if (e[i][j]) vec.emplace_back(i, j);
cout << vec.size() << '\n';
for (auto& i : vec) cout << i << '\n';
}
```
:::::
## [ZR3329 The Hermit](https://zhengruioi.com/problem/3329)
> 现有 $n$ 个任务 $(a_i,b_i)$ 排成一排。你初始持有正整数 $x$,一次操作可以选择如下两者之一:
>
> - 选择一个任务 $i$,令 $x\gets x-a_i$ 并获得 $1$ 的得分,然后删去这个任务;
> - 选择最左的未被删去的任务 $i$,令 $x\gets x+b_i$,然后删去这个任务。
>
> 操作二至多进行 $m$ 次。要求最终 $x\ge0$,最大化得分并输出。
>
> $1\le m\le n\le5\times10^5$,$0\le a_i,b_i\le10^9$,3 秒,256 MB。
:::::success[题解]
vp 时把我击杀了。
先考虑操作二不够 $m$ 次时如何处理。根据最左这一性质,最终所有任务都被删去。设进行操作一的任务集合为 $S$,则 $x=\sum\limits_{i\notin S}b_i-\sum\limits_{i\in S}a_i\ge0$。
反悔贪心,整体调整。初始时将 $n$ 个任务全部放入 $S$,然后从 $S$ 中删去若干任务 $i$,则 $x\gets x+a_i+b_i$。因此按 $a_i+b_i$ 将所有任务降序排序,然后枚举一段长度 $\le m$ 的前缀即可。
若上述算法无法得到答案,则最优解中,操作二恰好进行了 $m$ 次。考虑延续整体调整的思想,钦定一个集合 $T$ 为进行操作二的任务集合。
根据操作二的执行条件,最终 $1\sim\max T$ 中的所有任务一定被删去。因此考虑枚举 $k=\max T$,则 $k$ 形成了一个分界线:
- 对于 $[1,k]$ 中的所有任务:需要决策进行操作一还是操作二。
不妨令 $T=\{1,2,\cdots,k\}$ 然后整体调整。根据上面的讨论,我们将任务按 $a_i+b_i$ 升序排序,取前 $m$ 个作为操作一的任务,而剩余任务进行操作二。
- 对于 $[k+1,n]$ 中的任务:只需选择若干进行操作一。
通过上述讨论计算当前的 $x$,那么将任务按 $a_i$ 升序排序,取较小的 $a_i$ 直到超过 $x$ 停止。
直接模拟的复杂度为 $O(n^2\log n)$。考虑优化:
- 对于 $[1,k]$:用一个小根堆维护 $a_i+b_i$,堆的大小超过 $m-1$ 则弹出。额外维护堆中元素的和,以及前缀的额外代价即可;
- 对于 $[k+1,n]$:相当于在值域上查询第一个 $\ge x$ 的前缀和位置,BIT 上二分 / 权值线段树上二分 / 平衡树都可以维护。
正确实现的复杂度为 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 5e5 + 5;
int n, m, len, d[N], id[N];
int P(int x) {return lower_bound(d + 1, d + len + 1, x) - d;}
i64 a[N], b[N];
priority_queue<i64, vector<i64>, greater<i64>> q;
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
i64 sum[N << 2]; int cnt[N << 2];
void pushup(int rt) {sum[rt] = sum[ls] + sum[rs], cnt[rt] = cnt[ls] + cnt[rs];}
void update(int x, i64 v, int c, int l = 1, int r = len, int rt = 1) {
if (l == r) return sum[rt] += v, cnt[rt] += c, void();
int mid = (l + r) >> 1;
if (x <= mid) update(x, v, c, l, mid, ls);
else update(x, v, c, mid + 1, r, rs);
pushup(rt);
}
int ask(i64 x, int l = 1, int r = len, int rt = 1) {
if (sum[rt] <= x) return cnt[rt];
if (l == r) return d[l] == 0 ? 0 : x / d[l];
int mid = (l + r) >> 1;
if (sum[ls] <= x) return cnt[ls] + ask(x - sum[ls], mid + 1, r, rs);
return ask(x, l, mid, ls);
}
} T;
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i], d[i] = a[i];
iota(id + 1, id + n + 1, 1);
sort(id + 1, id + n + 1, [](int x, int y) -> bool {
return a[x] + b[x] > a[y] + b[y];
});
i64 cost = accumulate(a + 1, a + n + 1, 0LL), coin = 0;
if (coin >= cost) return cout << n, void();
for (int i = 1; i <= m; i++) {
cost -= a[id[i]], coin += b[id[i]];
if (coin >= cost) return cout << n - i, void();
}
sort(d + 1, d + n + 1), len = unique(d + 1, d + n + 1) - d - 1;
for (int i = 1; i <= n; i++) T.update(P(a[i]), a[i], 1);
i64 pre = 0, sum = 0, res = 0;
for (int k = 1; k <= n; k++) {
T.update(P(a[k]), -a[k], -1);
i64 c = b[k] + sum - pre;
if (c >= 0) chkmax(res, k - 1 - (i64)q.size() + T.ask(c));
q.emplace(a[k] + b[k]);
pre += a[k], sum += a[k] + b[k];
if ((int)q.size() >= m) sum -= q.top(), q.pop();
}
cout << res;
}
```
:::::
## [AGC016D XOR Replace](https://www.luogu.com.cn/problem/AT_agc016_d)
> 给定长为 $n$ 的序列 $a_i,b_i$。一次操作选择一个 $i$,令 $a_i\gets\bigoplus\limits_{k=1}^n a_k$。求将 $a$ 变为 $b$ 的最小操作次数,或报告无解。
>
> $n\le10^5$,2 秒,256 MB。
:::::success[题解]
令 $a_{n+1}=\bigoplus\limits_{k=1}^n a_k$,一次操作的实质是交换 $a_i$ 与 $a_{n+1}$。
对于位置 $i$,若 $a_i\ne b_i$,则必然存在某个时刻,当 $a_{n+1}=b_i$ 时交换 $a_i$ 与 $a_{n+1}$。在 $a_{n+1}$ 的视角上,它的值由 $b_i$ 突变为 $a_i$。
这启示我们建图 $b_i\to a_i$,则一组合法方案相当于从 $a_{n+1}$ 出发,将所有边都遍历一次,因此只要找一条欧拉路径。
同理令 $b_{n+1}=\bigoplus\limits_{k=1}^n b_k$,有解当且仅当 $a_1\sim a_{n+1}$ 与 $b_1\sim b_{n+1}$ 构成的多重集相等。
对于数值 $x$,其在图上的入度等于 $x$ 在 $a_1\sim a_n$ 中的出现次数,出度等于 $x$ 在 $b_1\sim b_n$ 的出现次数。不妨将 $b_{n+1}\to a_{n+1}$ 的虚边补上。若有解,则每个节点的入度都等于出度,此时必有欧拉回路存在。
我们顺次扫描 $i=1,2,\cdots,n$ 求出 $a_i\ne b_i$ 的 $i$ 的数目,作为图的边数 $|E|$。对值域离散化后连边 $b_i\to a_i$,忽略孤点求得连通块数目 $|C|$,如下计算答案:
- 若 $a_{n+1}$ 包含在 $|C|$ 中,我们需要走 $|E|$ 步并在 $|C|-1$ 个连通块之间跳跃。每次跳跃需要一次额外交换,操作次数 $|E|+|C|-1$。
- 若 $a_{n+1}$ 不包含在 $|C|$ 中,我们需要先做一次额外交换,操作次数 $|E|+|C|$。
复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, m, a[N], b[N], a0[N], b0[N], d[N], fa[N], sz[N];
int id(int x) {return lower_bound(d + 1, d + m + 1, x) - d;}
int find(int x) {return x == fa[x] ? x : fa[x] = find(fa[x]);}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (sz[x] > sz[y]) swap(x, y);
fa[x] = y, sz[y] += sz[x];
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], a[n + 1] ^= a[i];
for (int i = 1; i <= n; i++) cin >> b[i], b[n + 1] ^= b[i];
copy(a + 1, a + n + 2, a0 + 1), copy(b + 1, b + n + 2, b0 + 1);
sort(a0 + 1, a0 + n + 2), sort(b0 + 1, b0 + n + 2);
for (int i = 1; i <= n + 1; i++) if (a0[i] != b0[i]) return cout << -1, void();
for (int i = 1; i <= n + 1; i++) d[++m] = a[i], d[++m] = b[i];
sort(d + 1, d + m + 1), m = unique(d + 1, d + m + 1) - d - 1;
iota(fa + 1, fa + m + 1, 1), fill(sz + 1, sz + m + 1, 1);
int e = 0, c = 0, k = id(a[n + 1]);
for (int i = 1; i <= n; i++) {
if (a[i] == b[i]) continue;
unite(id(a[i]), id(b[i])), e++;
}
for (int i = 1; i <= m; i++) if (i == find(i) && sz[i] > 1) c++;
if (sz[find(k)] > 1) cout << e + c - 1;
else cout << e + c;
}
```
:::::
## [CF1120F Secret Letters](https://www.luogu.com.cn/problem/CF1120F)
> 现有 $n$ 个事件 $(t_i,p_i)$,表示时刻 $t_i$ 时事件主体为 $p_i$。保证 $p_i\in\{\tt{W},\tt{P}\}$。此时 $p_i$ 需要给另一方发送一封信,发送方法有两种:
>
> - 直接发送:代价为 $d$;
> - 暂时寄存:此操作每个时刻产生 $c$ 的代价,直到对方接收。对方可以在选择此操作时,或者时刻 $t_{n+1}$ 接受所有被此方寄存的信件。
>
> 保证 $t_i<t_{i+1}$。最小化发送所有信件的总代价并输出。
>
> $n\le10^5$,2 秒,500 MB。
:::::success[题解]
假设第 $k$ 封信选择寄存,且之后接收信件的角色构成索引序列 $a_1,a_2,\cdots,a_m$,其中 $a_1=k$。考虑信件 $a_i$ 一定被对方在 $t_{a_{i+1}}$ 取走,这 $m$ 封信的总代价即 $\sum\limits_{i=1}^m c\left(t_{a_{i+1}}-t_i\right)=c(t_{n+1}-t_k)$。
上述观察说明,只要我们钦定第一次寄存的信件 $k$,则后续取信链本身的代价为常数。于是我们可以任意调整取信链。
对于普通的信件,下一个对方为主体的节点应当尽可能接近。因此,每当主体改变时,这个点就应当加入取信链。换言之,取信链是所有颜色段的段首。
对于非链节点,其代价是独立的,可以直接计算两种操作的代价,取 $\min$ 即可。
我们倒序枚举 $k$,在枚举过程中即可计算右侧的颜色段等信息。复杂度可以做到 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 1e5 + 5;
int n, c, d, t[N];
char p[N];
void _main() {
cin >> n >> c >> d;
for (int i = 1; i <= n; i++) cin >> t[i] >> p[i];
cin >> t[n + 1];
int res = n * d, cur = t[n + 1], sum = 0;
for (int i = n; i >= 1; i--) {
if (p[i] == p[i + 1]) sum += min(d, c * (cur - t[i + 1]));
else cur = t[i + 1];
res = min(res, (t[n + 1] - t[i]) * c + (i - 1) * d + sum);
} cout << res;
}
```
:::::
## [P3479 [POI 2009] GAS-Fire Extinguishers](https://www.luogu.com.cn/problem/P3479)
> 给出一棵节点数为 $n$ 的有根叶向树,根节点为 $1$。你需要在某些节点放置任意数量的元素,每个元素可以被分配给距离 $ \le k$ 的节点,且最多分配给 $s$ 个不同节点。要求每个节点至少被分配到一个元素。最小化放置元素的总数目并输出。
>
> $n\le10^5$,$k\le20$,1 秒,125 MB。
::::::success[题解]
叶向树上的问题,考虑自底向上贪心。
我们声称,元素应当尽量放置在深度较小的节点上。对于节点 $x$,若其子树中仍存在距离 $=k$ 的点 $u$ 未分配,则必须在 $x$ 处放置元素并分配给 $u$。
可以用调整法说明上述策略的正确性。假设存在最优解,将 $x$ 替换为在其子树中的点 $v$,并将 $v$ 的元素分配给 $u$。记 $d(u,v)$ 为两点间距离,则 $d(u,v)<k$。
现在将 $v$ 上的元素移动到 $x$,我们要证明这仍是一个最优解,即说明被 $v$ 覆盖的元素可以被 $x$ 覆盖:
- 对 $u$ 点:根据定义 $d(x,u)=k$,必要性成立;
- 对 $x$ 子树外:假定 $v$ 处元素还覆盖了 $x$ 子树外的节点 $w$,则满足 $d(v,w)=d(v,x)+d(x,w)\le k$。移动到 $x$ 有 $d(x,w)\le k$,故移动不会影响 $x$ 外的节点;
- 对 $x$ 子树内:反证法,若存在 $y$ 使得其原本能被 $v$ 覆盖,但不能被 $x$ 覆盖,则其满足 $d(v,y)\le k\land d(x,y)>k$。根据定义,$d(x,u)=k$ 且 $u$ 是子树内最深的未分配节点,而这里 $y$ 比 $u$ 深,矛盾。所以不存在这样的 $y$。
说明这一做法的正确性后,考虑设计树形 DP 来执行策略。
记 $f_{i,x}$ 为在 $x$ 子树内,距离 $x$ 为 $i$ 的可分配数,$g_{i,x}$ 为子树内距离为 $i$ 的需求数目。DP 转移时,讨论在 $x$ 处新增元素,并且在 $x$ 处将余量 $f_{i,x}$ 与需要 $g_{j,x}$ 进行匹配。
一种错误的策略为:将满足 $i+j\le k$ 的所有余量—需求关系在当前 LCA 全部匹配。这种贪心会将极好的余量分配给容易满足的需求,从而导致较难满足的需求只能通过放置元素来解决。
事实上,我们只应该在如下两种情况时进行匹配:
1. 在 $i+j\in\{k-1,k\}$ 时将其匹配。因为如果再往祖先移动,就有 $i\gets i+1,j\gets j+1$,此时 $i+j>k$ 失去匹配机会;
2. 存在 $g_{k,x}>0$ 时,再向上走就无法处理这一需求,所以必须在 $x$ 处新建元素 $f_{0,x}$ 将其匹配。
正确性容易说明,考虑上述过程相当于贡献延后 DP,且所有余量—需求关系最终都会在根节点正确处理。
自底向上 DFS,对于当前节点 $x$ 有:
- 首先,将儿子的需求上传到 $x$,距离增加 $1$,并在 $x$ 处新增一个距离为 $0$ 的需求:
- $f_{i+1,x}=\sum\limits_{v\in\operatorname{son}(u)}f_{i,v}$;
- $g_{i+1,x}=\sum\limits_{v\in\operatorname{son}(u)}g_{i,v}$;
- $g_{0,x}=1$。
- 接下来处理第一类匹配。倒序枚举 $i=k,k-1,\cdots,0$,并考虑 $j\in\{k-i,k-i-1\}$。匹配的数目由 $\min(g_{i,u},f_{j,u})$ 决定。
- 在处理 $i=k$ 后,进行第二类匹配。计算出放置元素的数目 $a=\lceil\frac{g_{k,u}}{s}\rceil$,然后清空 $g_{k,u}\gets0$,并将剩余元素加入 $f_{0,u}$。
注意在根节点处,我们需要进行剩余匹配。首先将所有 $i+j\le k$ 的 $g_{i,u}$ 和 $f_{j,u}$ 匹配后,求出剩余需求数目 $a$,将 $\lceil\frac{a}{s}\rceil$ 加入答案。
按照上述过程实现,可以做到 $O(nk)$。
::::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, s, k;
vector<int> e[N];
i64 ans, f[21][N], g[21][N];
void dfs(int u, int fa) {
for (int v : e[u]) {
if (v == fa) continue;
dfs(v, u);
for (int i = 0; i < k; i++) f[i + 1][u] += f[i][v], g[i + 1][u] += g[i][v];
}
g[0][u] = 1;
for (int i = k; i >= 0; i--) {
for (int j : {k - i, k - i - 1}) {
if (j < 0) continue;
i64 a = min(g[i][u], f[j][u]);
g[i][u] -= a, f[j][u] -= a;
}
if (i == k && g[k][u] > 0) {
i64 a = (g[k][u] + s - 1) / s;
ans += a, f[0][u] += a * s - g[k][u], g[k][u] = 0;
}
}
}
void _main() {
cin >> n >> s >> k;
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
e[u].emplace_back(v), e[v].emplace_back(u);
}
dfs(1, -1);
for (int i = k; i >= 0; i--) {
for (int j = k - i; j >= 0; j--) {
i64 a = min(g[i][1], f[j][1]);
g[i][1] -= a, f[j][1] -= a;
}
}
i64 rem = 0;
for (int i = 0; i <= k; i++) rem += g[i][1];
cout << ans + (rem + s - 1) / s;
}
```
:::::
## [ARC135D Add to Square](https://www.luogu.com.cn/problem/AT_arc135_d)
> 给出一个 $n\times m$ 的矩阵 $a_{i,j}$。一次操作选择一个 $2\times2$ 的子矩阵和一个整数 $x$,令子矩阵中所有元素加上 $x$。你可以进行任意次操作,最小化 $\sum\limits_{i=1}^n\sum\limits_{j=1}^m|a_{i,j}|$,输出最小值并构造最终的 $a_{i,j}$。
>
> $n,m\le500$,2 秒,1024 MB。
:::::success[题解]
我们充分发扬人类智慧,将网格黑白染色,定义 $b_{i,j}=(-1)^{i+j}a_{i,j}$,则一次操作变为两个 $+x$ 和两个 $-x$。此时 $b_{i,j}$ 的行和 $r_i$ 与列和 $c_i$ 恒定。
记最终矩阵为 $b'_{i,j}$,则其合法当且仅当最终矩阵和原矩阵的行列和都相同。
可以发现答案具有一个下界 $\max\left(\sum|r_i|,\sum|c_j|\right)$。我们断言这个下界可以被取到,下面给出构造流程:
- 正数匹配:找出 $r_i>0\land c_j>0$ 的 $(i,j)$,令 $b_{i,j}\gets\min(r_i,c_j)$,并将 $r_i,c_j$ 减去这个值;
- 负数匹配:找到 $r_i<0\land c_j<0$ 的 $(i,j)$,令 $b_{i,j}\gets\max(r_i,c_j)$,并将 $r_i,c_j$ 减去这个值;
- 正负匹配:找到 $r_i>0\land r_j<0$ 的 $(i,j)$,令 $b_{i,1}$ 加上 $\min(r_i,-r_j)$,$b_{j,1}$ 减去这个值,并更新 $r_i,r_j$。对 $c$ 做同样的操作。
不妨设 $\sum|r_i|\ge\sum|c_j|$,则所有 $c_j$ 会在前两步中消去,代价即 $\sum|c_j|$。而第三步执行时正数和为 $\sum\limits_{r_i>0}r_i-\sum\limits_{c_j>0}c_j$,负数和为 $\sum\limits_{r_i<0}r_i-\sum\limits_{c_j<0}c_j$,可以相互抵消,且代价为二者相加。
总代价则为 $\sum|c_j|+\sum\limits_{r_i>0}r_i-\sum\limits_{c_j>0}c_j+\sum\limits_{r_i<0}r_i-\sum\limits_{c_j<0}c_j=\sum r_i$。因此上述构造可以达到下界。
视 $n,m$ 同阶,精细实现的复杂度可以做到 $O(n^2)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 505;
int n, m;
i64 r[N], c[N], b[N][N];
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1, x; j <= m; j++) {
cin >> x;
if ((i + j) & 1) r[i] -= x, c[j] -= x;
else r[i] += x, c[j] += x;
}
}
i64 rsum = 0, csum = 0;
for (int i = 1; i <= n; i++) rsum += abs(r[i]);
for (int i = 1; i <= m; i++) csum += abs(c[i]);
cout << max(rsum, csum) << '\n';
for (int i = 1, j = 1; i <= n && j <= m; ) {
while (i <= n && r[i] <= 0) i++;
while (j <= m && c[j] <= 0) j++;
if (i > n || j > m) break;
i64 x = min(r[i], c[j]);
b[i][j] += x, r[i] -= x, c[j] -= x;
}
for (int i = 1, j = 1; i <= n && j <= m; ) {
while (i <= n && r[i] >= 0) i++;
while (j <= m && c[j] >= 0) j++;
if (i > n || j > m) break;
i64 x = max(r[i], c[j]);
b[i][j] += x, r[i] -= x, c[j] -= x;
}
for (int i = 1, j = 1; i <= n && j <= n; ) {
while (i <= n && r[i] <= 0) i++;
while (j <= n && r[j] >= 0) j++;
if (i > n || j > n) break;
i64 x = min(r[i], -r[j]);
b[i][1] += x, b[j][1] -= x, r[i] -= x, r[j] += x;
}
for (int i = 1, j = 1; i <= m && j <= m; ) {
while (i <= m && c[i] <= 0) i++;
while (j <= m && c[j] >= 0) j++;
if (i > m || j > m) break;
i64 x = min(c[i], -c[j]);
b[1][i] += x, b[1][j] -= x, c[i] -= x, c[j] += x;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if ((i + j) & 1) cout << -b[i][j] << ' ';
else cout << b[i][j] << ' ';
}
cout << '\n';
}
}
```
:::::
## [P4785 [BalticOI 2016] 交换 (Day2)](https://www.luogu.com.cn/problem/P4785)
> 给出一个长为 $n$ 的排列 $a_i$。有 $n-1$ 轮操作,第 $k$ 次操作可以交换 $a_k$ 和 $a_{\lfloor k/2\rfloor}$。你需要最小化最终排列的字典序并输出。
>
> $n\le2\times10^5$,1 秒,250 MB。
:::::success[题解]
思维自然且很有启发性的好题,点赞!
题目中 $i\to\lfloor i/2\rfloor$ 的交换方式让我们联想到完全二叉树的堆式存储:将 $\lfloor i/2\rfloor$ 视为 $i$ 的父亲,$i$ 的左右儿子为 $2i,2i+1$。
对原排列建立完全二叉树,根节点为 $1$,则题目转化为最小化层序遍历字典序。
我们按前序遍历的顺序依次考虑每个节点 $i$,则其最终值有三种可能:$x=a_i,y=a_{2i},z=a_{2i+1}$。贪心地,我们先让 $i$ 处的值最小,字典序一定更优。
- 若 $x$ 是最小值,不做交换,左右子树分别递归求解;
- 若 $y$ 是最小值,交换 $x\to y$,然后左右子树递归求解;
- 若 $z$ 是最小值,交换 $x\to z$ 或者依次交换 $x\to y,y\to z$ 都可行。左右子树有 $x,y$ 和 $y,x$ 两种可能。
这里需要说明一下,直接将较小值作为左子树根是错误的,因为较小值可能在左子树中被替换。
我们将一个值沉入一棵子树,其必然经历若干次替换后停止在某个位置。这个位置可以通过模拟上述流程算出。
设 $f(u,x)$ 为值 $x$ 沉入 $u$ 子树后的最终位置。在节点 $i$ 处,假定 $z$ 是最小值,不妨设 $x<y
,则我们计算出 f(2i,x) 和 f(2i+1,x) ,然后将 x 沉入较小的一边即可。
对于 f(u,x) 的求解,可以模拟上述递归流程,其会在 z 成为最小值时产生 3 个分支,由递归式 T(n)=3T(n/2)+O(1) 解得复杂度 O(n^{\log_2 3})\approx O(n^{1.585}) 。加上递归求解,总复杂度为 O(n^{1.585}\log n) ,可以卡过。
我们注意到 x 一定来源于 u 的祖先节点,这只会有 O(\log n) 个,所以可以对 (u,x) 二元组记忆化。根据记搜实现方式,复杂度为 O(n\log^2 n)\sim O(n\log n) 。由于哈希表常数太大,使用 map 实现多一只 log 但跑的更快。
:::::info[代码]
const int N = 2e5 + 5;
int n, a[N], ans[N];
umap<int, int> mem[N];
int f(int u, int val) {
int ls = u << 1, rs = u << 1 | 1;
if (ls > n) return u;
if (rs > n) return val < a[ls] ? u : f(ls, val);
if (mem[u].find(val) != mem[u].end()) return mem[u][val];
int m = min({val, a[ls], a[rs]});
if (m == val) return mem[u][val] = u;
if (m == a[ls]) return mem[u][val] = f(ls, val);
if (val < a[ls]) return mem[u][val] = min(f(ls, val), f(rs, val));
return mem[u][val] = f(ls, a[ls]) < f(rs, a[ls]) ? f(rs, val) : f(ls, val);
}
void solve(int u, int val) {
int ls = u << 1, rs = u << 1 | 1;
if (ls > n) return ans[u] = val, void();
if (rs > n) {
int v = a[ls];
if (v < val) swap(v, val);
return ans[u] = val, solve(ls, v), void();
}
int m = min({val, a[ls], a[rs]});
if (m == val) {
ans[u] = val, solve(ls, a[ls]), solve(rs, a[rs]);
} else if (m == a[ls]) {
ans[u] = a[ls], solve(ls, val), solve(rs, a[rs]);
} else {
ans[u] = a[rs];
int x = val, y = a[ls];
if (x > y) swap(x, y);
if (f(ls, x) < f(rs, x)) solve(ls, x), solve(rs, y);
else solve(ls, y), solve(rs, x);
}
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
a[n + 1] = 1e9, solve(1, a[1]);
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
}
:::::
CF1519E Off by One
给定 n 个点 (x_i,y_i) ,每个点可以变成 (x_i+1,y_i) 或 (x_i,y_i+1) 。若 (0,0),(x_i,y_i),(x_j,y_j) 三点共线则可以匹配 i,j 并删去。求最大匹配,并输出一组方案。
:::::success[题解]
直观的想法是若 i,j 可以匹配就连边 i\leftrightarrow j ,求一般图最大匹配,显然不可做。
进行点边转化,将斜率视作顶点,点视作边。记 u_i=\frac{y_i}{x_i+1},v_i=\frac{y_i+1}{x_i} ,将输入的每个点都视作 u_i\leftrightarrow v_i 的无向边。那么这张图的线图就是上面那个做法建出来的图。
问题是 L(G) 的最大匹配,转化到 G 上得到如下问题:最多能匹配多少对共顶点的边,每条边只能使用一次。
对 G 的全体连通块考虑,下面设 G 连通。理论上界是 \left\lfloor|E|/2\right\rfloor ,我们断言上界可以取到,下面给出构造式证明:
拉出一棵 DFS 树,自底向上贪心。设计函数 dfs(u) 返回 u 子树内,未能匹配的那一条边,都匹配则返回无效值。遍历 u 的出边 e=(u,v) ,进行讨论:
若 v 未访问,调用 dfs(v) 得到 e' 。
若 e' 存在,则将 e 和 e' 配对。
若 e' 不存在,则保留 e 。
若 v 已访问,说明 u\to v 是返祖边,也保留 e 。
遍历结束后,将被保留的 e 两两任意配对。显然最终剩余至多 1 条边,作为 DFS 的返回值即可。
总复杂度 O(n\log n) 。
做法几乎一致的题目:QOJ5423 Perfect Matching。
:::::
:::::info[代码]
const int N = 2e5 + 5;
int n, m;
frac128 x[N], y[N], u[N], v[N], d[2*N];
vector<pair<int, int>> e[2*N];
int id(const frac128& f) {return lower_bound(d + 1, d + m + 1, f) - d;}
bool vis[2*N], used[N];
vector<pair<int, int>> vec;
int dfs(int u) {
vis[u] = true;
vector<int> cur;
for (auto [v, e] : e[u]) {
if (used[e]) continue;
used[e] = true;
if (!vis[v]) {
int e2 = dfs(v);
if (e2 != -1) vec.emplace_back(e, e2);
else cur.emplace_back(e);
} else {
cur.emplace_back(e);
}
}
while (cur.size() >= 2) {
int x = cur.back(); cur.pop_back();
int y = cur.back(); cur.pop_back();
vec.emplace_back(x, y);
}
return cur.empty() ? -1 : cur[0];
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
u[i] = y[i] / (x[i]+1), v[i] = (y[i]+1) / x[i];
d[i] = u[i], d[i+n] = v[i];
}
sort(d + 1, d + 2*n + 1), m = unique(d + 1, d + 2*n + 1) - d - 1;
for (int i = 1; i <= n; i++) {
int x = id(u[i]), y = id(v[i]);
e[x].emplace_back(y, i), e[y].emplace_back(x, i);
}
for (int i = 1; i <= m; i++) if (!vis[i]) dfs(i);
cout << vec.size() << '\n';
for (auto& i : vec) cout << i << '\n';
}
:::::
AT_utpc2020_j Merge and Decrement
给出两个多重集 A,B ,大小分别为 n,m 。你可以任意顺序对 A 执行任意次以下操作:
选择 x\in A ,删除 x 并加入 x-1 。
选择 x,y\in A\land|x-y|\le1 ,删除 x,y 并加入 x+y 。
判断能否让 A 变成 B 。
多测,\sum n,\sum m\le2\times10^5 ,2 秒,1024 MB。
:::::success[题解]
正难则反,考虑从 B 还原回 A 的过程。
考虑二操作的逆操作,即将 b_i 分裂为两数 x,y 。由于 |x-y|\le1 ,分裂方式是唯一的 x=\lfloor\frac{b_i}{2}\rfloor,y=\lceil\frac{b_i}{2}\rceil 。
我们需要对 B 进行恰好 n-m 次分裂操作,得到新的 B 后,将两数组对应匹配,若 \forall i,a_i\ge b_i 则合法。容易说明将 A,B 降序排序即为最优。
记 a=\max A,b=\max B ,考虑如下贪心策略:
若 a<b :此时 a 无法匹配 b ,必须将 b 分裂。
若 a\ge b :
若 |A|=|B| :直接匹配 a,b 。
若 |A|>|B| 且 |B|=1 :如果将 a,b 匹配,A 中剩余元素无法处理,所以只能将 b 分裂。
若 |A|>|B| 且 |B|>1 :此时仍然应当匹配 a,b 。因为我们必然会执行若干次分裂操作,如果将这些分裂机会留给 B 中剩余元素,就更容易使得 a_i\ge b_i 。
用大根堆维护 A,B 并执行上述过程,若 |A|<|B| 则判定无解。复杂度 O(n\log n) 。
:::::
:::::info[代码]
int n, m;
priority_queue<int> a, b;
void _main() {
cin >> n >> m;
while (!a.empty()) a.pop();
while (!b.empty()) b.pop();
for (int i = 1, x; i <= n; i++) cin >> x, a.emplace(x);
for (int i = 1, x; i <= m; i++) cin >> x, b.emplace(x);
while (!a.empty()) {
if (b.size() > a.size()) return cout << "No\n", void();
int x = a.top(); a.pop();
int y = b.top(); b.pop();
if (x < y || (!a.empty() && b.empty()))
a.emplace(x), b.emplace(y / 2), b.emplace((y + 1) / 2);
}
cout << "Yes\n";
}
:::::
ARC147E Examination
给出长为 n 的序列 a_i,b_i 。你可以任意重排 a_i ,目标为 \forall1\le i\le n,a_i\ge b_i 。求最少重排多少个位置,或报告无解。
:::::success[题解]
钦定一个集合 S 表示可以重排的位置,我们需要最小化 |S| 。如下建立二分图 G :若 u,v\in S 且 a_u\ge b_v ,则将左部点 u 和右部点 v 连边。则合法的充要条件为:
其中第一条限制由 Hall 定理得出。接下来考察 |N(T)|-|T| 取得 \min 的所有 T 。
当 T 已经确定时,记 u=\max T ,则 N(T)=\{v\mid a_u\ge b_v\} 。因此对于 T\subseteq T' 的 T' ,若 \max T'=u ,则 T' 必然不劣。因此 T 的形态就是将 a_i 升序排序后的一段前缀。
根据上述讨论,可以转化合法条件为
\forall k\ge1,\sum_{i\in S}[a_i\ge k]\ge\sum_{i\in S}[b_i\ge k]
令 x_k=\sum\limits_{i=1}^n[a_i\ge k],y_k=\sum\limits_{i=1}^n[b_i\ge k] 。可以离散化后做两次后缀和求出。若初始 \exists k\ge1,x_k<y_k 则无解。
使用整体调整的思想,先将所有 i 加入 S 中再逐步删去。讨论删去 (a_i,b_i) 对式子的影响:
对于 a_i\ge k ,\sum\limits_{i\in S}[a_i\ge k] 减少 1 ;
对于 b_i\ge k ,\sum\limits_{i\in S}[b_i\ge k] 减少 1 ;
对于 b_i<k\le a_i ,\sum\limits_{i\in S}[a_i\ge k]-\sum\limits_{i\in S}[b_i\ge k] 减少 1 。
因此题目就转化成:在数轴上有若干区间,你需要选出若干个区间,且每段区间有一个容量上限,最大化选点的数目。
将所有区间按右端点升序排序后能选即选,容易说明正确性。线段树维护这个过程即可,复杂度 O(n\log n) 。
:::::info[代码]
const int N = 6e5 + 5;
int n, m, a[N], b[N], x[N], y[N], d[N];
int idx(int x) {return lower_bound(d + 1, d + m + 1, x) - d;}
struct node {int l, r;};
vector<node> vec;
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
int val[N << 2], tag[N << 2];
void pushup(int rt) {val[rt] = min(val[ls], val[rs]);}
void apply(int rt, int c) {val[rt] += c, tag[rt] += c;}
void pushdown(int rt) {
if (!tag[rt]) return;
apply(ls, tag[rt]), apply(rs, tag[rt]), tag[rt] = 0;
}
void update(int tl, int tr, int c, int l = 1, int r = m, int rt = 1) {
if (tl <= l && r <= tr) return apply(rt, c), void();
int mid = (l + r) >> 1; pushdown(rt);
if (tl <= mid) update(tl, tr, c, l, mid, ls);
if (tr > mid) update(tl, tr, c, mid + 1, r, rs);
pushup(rt);
}
int ask(int tl, int tr, int l = 1, int r = m, int rt = 1) {
if (tl <= l && r <= tr) return val[rt];
int mid = (l + r) >> 1, res = 1e9; pushdown(rt);
if (tl <= mid) chkmin(res, ask(tl, tr, l, mid, ls));
if (tr > mid) chkmin(res, ask(tl, tr, mid + 1, r, rs));
return res;
}
} T;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
d[i] = a[i], d[i + n] = b[i];
}
sort(d + 1, d + 2 * n + 1);
m = unique(d + 1, d + 2 * n + 1) - d - 1;
for (int i = 1; i <= n; i++) x[idx(a[i])]++, y[idx(b[i])]++;
for (int i = m; i >= 1; i--) x[i] += x[i + 1], y[i] += y[i + 1];
for (int i = 1; i <= m; i++) {
if (x[i] < y[i]) return cout << -1, void();
T.update(i, i, x[i] - y[i]);
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (a[i] < b[i]) continue;
int l = idx(b[i]) + 1, r = idx(a[i]);
if (l <= r) vec.emplace_back(node{l, r});
else res++;
}
sort(vec.begin(), vec.end(), [](const node& x, const node& y) -> bool {
if (x.r != y.r) return x.r < y.r;
return x.l < y.l;
});
for (auto [l, r] : vec)
if (T.ask(l, r) >= 1) res++, T.update(l, r, -1);
cout << res;
}
:::::
[模拟赛] 排列变环
给出长为 n 的数组 a_i 和一个整数 k 。考虑排列 p_i ,构造有向图 i\to p_i ,则有向图上必然形成若干环(包含自环)。称排列 p_i 是好的,当且仅当存在一个环 i_1\to i_2\to\cdots\to i_m\to i_1 ,使得 \sum\limits_{j=1}^m a_{i_j}\ge k 。
求所有好的排列中,逆序对数最少的排列,并输出最小的逆序对数。
:::::success[题解]
不难发现 k\le0 时最优解一定为若干自环,此时有解当且仅当 \max\limits_{i=1}^n a_i\ge k 。下文讨论认为 k>0 。
考虑 a_i\ge0 时的做法。
结论:使得一个长为 n 的排列整体形成一个环,则最小逆序对数为 n-1 。
::::success[证明]{open}
充分性:考虑构造 p=[2,3,\cdots,n,1] ,显然成环 1\to2\to\cdots\to n\to1 ,且逆序对数为 n-1 。
必要性:考虑交换两个相邻元素后,环数必然 +1 或 -1 。则从初始状态 n 个自环交换为目标状态 1 个大环,最少的交换次数恰为 n-1 。而相邻交换排序的次数就是逆序对数,即逆序对数不小于 n-1 。
因此,我们只要找到最短的 [l,r] 满足 \sum\limits_{i=l}^r a_i\ge k ,答案即为 r-l 。
对于 a_i<0 的元素,考虑将其删去,即选择了非负整数的下标 i_1,i_2,\cdots,i_m ,就构造环 i_1\to i_2\to\cdots\to i_m\to i_1 。此时每个负数被跨过一次,对逆序对数的贡献恒为 1 。
因此对于区间 [l,r] ,可以不断删去最小的负数直到区间和 \ge k ,用 r-l 加上删去的数的数目更新答案。
直接模拟可以做到 O(n^3\log n) 。考虑用权值线段树维护,枚举 l ,在 r 向右移动的过程中维护线段树,将每个负数插入线段树,查询则线段树上二分。
如果不离散化,暴力清空复杂度会出问题,给每个节点打一个版本号即可。这样复杂度为 O(n^2\log V) 。
:::::info[代码]
const int N = 1005, M = 1e6 + 5, inf = 1e9;
int n, k, a[N], pre[N];
#define ls (rt << 1)
#define rs (rt << 1 | 1)
int now, ver[M << 2], cnt[M << 2], sum[M << 2];
void maintain(int rt) {
if (ver[rt] != now) ver[rt] = now, cnt[rt] = 0, sum[rt] = 0;
}
void pushup(int rt) {
maintain(ls), maintain(rs);
cnt[rt] = cnt[ls] + cnt[rs], sum[rt] = sum[ls] + sum[rs];
}
void add(int x, int l = -1e6, int r = 0, int rt = 1) {
maintain(rt);
if (l == r) return cnt[rt]++, sum[rt] += x, void();
int mid = (l + r) >> 1;
if (x <= mid) add(x, l, mid, ls);
else add(x, mid + 1, r, rs);
pushup(rt);
}
int ask(int x, int l = -1e6, int r = 0, int rt = 1) {
if (l == r) return (x + l + 1) / l;
maintain(ls), maintain(rs);
int mid = (l + r) >> 1;
if (sum[ls] <= x) return ask(x, l, mid, ls);
if (sum[ls] + sum[rs] <= x) return ask(x - sum[ls], mid + 1, r, rs) + cnt[ls];
return inf;
}
void _main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], pre[i] = pre[i - 1] + a[i];
if (k <= 0) {
if (*max_element(a + 1, a + n + 1) >= k) cout << 0;
else cout << -1;
return;
}
int res = inf;
for (int l = 1; l <= n; l++) {
now++;
for (int r = l; r <= n; r++) {
if (a[r] < 0) add(a[r]);
int sum = pre[r] - pre[l - 1];
if (sum >= k) {
chkmin(res, r - l);
} else {
int x = ask(sum - k);
maintain(1);
if (x <= cnt[1]) chkmin(res, r - l + x);
}
}
}
cout << (res >= inf ? -1 : res);
}
:::::
CF280D k-Maximum Subsequence Sum
维护一个长为 n 的序列 a_i ,q 次操作,要求支持单点修改,区间查询选出至多 k 个不交子段的最大总和。
:::::success[题解]
用线段树来维护最大子段和是简单的。
引入反悔贪心的思想,每次先求出最大子段和,然后将最大子段和的区间乘上 -1 ,再求最大子段和时如果两段有交,相当于反悔掉了交集。跑 k 轮即可。
不过上面的说法只能作为一种理解方式,正确性是不严谨的。因此我们用模拟费用流的观点来证明一下:
这样,选取区间 [l,r] 可以被刻画为流 S\to l\to r+1\to T ,问题变为流量上界为 k 的最大费用流。
考虑一轮增广中,我们取出增广路 S\to l\to r+1\to R ,并建立容量为 -1 的一段反向弧,这等价于找出最大子段和并且取反。需要进行至多 k 轮增广得到答案,这就说明了反悔贪心策略的正确性。
考虑用数据结构维护上述过程。构造半群信息,维护:
前缀和最大值,后缀和最大值;
最大子段和,区间和;
前后缀 & 整体最大子段和的对应区间。
可以用线段树维护。每个节点再打一个 -1 的标记,并同时存正反串,非常好写。
:::::info[代码]
const int N = 1e5 + 86;
int n, q, a[N], opt, l, r, k;
struct node {
int sum, // 区间和
lmax, rmax, amax, // 左/右/区间最大子段和
lx, rx, // 最大子段和的端点
lrx, rlx; // 前/后最大子段和的端点
node(int x = 0, int v = 0)
: sum(v), lmax(v), rmax(v), amax(v), lx(x), rx(x), lrx(x), rlx(x) {}
};
node operator+ (const node& l, const node& r) {
node a; a.sum = l.sum + r.sum;
a.lmax = max(l.lmax, l.sum + r.lmax);
if (a.lmax == l.lmax) a.lrx = l.lrx;
if (a.lmax == l.sum + r.lmax) a.lrx = r.lrx;
a.rmax = max(r.rmax, r.sum + l.rmax);
if (a.rmax == r.rmax) a.rlx = r.rlx;
if (a.rmax == r.sum + l.rmax) a.rlx = l.rlx;
a.amax = max({l.amax, r.amax, l.rmax + r.lmax});
if (a.amax == l.amax) a.lx = l.lx, a.rx = l.rx;
if (a.amax == r.amax) a.lx = r.lx, a.rx = r.rx;
if (a.amax == l.rmax + r.lmax) a.lx = l.rlx, a.rx = r.lrx;
return a;
}
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
node val[N << 2], rval[N << 2];
bool rev[N << 2];
void pushup(int rt) {val[rt] = val[ls] + val[rs], rval[rt] = rval[ls] + rval[rs];}
void pushdown(int rt) {
if (!rev[rt]) return;
swap(val[ls], rval[ls]), swap(val[rs], rval[rs]), rev[ls] ^= 1, rev[rs] ^= 1, rev[rt] ^= 1;
}
void build(int l = 1, int r = n, int rt = 1) {
if (l == r) return val[rt] = node{l, a[l]}, rval[rt] = node{l, -a[l]}, void();
int mid = (l + r) >> 1;
build(l, mid, ls), build(mid + 1, r, rs), pushup(rt);
}
void change(int x, int c, int l = 1, int r = n, int rt = 1) {
if (l == r) return val[rt] = node{l, c}, rval[rt] = node{l, -c}, void();
int mid = (l + r) >> 1;
pushdown(rt);
if (x <= mid) change(x, c, l, mid, ls);
else change(x, c, mid + 1, r, rs);
pushup(rt);
}
void flip(int tl, int tr, int l = 1, int r = n, int rt = 1) {
if (tl <= l && r <= tr) return swap(val[rt], rval[rt]), rev[rt] ^= 1, void();
int mid = (l + r) >> 1;
pushdown(rt);
if (tl <= mid) flip(tl, tr, l, mid, ls);
if (tr > mid) flip(tl, tr, mid + 1, r, rs);
pushup(rt);
}
node query(int tl, int tr, int l = 1, int r = n, int rt = 1) {
if (tl <= l && r <= tr) return val[rt];
int mid = (l + r) >> 1;
pushdown(rt);
if (tl <= mid && mid < tr) return query(tl, tr, l, mid, ls) + query(tl, tr, mid + 1, r, rs);
return tl <= mid ? query(tl, tr, l, mid, ls) : query(tl, tr, mid + 1, r, rs);
}
} sgt;
void _main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
sgt.build();
while (q--) {
cin >> opt >> l >> r;
if (opt == 1) {
sgt.change(l, r);
} else {
cin >> k;
int res = 0, cur = 0;
stack<pair<int, int>> st;
while (k--) {
node x = sgt.query(l, r);
cur += x.amax, res = max(res, cur);
sgt.flip(x.lx, x.rx), st.emplace(x.lx, x.rx);
}
while (!st.empty()) {
auto [l, r] = st.top(); st.pop();
sgt.flip(l, r);
}
cout << res << '\n';
}
}
}
:::::
P10439 [JOIST 2024] 逃生路线 2 / Escape Route 2
现有 n 个机场,机场 i 有 m_i 条航班 (l_j,r_j) ,第 j 条航班在 l_j 时刻离开 i ,并在 r_j 时刻到达 i+1 ,保证 l_j<r_j 。到达某个机场后,可以原地等待下一个航班。一天中有 t 个时刻,允许在机场过夜。
给出 q 次询问,每次询问给定 u,v ,你需要最小化机场 u 到机场 v 的总用时并输出。可以在任意时刻从 u 出发并在任意时刻到达 v 。
:::::success[题解]
先进行初步观察。考虑如下情形:
我们发现,图中黄色线段表示的航班一定是无用的。换句话说,如果在同一个机场 i 存在两趟航班 x 和 y ,满足 [l_x,r_x]\subseteq[l_y,r_y] ,那么 y 一定可以被抛弃。
因此,我们可以先将区间以 l 为第一关键字升序排序,r 为第二关键字降序排序,然后跑一次单调栈删去所有无效航班。
删去无效航班后,我们继续进行观察:在可选的 i\to i+1 航班中,选择到达时间最靠前的航班一定不劣。结合上图中的黄线和绿线,由于处理后的航班区间不再相互包含,且到达时间单调递增,这就保证了贪心策略的正确性。
此时,如果我们确定了起点选择的第一趟航班,后续的航程就是唯一确定的。如果直接暴力向后跳,复杂度为 O(qnm) 。
出现多次向后跳跃的情形,这启发我们使用倍增优化。我们可以利用双指针预处理出每趟航班向后跳的第一步,进而递推出跳 2^i 步到达的节点和总耗时。查询时进行二进制拆分,优化到 O(q m\log n) 。
进一步,注意到上述过程可逆,于是给出如下策略:判断 m_u 和 m_{v-1} 的大小关系。如果 m_u 较小,就枚举从 u 出发的所有航班向右倍增;否则,就枚举从 v-1 出发的所有航班向左倍增。
并且对于每次询问的 u,v ,我们将其记忆化。可以证明这样优化以后的复杂度是 O(m\sqrt{q}\log n) ,可以通过。
下面证明这个复杂度。注意到每次询问的计算量为 \min(m_u,m_{v-1}) ,此时我们引入一个虚拟阈值 B 。
当 \min(m_u,m_{v-1})\le B 时,复杂度为 O(B) 。
当 \min(m_u,m_{v-1})>B 时,这样的组合最多有 O\left(\dfrac{m^2}{B}\right) 种。记忆化以后,每种组合最多计算一次,于是复杂度为 O\left(\dfrac{m^2}{B}\right) 。
总复杂度 O\left(qB+\dfrac{m^2}{B}\right) 。
注意上述推导省略了倍增的 \log n 。
我们的算法是自适应的,所以上述算法可以取到最优的 B=\dfrac{m}{\sqrt{q}} ,此时的复杂度即 O(m\sqrt{q}) 。
:::::info[代码]
const int N = 3e5 + 5;
int n, t, m, q;
using node = tuple<int, int, int>; // {l, r, id}
vector<node> a[N];
node b[N];
int pre[19][N], nxt[19][N];
i64 pco[19][N], nco[19][N];
umap<u64, i64> mem;
void prework() {
for (int i = 1; i < n - 1; i++) {
int p = 0, lim = a[i + 1].size();
for (auto [l, r, id] : a[i]) {
while (p < lim && r > get<0>(a[i + 1][p])) p++;
if (p < lim) {
auto [nl, nr, nid] = a[i + 1][p];
nxt[0][id] = nid, nco[0][id] = nl - l;
} else {
auto [nl, nr, nid] = a[i + 1][0];
nxt[0][id] = nid, nco[0][id] = nl - l + t;
}
}
}
for (int i = n - 1; i >= 2; i--) {
int p = a[i - 1].size() - 1;
for (int j = a[i].size() - 1; j >= 0; j--) {
auto [l, r, id] = a[i][j];
while (p >= 0 && get<1>(a[i - 1][p]) > l) p--;
if (p >= 0) {
auto [nl, nr, nid] = a[i - 1][p];
pre[0][id] = nid, pco[0][id] = l - nl;
} else {
auto [nl, nr, nid] = a[i - 1].back();
pre[0][id] = nid, pco[0][id] = l - nl + t;
}
}
}
for (int i = 1; (1 << i) <= m; i++) {
for (int j = 1; j <= m; j++) {
pre[i][j] = pre[i - 1][pre[i - 1][j]];
nxt[i][j] = nxt[i - 1][nxt[i - 1][j]];
pco[i][j] = pco[i - 1][j] + pco[i - 1][pre[i - 1][j]];
nco[i][j] = nco[i - 1][j] + nco[i - 1][nxt[i - 1][j]];
}
}
}
i64 nask(int u, int k) {
i64 res = 0;
for (int i = lg(m); i >= 0; i--) {
if (k >> i & 1) res += nco[i][u], u = nxt[i][u];
}
auto [l, r, _] = b[u];
return res + r - l;
}
i64 pask(int u, int k) {
auto [l, r, _] = b[u];
i64 res = r - l;
for (int i = lg(m); i >= 0; i--) {
if (k >> i & 1) res += pco[i][u], u = pre[i][u];
}
return res;
}
void _main() {
cin >> n >> t;
for (int i = 1, x; i < n; i++) {
cin >> x;
vector<node> vec;
for (int l, r; x--; ) {
cin >> l >> r;
vec.emplace_back(l, r, -1);
}
sort(vec.begin(), vec.end(), [](const node& a, const node& b) -> bool {
auto [l1, r1, i1] = a; auto [l2, r2, i2] = b;
return l1 != l2 ? l1 < l2 : r1 > r2;
});
vector<node> st;
for (auto [l, r, _] : vec) {
while (!st.empty() && get<1>(st.back()) >= r) st.pop_back();
st.emplace_back(l, r, -1);
}
for (auto [l, r, _] : st) a[i].emplace_back(l, r, ++m), b[m] = a[i].back();
}
prework(), cin >> q;
for (int i = 1, u, v; i <= q; i++) {
cin >> u >> v;
u64 h = u * 1000007ULL + v;
if (mem.find(h) != mem.end()) {
cout << mem[h] << '\n';
continue;
}
i64 res = 2e18;
if (a[u].size() <= a[v - 1].size())
for (auto [l, r, id] : a[u]) res = min(res, nask(id, v - u - 1));
else
for (auto [l, r, id] : a[v - 1]) res = min(res, pask(id, v - u - 1));
cout << (mem[h] = res) << '\n';
}
}
:::::
P9019 [USACO23JAN] Tractor Paths P
给出 n 个区间 [l_i,r_i] ,保证 l_i,r_i 递增,且所有 l_i,r_i 构成 1\sim2n 的排列。若 [l_i,r_i]\cap[l_j,r_j]\ne\varnothing ,则在 i,j 之间连一条无向边,保证 (1,n) 有边。再给定一个点集 S 。
给出 q 次询问,每次询问给定 s,t ,保证 s<t ,分别回答以下问题:
考虑所有从 s 到 t 的最短路,有多少个 u\in S 在至少一条最短路上。
:::::success[题解]
由于 l_i,r_i 递增,[l_i,r_i]\cap[l_j,r_j]\ne\varnothing 当且仅当 l_j<r_i ,并且 i 可达的 j 是一段区间。贪心地,跳到最右端总是不劣,于是可以预处理 i 可达的最右节点 f_i ,不断令 i\gets f_i 。倍增优化即可求出第一问答案 d 。
进一步,我们预处理 i 可达的最左节点 g_i 。记 f^k(i) 为 i 跳 k 步后到达的点,g^k 同理。假设最短路的第 k 步到达节点 u ,中间节点需要满足:
将两个区间求交即是第 k 步的可达点集。我们声称
\left((f^{k-1}(s),f^k(s)\right]\cap\left[g^{d-k}(t),g^{d-k-1}(t)\right)=\left[g^{d-k}(t),f^{k}(s)\right]
证明:
假设 f^{k-1}(s)\ge g^{d-k}(t) ,则 s\to t 的最短路 k-1+d-k=d-1 ,矛盾。
假设 f^{k}(s)\ge g^{d-k-1}(t) ,则 s\to t 的最短路 k+d-k-1=d-1 ,矛盾。
由上述证明知 f^k(s)<g^{d-k-1}(t) ,因此所有 \left[g^{d-k}(t),f^{k}(s)\right] 两两不交,且从左向右排列。故只要在 d-1 个区间内求特殊点的数目即可。
记 b(k)=\sum\limits_{i=1}^k[i\in S] 。所求为
\begin{aligned}
&\sum_{k=1}^{d-1}\left(b(f^k(s))-b(g^{d-k}(t)-1)\right)\\
=&\sum_{k=1}^{d-1}b(f^k(s))-\sum_{k=1}^{d-1}b(g^{d-k}(t)-1)\\
=&\sum_{i=1}^{d-1}b(f^i(s))-\sum_{i=1}^{d-1}b(g^{i}(t)-1)
\end{aligned}
只要在 f,g 上跳 d-1 步,求沿途节点的 b 值之和。仍然可以倍增预处理。复杂度 O(q\log n) 。
:::::
:::::info[代码]
const int N = 2e5 + 5;
int n, q, l[N], r[N], b[N], f[18][N], g[18][N], fs[18][N], gs[18][N];
char a[N];
int qdis(int u, int v) {
int res = 0;
for (int i = lg(n); i >= 0; i--)
if (f[i][u] < v) u = f[i][u], res += 1 << i;
return res + 1;
}
int qsum(int u, int d, auto&& f, auto&& fs) {
int res = 0;
for (int i = lg(n); i >= 0; i--)
if (d >> i & 1) res += fs[i][u], u = f[i][u];
return res;
}
void prework() {
for (int i = 1; i <= n; i++) b[i] = b[i - 1] + (a[i] == '1');
for (int i = 0; (1 << i) <= n; i++) fill(f[i], f[i] + n + 2, n + 1);
for (int i = 1; i <= n; i++) {
f[0][i] = lower_bound(l + 1, l + n + 1, r[i]) - l - 1;
g[0][i] = upper_bound(r + 1, r + n + 1, l[i]) - r;
fs[0][i] = b[f[0][i]], gs[0][i] = b[g[0][i] - 1];
}
for (int i = 1; (1 << i) <= n; i++)
for (int j = 1; j <= n; j++) {
f[i][j] = f[i - 1][f[i - 1][j]];
g[i][j] = g[i - 1][g[i - 1][j]];
fs[i][j] = fs[i - 1][j] + fs[i - 1][f[i - 1][j]];
gs[i][j] = gs[i - 1][j] + gs[i - 1][g[i - 1][j]];
}
}
void _main() {
cin >> n >> q;
for (int i = 1; i <= 2 * n; i++) {
char c; cin >> c;
if (c == 'L') l[++l[0]] = i;
else r[++r[0]] = i;
}
cin >> (a + 1); prework();
for (int s, t; q--; ) {
cin >> s >> t;
int d = qdis(s, t), h = qsum(s, d - 1, f, fs) - qsum(t, d - 1, g, gs);
cout << d << ' ' << h + (a[s] == '1') + (a[t] == '1') << '\n';
}
}
:::::
P3615 [JOISC 2016] 如厕计划 / Toilets
给出一个长为 2n ,仅包含 M 与 F 的字符串 s 。定义一次操作为:
若 s_1=\tt{F} ,则直接消除前两个字符。
若 s_1=\tt{M} ,则先消除 s_1 ,再找到出现位置最靠前的 F 消除。
若 s 能被恰好 n 次操作消除为空串,过程中不会出现无法操作的情况,则称字符串 s 合法。
你需要对 s 重排得到新的字符串 s' ,此操作的代价为每个字符向后移动距离的最大值。求出所有合法的 s' 中,代价的最小值,或报告无解。
$n,k_i\le10^{18}$,$m\le10^5$,$\sum|s_i|\le2\times10^5$,1 秒,125 MB。
:::::success[题解]
初看题目感觉非常不可做。我们考虑推一些性质。
对于题目中 M 必须匹配后面的 F 的模式,我们可以建立括号匹配模型。而括号匹配模型又有这样一个经典转化:令 \tt{F}=1,\tt{M}=-1 ,将 s 抽象为一个只包含 -1,1 的序列。
观察到,合法序列的充要条件为:对于任意位置,后缀和必须 \ge-1 。必要性显然,不满足此性质意味着存在失配的 M。充分性则考虑 F 匹配 M/F 均可。
为了提高某些较小的后缀,我们尽量将 F 右移,M 左移。考虑 F 右移带动 M 左移填空缺,由于题目的代价计算方式,我们不用管 M 的移动,只需求出最大的 F 右移距离。
下面考虑 F 的极限位置。对于一个长为 k 的后缀,则 F 的数目至少是 \lfloor k/2\rfloor 。从右侧开始倒推,可以发现:
倒数第 1 个 F,最迟的出现在倒数第 2 个位置;
倒数第 2 个 F,最迟的出现在倒数第 4 个位置;
…
倒数第 w 个 F,最迟的出现在倒数第 2w 个位置。
因此,倒数第 i 个 F 的理论最左位置 f_i=2n-2i+1 。
设原字符串中倒数第 i 个 F 的实际位置为 p_i ,若 p_i<f_i ,则必须右移此 F。向右移动的距离为 p_i-f_i ,则答案
\max\left(0,\max_{i}(2n-2i+1-p_i)\right)
设 F 的总数为 x ,则倒数第 i 个 F 前有 c=x-i+1 个 F。代入 2n-2i+1-p_i 得
2n-2(x-c+1)+1-p_i=2n-2x-1+2c-p_i
注意到 2c-p_i 的实际意义:在长为 i 的前缀中,F 的数目为 c ,M 的数目为 p_i-c ,二者相减有 c-(p_i-c)=2c-p_i 。所以这个式子就是前缀和!
记最大前缀和为 s ,答案即 \max(0,2n-2x-1+s) 。特判 x<n 无解。
至此,问题已经被转化为求最大前缀和。直接模拟可以获得 60pts。
下面处理分段字符串。我们对每个子串 s_i ,算出扫过 s_i 的前缀和变化量 \Delta_i 和局部最大前缀和 m_i 。
若 \Delta_i\le0 ,则前缀和单调减,最大值一定在第一次循环中取到,变化量即 m_i 。
若 \Delta_i>0 ,则前缀和单调增,最大值在最后一次循环中取到,变化量即 (k_i-1)\Delta_i+m_i 。
全部扫完后,按照推出的公式计算即可。视 m,\sum|s_i| 同阶,复杂度 O(m) 。
:::::
:::::info[代码]
i64 n, m, k;
string s;
void _main() {
cin >> n >> m;
i64 x = 0, tot = 0, pre = 0, mx = 0;
while (m--) {
cin >> s >> k;
x += count(s.begin(), s.end(), 'F') * k, tot += s.size() * k;
i64 d = 0, md = 0;
for (char c : s) d += (c == 'F' ? 1 : -1), md = max(md, d);
if (d <= 0) mx = max(mx, pre + md);
else mx = max(mx, pre + (k - 1) * d + md);
pre += d * k;
}
if (x < n) return cout << -1, void();
cout << max(0LL, 2 * n - 2 * x - 1 + mx);
}
:::::
P17141 [NOI 2026] 传送
给定一棵 n 个节点的无根树。你需要在树上游走。设当前位于节点 u ,可以选择下列策略之一:
选定 u 的邻居 v 并走到节点 v 。
从 1,2,\cdots,n 中等概率随机一个 v ,走到节点 v 。
两种策略均花费 1 单位时间。
进行 q 次询问,给定 s,t ,最小化 s 游走到 t 的期望时间并回答。
:::::success[题解]
取固定的终点 t 进行分析。设 E_u 为 u\to t 的最短期望时间,由题意
E_u=\min\left(1+\min_{(u,v)\in E}E_v,1+\dfrac{1}{n}\sum_{i=1}^n E_i\right)
贪心地,取 \min\limits_{(u,v)\in E}E_v 时 v 一定是更接近 t 的邻居,于是
E_u=\min\left(\text{dis}(u,t),1+\dfrac{1}{n}\sum_{i=1}^n E_i\right)
注意到右侧 1+\dfrac{1}{n}\sum\limits_{i=1}^n E_i 是一个常数,我们将其记作 C 。对 \min 的取值进行讨论:
若 \text{dis(u,t)}\le C ,则 E_u=\text{dis}(u,t) 。
若 \text{dis}(u,t)>C ,则 E_u=C 。
这表明策略关于距离单调:
性质 1 对固定的 t ,存在定值 d 使得 \text{dis}(u,t)\le d 的 u 处策略为向 v 走一步,\text{dis}(u,t)>d 的 u 处策略为随机跳跃。
取 d=\lfloor C\rfloor ,记 S=\{u\mid\text{dis}(u,t)\le d\} ,S 的形态是 t 的 d 邻域 。
若起点不在 S 中,则需要跳进 S ,一次跳跃的成功概率为 \dfrac{|S|}{n} 。由几何分布,期望步数为 E_1=\dfrac{n}{|S|} 。进入 S 后,只要走向 t ,期望步数为 E_0=\dfrac{1}{|S|}\sum\limits_{u\in S}\text{dis}(u,t) 。于是,从 S 外部到达 t 的期望步数
E=E_0+E_1=\dfrac{1}{|S|}\left(n+\sum\limits_{u\in S}\text{dis}(u,t)\right)
对所有 t 枚举 d 求 E_{\min} ,询问时对 \text{dis}(s,t) 做 chkmin,复杂度 O(n^2+q) ,获得 45pts。
观察 E_0+E_1 随 d 的变化规律,通过打表得
性质 2 对固定的 t ,E 关于 d 下凸 。
于是我们对导数二分得到最优的 d 。问题瓶颈为:给定 t,d ,求 |S| 和 \sum\limits_{u\in S}\text{dis}(u,t) ,要求在线。
这是点分树的经典应用。具体地,我们对点分树上每个节点 x 维护 u\in\text{subtree}(x)\land\text{dis}(u,x)\le k 的 u 的数目 c_{x,k} ,再记录 u\in\text{subtree}(x)\land\text{dis}(u,\text{fa}_x)\le k 的 u 的数目 c'_{x,k} 用于容斥。查询 t 时向上跳根链即可得到 |S| ,\sum\limits_{u\in S}\text{dis}(u,t) 的处理类似。数组 c 的空间为点分树的深度和 O(n\log n) 。
正确实现的复杂度为 O(n\log^2 n+q) 。获得 75pts。
进一步优化是一个神秘观察:
性质 3 对原树上相邻的点 u,v ,节点 u 和 v 的最优 d 值至多相差 1 。
这是因为,我们得到 u 的策略后可以走一步 u\to v 来得到 v 的策略,反之同理。
我们自顶向下 DFS,对根做一次 2log 的二分导数,其余点通过父亲的 d 值计算答案。具体地,设父亲的决策点为 d_0 ,则当前决策点必然 \in\{d_0-1,d_0,d_0+1\} ,直接用 1log 的点分树查询求出 \max 即可。
:::::info[代码]
const int N = 5e5 + 5;
int n;
vector<int> e[N];
int dn, dfn[N], dep[N], st[20][N];
int chk(int u, int v) {return dfn[u] < dfn[v] ? u : v;}
void dfs1(int u, int fa) {
dfn[u] = ++dn, st[0][dn] = fa;
for (int v : e[u]) {
if (v == fa) continue;
dep[v] = dep[u] + 1, dfs1(v, u);
}
}
int lca(int u, int v) {
if (u == v) return u;
u = dfn[u], v = dfn[v];
if (u > v) swap(u, v);
int k = lg(v - u++);
return chk(st[k][u], st[k][v - (1 << k) + 1]);
}
int dis(int u, int v) {return dep[u] + dep[v] - 2 * dep[lca(u, v)];}
vector<i64> c[N], c2[N], s[N], s2[N];
int del[N], sz[N];
void dfs2(int u, int fa) {
sz[u] = 1;
for (int v : e[u])
if (v != fa && !del[v]) dfs2(v, u), sz[u] += sz[v];
}
int dfs3(int u, int fa, int tot) {
for (int v : e[u])
if (v != fa && !del[v] && sz[v] > tot / 2) return dfs3(v, u, tot);
return u;
}
void dfs4(int u, int fa, vector<int>& p) {
p.emplace_back(u);
for (int v : e[u])
if (v != fa && !del[v]) dfs4(v, u, p);
}
int pa[N];
void build(int u, int p) {
dfs2(u, -1);
int x = dfs3(u, -1, sz[u]);
pa[x] = p;
vector<int> cur; dfs4(u, -1, cur);
int lim = -1, lim2 = -1;
for (int v : cur) chkmax(lim, dis(x, v));
if (p != -1) for (int v : cur) chkmax(lim2, dis(p, v));
c[x].resize(lim + 1), s[x].resize(lim + 1);
c2[x].resize(lim2 + 1), s2[x].resize(lim2 + 1);
for (int v : cur) {
int d = dis(x, v);
c[x][d]++, s[x][d] += d;
if (p != -1) {
int d2 = dis(p, v);
c2[x][d2]++, s2[x][d2] += d2;
}
}
for (int i = 1; i <= lim; i++)
c[x][i] += c[x][i - 1], s[x][i] += s[x][i - 1];
if (p != -1) for (int i = 1; i <= lim2; i++)
c2[x][i] += c2[x][i - 1], s2[x][i] += s2[x][i - 1];
del[x] = true;
for (int y : e[x]) if (!del[y]) build(y, x);
}
pair<i64, i64> ask(int t, int d) {
auto val = [](vector<i64>& v, int k) -> i64 {
if (k < 0 || v.empty()) return 0;
if (k >= (int)v.size()) return v.back();
return v[k];
};
i64 cnt = val(c[t], d), sum = val(s[t], d);
for (int x = t, f = pa[x]; f != -1; x = f, f = pa[x]) {
int w = dis(t, f), k = d - w;
if (k < 0) continue;
cnt += val(c[f], k), sum += val(s[f], k) + val(c[f], k) * w;
cnt -= val(c2[x], k), sum -= val(s2[x], k) + val(c2[x], k) * w;
}
return {cnt, sum};
}
frac64 f(int t, int d) {
auto [cnt, sum] = ask(t, d);
return frac64(n + sum, cnt);
}
pair<frac64, int> solve(int t) {
int l = 0, r = n - 1, p = n;
while (l <= r) {
int mid = (l + r) >> 1;
if (f(t, mid) <= f(t, mid + 1)) p = mid, r = mid - 1;
else l = mid + 1;
}
return {f(t, p), p};
}
frac64 w[N];
void dfs5(int u, int fa, int op) {
for (int v : e[u]) {
if (v == fa) continue;
int p = -1;
for (int i = op-1; i <= op+1; i++) {
if (i < 0 || i > n) continue;
auto c = f(v, i);
if (p == -1 || c < w[v]) w[v] = c, p = i;
}
dfs5(v, u, p);
}
}
vector<pair<i64, int>> teleport(int c, int n, int m, vector<int> u, vector<int> v, vector<int> x, vector<int> y) {
::n = n;
for (int i = 0; i < n-1; i++) {
u[i]++, v[i]++;
e[u[i]].emplace_back(v[i]), e[v[i]].emplace_back(u[i]);
}
dfs1(1, 0);
for (int i = 1; (1 << i) <= n; i++)
for (int j = 1; j + (1 << i) - 1 <= n; j++)
st[i][j] = chk(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
build(1, -1);
vector<pair<i64, int>> vec;
auto [w1, op] = solve(1);
w[1] = w1, dfs5(1, -1, op);
for (int i = 0; i < m; i++) {
int s = x[i]+1, t = y[i]+1;
frac64 f = min<frac64>(dis(s, t), w[t]);
vec.emplace_back(f.ratio());
} return vec;
}
:::::
P7831 [CCO 2021] Travelling Merchant
给你一个 n 个点,m 条边的有向图,边有边权 (a_i,b_i) 。
你初始从节点 u 出发,持有一个初始数字 x 。每次操作可以经过一条满足 x\ge a_i 的边走到另一个点,并使得 x\gets x+b_i 。
对于 u=1,2,\cdots,n ,求出可以无限游走的最小初始数字,或报告无解。
:::::success[题解]
感觉做法可能需要与外星人交流得出。
先进行一些初步的观察,环是重要的,走不到环一定是不合法的。
我们可以通过拓扑排序来删去不合法点。每次找到若干零出度点将其删去,执行多次后,剩下的是就是环和环上挂的一些结构。这可以在反图上拓扑实现。
设计一个 DP,记 f_u 为 u 点的答案,那么考虑其出边 (u,v) 得转移
f_u=\min_{(u,v,a,b)\in E}\max(a,f_v-b)
由于图上有环,这个 DP 有后效性,无法直接转移。
可以魔改最短路算法进行转移,比如魔改 SPFA,节点答案每次变化时入队,多次更新。由于入队次数没有上限,复杂度是假的,实测可以获得 83 分。
我们用贪心的思想来转移图上 DP。上述做法都是从一个节点开始扩展,是正向思考,难以做到优秀的复杂度。那么我们正难则反,从反向思考,这基于以下观察:
如果初值为 a 的最大值,那么一定不会被边权所限制。
零出度点 v 是无用的,则形如 (u,v) 的边也是无用的。
结合上述做法中的拓扑预处理,我们得到一种交错拓扑的逆向转移:
首先,将所有边按 a 降序排序并扫描。
对反图做一轮拓扑,对于拓扑中相关的边 (u,v,a,b) ,执行转移 f_v\gets\max(a,f_u-b) ,然后删去这条边。
若当前扫描到的边 (u,v,a,b) 未被删去,则将 f_u 与其下界 a 做 chkmin,并且删去当前边。若这一操作使得 u 零出度,则加入拓扑队列。
第 2 条转移是常规转移,第 3 条转移是防止队列空时,图上剩下一堆环,无法执行拓扑。此时,第 1 步就非常重要。根据我们的观察,将 a 直接作为答案一定不会被限制。这就是 f_u 的下界。
由于我们打破了环结构,每个节点必定入队一次,故算法正确。
复杂度 O(m\log m) ,瓶颈在排序。
:::::
::::info[代码]
const int N = 2e5 + 5;
const i64 inf = 2e18;
int n, m, deg[N], vis[N];
struct edge {
int u, v, a, b;
bool operator< (const edge& e) const {return a < e.a;}
} e[N];
vector<int> rev[N];
i64 f[N];
void _main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> e[i].u >> e[i].v >> e[i].a >> e[i].b;
deg[e[i].u]++;
}
sort(e + 1, e + m + 1);
for (int i = 1; i <= m; i++) rev[e[i].v].emplace_back(i);
queue<int> q;
for (int i = 1; i <= n; i++) if (!deg[i]) q.emplace(i);
fill(f + 1, f + n + 1, inf);
for (int i = m; i >= 1; i--) {
while (!q.empty()) {
int u = q.front(); q.pop();
for (int eid : rev[u]) {
if (vis[eid]) continue;
vis[eid] = true;
auto [v, _, a, b] = e[eid];
if (--deg[v] == 0) q.emplace(v);
f[v] = min(f[v], max<i64>(a, f[u] - b));
}
}
if (vis[i]) continue;
vis[i] = true;
if (--deg[e[i].u] == 0) q.emplace(e[i].u);
f[e[i].u] = min<i64>(f[e[i].u], e[i].a);
}
for (int i = 1; i <= n; i++) cout << (f[i] > 1e18 ? -1 : f[i]) << ' ';
}
:::::
QOJ6964 Werewolves
现有 n 个人,每人持有一个 [1,m] 中的正整数。每个人可以看到其他人的数字,但不能得知自己的数字,需要猜测一个数字。
构造每个人的策略,使得猜对的人数至少为 \lfloor n/m\rfloor 。
多测,2 \le m \le n ,\sum m^n \le 1.4 \times 10^7 ,1 秒,512 MB。
:::::success[题解]
假设数字均匀随机生成,每个人随机猜测,则猜对概率均为 \frac{1}{m} 。由二项分布,猜对人数的期望为 \frac{n}{m} ,从而 \lfloor n/m\rfloor 是理论上界。
由于限制顶到期望上界,我们的构造原则就是控制事件互斥。考虑鸽巢构造法,将 n 个事件分为 m 组,使得组间事件互斥。
设第 i 个人的数字为 x_i 。为叙述方便,将 x_i 映射到 [0,m) 范围。第 i 个人可以知道 S_i=\sum \limits_{j \ne i} x_j ,如果知道总和 S=\sum\limits_{i=1}^n x_i ,就可以算出 S-S_i\equiv x_i \pmod m 。
考虑用 m 组事件取遍 S \bmod m 。一个取巧的方案是,第 i 个人猜测 S \equiv i \pmod m ,进而 x_i\equiv i-S_i 。将这个作为策略即可。
:::::
:::::info[代码]
int n, m;
void dfs(int x, int id, int sum, int lo) {
if (x >= n) {
cout << (id - sum + m) % m + 1 << ' ';
return;
}
for (int i = lo; i <= m; i++) dfs(x + 1, id, (sum + i) % m, i);
}
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) dfs(1, i, 0, 1), cout << '\n';
}
:::::
QOJ17165 Four Sages Around an Oak Tree
现有 4 个人坐成一个环,每个人头上有一顶帽子,帽子有 \tt{R},\tt{G},\tt{B} 三种颜色。每个人可以看到两边人的帽子颜色,但是不能看到自己的。构造一种策略,使得至少有一人可以猜对自己的帽子颜色。
采用通信方式提交。多测且 T\le100 ,1.5 秒,1024 MB。
:::::success[题解]
记 \tt{R}=0,\tt{G}=1,\tt{B}=2 ,并将颜色在模 3 意义下运算。将四个人称作 ABCD,帽子颜色称为 a,b,c,d ,可以发现,A & C 以及 B & D 的信息是相同的,因此策略要对称。
事实上有如下解法:令 B 猜 a+c ,D 猜 a-c ,若都失败,必有 b=a+c\pm1 且 d=a-c\pm1 。此时可令 A 猜 \frac{b+d}{2} ,C 猜 \frac{b-d}{2} ,当正负号相同时 A 成功,反之 C 成功。
另一种方法是直接搜索。解空间大概是 3^{4\times3\times3}\approx1.5\times10^{17} 级别,用一些剪枝手法可以找到策略。
:::::info[代码]
int opt, a, b, c, d;
int F(const string& s) {return s == "red" ? 0 : s == "green" ? 1 : 2;}
string G(int x) {return x == 0 ? "red" : x == 1 ? "green" : "blue";}
void _main() {
if (opt == 1) {
string s;
cin >> s, a = F(s), cin >> s, b = F(s), cin >> s, c = F(s), cin >> s, d = F(s);
if ((a + c) % 3 == b) return cout << 2 << endl, void();
if ((a - c + 3) % 3 == d) return cout << 4 << endl, void();
if ((b + d) * 2 % 3 == a) return cout << 1 << endl, void();
return cout << 3 << endl, void();
} else {
int n; cin >> n;
string s;
cin >> s, a = F(s), cin >> s, b = F(s);
if (n == 2) cout << G((a + b) % 3) << endl;
else if (n == 4) cout << G((b - a + 3) % 3) << endl;
else if (n == 1) cout << G((a + b) * 2 % 3) << endl;
else cout << G((a - b + 3) * 2 % 3) << endl;
}
}
:::::
QOJ14559 并行计算
现有一个数组,可以使用一些并行指令,你需要使用不超过 200 条指令计算分段前缀和。详情见原题题面。
1 秒,256 MB。
:::::success[题解]
先考虑直接算前缀和怎么做:以 32 为块长分块,先做块内的前缀和,然后再将块尾加到下一个块的每个数上。
那么正确答案应该由这个位置减去上一个 1 所在位置得出。
将上述做法描述为:所有 1 出现位置的前缀 \max 。而前缀 \max 可以使用类似前缀和的办法算出。
事实上,通过对位乘法,我们可以精确地保留所有 1 位置的和,并且将 0 位置上清空,然后做前缀 \max 。
计算答案只需再做一次对位减法。指令数目为 188 ,足以通过。
:::::info[代码]
struct node {int id;} a[5000];
using vecpi = vector<pair<int, int>>;
vecpi A, S, M, X;
void out(string op, vecpi& a) {
cout << op << ' ' << 32 << '\n';
for (auto [x, y] : a) cout << x << ' ';
cout << '\n';
for (auto [x, y] : a) cout << y << ' ';
cout << '\n';
for (auto [x, y] : a) cout << x << ' ';
cout << '\n';
a.clear();
}
void operator+= (node& a, const node& b) {
A.emplace_back(a.id, b.id);
if (A.size() == 32) out("add", A);
}
void operator-= (node& a, const node& b) {
S.emplace_back(a.id, b.id);
if (S.size() == 32) out("sub", S);
}
void operator*= (node& a, const node& b) {
M.emplace_back(a.id, b.id);
if (M.size() == 32) out("mul", M);
}
void operator&= (node& a, const node& b) {
X.emplace_back(a.id, b.id);
if (X.size() == 32) out("max", X);
}
void _main() {
cout << 188 << '\n';
for (int i = 0; i < 4096; i++) a[i].id = i;
for (int i = 1; i < 32; i++)
for (int j = 0; j < 1024; j += 32) a[i + j] += a[i + j - 1];
for (int i = 32; i < 1024; i += 32)
for (int j = 0; j < 32; j++) a[i + j] += a[i - 1];
for (int i = 0; i < 1024; i += 32)
for (int j = 0; j < 32; j++) a[i + j + 1024] *= a[i + j];
for (int i = 1; i < 32; i++)
for (int j = 1024; j < 2048; j += 32) a[i + j] &= a[i + j - 1];
for (int i = 1056; i < 2048; i += 32)
for (int j = 0; j < 32; j++) a[i + j] &= a[i - 1];
for (int i = 0; i < 1024; i += 32)
for (int j = 0; j < 32; j++) a[i + j] -= a[i + j + 1024];
}
:::::
CF547D Mike and Fish
给出二维平面上 n 个两两不同的点 (x_i,y_i) 。你需要将每个点黑白染色,使得每条水平 / 竖直线上颜色黑白点的数目之差不超过 1 。输出构造。
:::::success[题解]
考虑图论建模。将所有点按 x 坐标分成若干类,对于每个相同的 x 坐标,将其中的点两两配对并连边。如果有奇数个点,则剩余一个不连边。
对 y 坐标做相同的操作。
此时我们得到一张图。根据建图方式,每个顶点的度数至多为 2 ,故每个连通块的形态只可能是链或者环。而二度点必然是一条 x 边和一条 y 边,则每个环上一定是 x,y 边交替,也即图中不存在奇环。
因此该图为二分图。由于每行每列至多一个孤立点,将其黑白染色以后可以满足题目约束。复杂度 O(n\log n) 。
启示:网格图相关的问题,考虑行列转点,格子转边,建模为二分图。
::::::info[代码]
const int N = 2e5 + 5;
int n, col[N];
struct node {
int x, y, id;
} a[N];
vector<int> e[N];
void add(int u, int v) {e[u].emplace_back(v), e[v].emplace_back(u);}
void dfs(int u) {
for (int v : e[u])
if (col[v] == -1) col[v] = col[u] ^ 1, dfs(v);
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].x >> a[i].y, a[i].id = i;
sort(a + 1, a + n + 1, [](const node& a, const node& b) -> bool {
return a.x < b.x;
});
for (int i = 1; i <= n; i++) {
if (a[i].x == a[i + 1].x) add(a[i].id, a[i + 1].id), i++;
}
sort(a + 1, a + n + 1, [](const node& a, const node& b) -> bool {
return a.y < b.y;
});
for (int i = 1; i <= n; i++) {
if (a[i].y == a[i + 1].y) add(a[i].id, a[i + 1].id), i++;
}
fill(col + 1, col + n + 1, -1);
for (int i = 1; i <= n; i++) if (col[i] == -1) col[i] = 0, dfs(i);
for (int i = 1; i <= n; i++) cout << (col[i] ? 'r' : 'b');
}
::::::
:::::success[另解]
经典转化:对于每个点 (x_i,y_i) ,连边 x_i\to y_i 形成一张无向二分图。
那么颜色就相当于是边的方向。因此题目转化为给每条边定向,使得每个点的入度和出度之差不超过 1 。
引入虚点 S ,对于每个奇度数点 u ,连边 S\to u 。根据握手定理,奇度数点必有偶数个,则新图中所有点的度数都是偶数。
用 Hierholzer 对每个连通块跑出一条欧拉回路即可得到定向方案,复杂度 O(V) 。代码。
启示:可以用边的方向表示一种决策,用欧拉路解决问题。
P9731 [CEOI 2023] Balance
给定一个 m\times k 的矩阵,值域为 [1,n] 。你需要将每行重排,使得 \forall i\in[1,n] ,数字 i 在所有列中出现次数的极差不超过 1 。输出构造。保证 \mathbf{k} 是 \mathbf{2} 的幂。
:::::success[题解]
考虑 k=2 。对于同行的两个数 u_i,v_i ,只要考虑重排为 [u_i,v_i] 还是 [v_i,u_i] 。
建图 u_i\leftrightarrow v_i 并用边的方向表示决策。则题目的约束转化为每个点的出入度之差 \le1 。套路地建超级源点对所有奇度数点连边,跑出一条欧拉回路表示决策即可。可以获得 35pts。
将其推广到一般情形。对列分治,设当前区间为 [l,r] ,分治中心为 m 。我们用上面的算法将数划分到 [l,m] 和 (m,r] 进行归纳构造。
具体地,考虑连边 a_{i,j}\leftrightarrow a_{i,j+m-l+1} ,其中 i\in[1,m],j\in[l,m] 。则边的两个端点必然被划分到两侧,用边的方向表示决策。建超级源点向所有奇度数点连边,跑欧拉回路得到方案后递归。正确性考虑 c\to\lfloor c/2\rfloor 和 c\to\lceil c/2\rceil 时不存在 \ge2 的层。
复杂度 O(mk\log k) 。
:::::
:::::info[代码]
const int N = 2e5 + 5;
int n, m, k;
vector<int> a[N];
vector<tuple<int, int, int>> e[N];
int hd[N], vis[40*N];
void dfs(int u, vector<int>& ans) {
for (int& i = hd[u]; i < (int)e[u].size(); ) {
auto [v, id, d] = e[u][i++];
if (vis[id]) continue;
vis[id] = true, dfs(v, ans);
if (id < (int)ans.size()) ans[id] = d;
}
}
void solve(int l, int r) {
if (l == r) return;
int mid = (l + r) >> 1, ln = mid - l + 1, cnt = 0;
vector<tuple<int, int, int>> vec;
vector<int> cur;
for (int i = 1; i <= m; i++)
for (int j = l; j <= mid; j++) {
int u = a[i][j], v = a[i][j + ln];
e[u].emplace_back(v, cnt, 0), e[v].emplace_back(u, cnt, 1);
cur.emplace_back(u), cur.emplace_back(v);
vec.emplace_back(i, j, j + ln), cnt++;
}
vector<int> ans(cnt, -1);
sort(cur.begin(), cur.end()), cur.erase(unique(cur.begin(), cur.end()), cur.end());
for (int u : cur) if (e[u].size() & 1)
e[0].emplace_back(u, cnt, -1), e[u].emplace_back(0, cnt, -1), cnt++;
cur.emplace_back(0);
for (int u : cur) dfs(u, ans);
for (int i = 0; i < (int)ans.size(); i++) {
auto [u, x, y] = vec[i];
if (ans[i]) swap(a[u][x], a[u][y]);
}
for (int u : cur) e[u].clear(), hd[u] = 0;
fill(vis, vis + cnt, 0);
solve(l, mid), solve(mid + 1, r);
}
void _main() {
cin >> m >> k >> n;
for (int i = 1; i <= m; i++) {
a[i].resize(k);
for (int j = 0; j < k; j++) cin >> a[i][j];
}
solve(0, k - 1);
for (int i = 1; i <= m; i++)
for (int j = 0; j < k; j++) cout << a[i][j] << " \n"[j == k-1];
}
:::::
P10873 [COTS 2022] 帽子 Šeširi
现有 n 个人头上戴着红色或白色的帽子,每个人只能看到别人的帽子颜色,他们会根据别人的帽子颜色猜测自己头上帽子的颜色。
你需要为每个人构造一组猜测策略,使得对于所有 2^n 种情况都满足以下条件:
设有 b 人戴了白色帽子,其中至少有 \lfloor\frac{b}{2}\rfloor 人猜对自己帽子的颜色。
设有 c 人戴了红色帽子,其中至少有 \lfloor\frac{c}{2}\rfloor 人猜对自己帽子的颜色。
输出构造。
:::::success[题解]
对于所有 2^n 种情况中的其中一种状态 S ,我们只改变第 i 个人戴的帽子颜色得到状态 T 。那么第 i 个人在 S,T 中获得的信息完全一致,猜测策略也必然一致。
更直观的说,对第 i 个人的决策就是一个二选一:让 S 增加一个猜对的人,还是让 T 增加一个猜对的人。
考虑图论建模,连无向边 S\leftrightarrow T ,然后用边的方向表示决策 。如果定向为 S\to T ,则令 T 增加一个猜对的人,反之同理。另一种理解是,一条边表示了一种冲突关系,两个端点必然一个满足一个不满足。
一个状态下猜对的人就是这个节点的入度。弱化题目的限制,即要求猜对的人数至少为 \lfloor\frac{n}{2}\rfloor 。那么建一个虚点向所有奇度数点连边,然后跑出一条欧拉回路,根据边的方向即可得到答案。
回到原题,我们将一个状态拆成两个点 S_0,S_1 ,用 S_0 的入度表示状态 S 下白帽猜对的人数,S_1 的入度表示红帽猜对的人数。枚举状态对 (S,T) ,记 S 中第 i 个人为白帽,T 中第 i 个人为红帽,连边 S_0\leftrightarrow T_1 然后仿照上面的做法跑欧拉回路即可。
:::::info[代码]
const int N = 4e6 + 5;
int n, m, cnt, hd[N], vis[N];
vector<pair<int, int>> e[N];
string a[20];
void add(int u, int v) {e[u].emplace_back(v, ++cnt), e[v].emplace_back(u, cnt);}
void dfs(int u) {
for (int& i = hd[u]; i < (int)e[u].size(); ) {
auto [v, id] = e[u][i++];
if (vis[id]) continue;
vis[id] = true, dfs(v);
if (u >= 2 * m || v >= 2 * m) continue;
int s = min(u, v), t = max(u, v), d = ctz(s ^ (t - m));
int mask = (s >> (d + 1) << d) | (s & ((1 << d) - 1));
if (u < m) a[n - 1 - d][mask] = 'C';
else a[n - 1 - d][mask] = 'B';
}
}
void _main() {
cin >> n; m = 1 << n;
for (int i = 0; i < n; i++) a[i].resize(1 << (n - 1));
for (int s = 0; s < m; s++)
for (int i = 0; i < n; i++)
if (!(s >> i & 1)) add(s, (s ^ (1 << i)) + m);
for (int s = 0; s < 2 * m; s++)
if (e[s].size() & 1) add(2 * m, s);
for (int s = 0; s <= 2 * m; s++) dfs(s);
for (int i = 0; i < n; i++) cout << a[i] << '\n';
}
:::::
AGC025E Walking on a Tree
给出一棵 n 个点的无根树,再给定 m 个二元组 (u_i,v_i) 。你需要依次考虑 i=1,2,\cdots,m ,选择从 u_i 游走到 v_i ,或从 v_i 游走到 u_i 。
第 i 次的游走的得分定义为,游走路径上满足如下条件之一的边的数目:
在前 i-1 次游走中,该边未被经过。
在前 i-1 次游走中,该边的所有遍历方向恰与本次相反。
最大化总得分,并构造一组方案。
::::::success[题解]
先尝试分析理论上界。容易用树上差分得到第 i 条边被经过的次数 c_i ,分类讨论:
若 c_i=0 ,它不会提供任何得分。
若 c_i=1 ,它只被遍历一次,必然产生 1 的得分。
若 c_i\ge2 ,它最多被正反遍历两次,至多产生 2 的得分。
因此,得分的理论上界是
\sum_{i=1}^{n-1}\min(2,c_i)
断言上界可以取到。为了给出构造式证明,必须让 c_i\ge2 的边真正被正反遍历。
考虑对 m 个点对 (u_i,v_i) 建无向边。我们将原题条件强化为,偶度数点度数平衡,奇度数点出入度之差 \le1 。
假定所有连通块都是欧拉图,则可以对每个连通块跑出一条欧拉回路,由出入度平衡的性质构造必然合法。
:::::error[错解]{open}
考虑建超级源点对所有奇度数点连边,再跑欧拉回路。
::::info[Hack]
考虑树的结构 1\to2\to3\to4 ,给出两次游走 (1,3) 和 (2,4) 。
建立的虚图边为 (S,1),(S,2),(S,3),(S,4),(1,3),(2,4) 。得到欧拉回路 S\to1\to3\to S\to2\to4\to S 。
定向方案为 1\to3,2\to4 。此时树边 (2,3) 没有产生 2 的得分。
::::
:::::
使用另一种处理奇度数点的手法。注意到对于树上节点 u ,虚图中 u 的度数奇偶性,恰好等于树上 u 邻域 c_i 为奇数的数目奇偶性。这启发我们,将所有 c_i 为奇数的树边加入虚图中,这样虚图中所有点的度数就被调整为偶数。
这样调整之后,我们再对每个连通块跑欧拉回路,得到定向方案即可。
复杂度 O(n\log n+m) ,如果线性 LCA 可以做到 O(n+m) 。
::::::
::::::info[代码]
const int N = 2005;
int n, m, tot, c[N], s[N], t[N];
vector<int> e[N];
vector<pair<int, int>> g[N];
int fa[N], sz[N], dep[N], son[N], top[N];
void dfs1(int u) {
sz[u] = 1;
for (int v : e[u]) {
if (v == fa[u]) continue;
fa[v] = u, dep[v] = dep[u] + 1, dfs1(v), sz[u] += sz[v];
if (sz[v] > sz[son[u]]) son[u] = v;
}
}
void dfs2(int u, int t) {
top[u] = t;
if (son[u]) dfs2(son[u], t);
for (int v : e[u]) if (v != fa[u] && v != son[u]) dfs2(v, v);
}
int lca(int u, int v) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
u = fa[top[u]];
} return dep[u] < dep[v] ? u : v;
}
void dfs3(int u) {
for (int v : e[u]) {
if (v == fa[u]) continue;
dfs3(v), c[u] += c[v];
if (g[v].size() & 1) tot++, g[u].emplace_back(v, tot), g[v].emplace_back(u, tot);
}
}
int hd[N], vis[2 * N], ans[N];
void dfs4(int u) {
for (int& i = hd[u]; i < (int)g[u].size(); ) {
auto [v, id] = g[u][i++];
if (vis[id]) continue;
vis[id] = true, dfs4(v);
if (id > m) continue;
ans[id] = u == t[id];
}
}
void _main() {
cin >> n >> m;
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
e[u].emplace_back(v), e[v].emplace_back(u);
}
dfs1(1), dfs2(1, 1);
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
if (u > v) swap(u, v);
s[i] = u, t[i] = v;
g[u].emplace_back(v, i), g[v].emplace_back(u, i);
c[u]++, c[v]++, c[lca(u, v)] -= 2;
}
tot = m, dfs3(1);
int res = 0;
for (int i = 2; i <= n; i++) res += min(2, c[i]);
cout << res << '\n';
for (int i = 1; i <= n; i++) dfs4(i);
for (int i = 1; i <= m; i++) {
if (ans[i]) swap(s[i], t[i]);
cout << s[i] << ' ' << t[i] << '\n';
}
}
::::::
ABC373G No Cross Matching
给出 2n 个点 (x_i,y_i) 和 (x_i',y_i') 。保证不存在三点共线。
构造一个 1\sim n 的排列 p_i 使得将 (x_i,y_i) 和 (x_{p_i}',y'_{p_i}) 连线后,这 n 条线段两两不交。
输出构造或报告无解。
:::::success[题解]
分析 n=2 的情形。画出不共线的四点 A,B,C,D
显然有 |AC|+|BD|<|AD|+|BC| 。
直接给出断言,使得 \sum\limits_{i=1}^n\sqrt{(x'_{p_i}-x_i)^2+(y'_{p_i}-y_i)^2} 取 \min 的 p 必合法。
证明考虑调整法,将两条有交线段改为不交,总和减少,交点数目减小,故总和最小必能使得构造合法。
考虑建一张完全二分图,边权是端点距离,则只要找出最小权完美匹配。转化为费用流模型,在残量网络上找构造即可,可以通过。
:::::
:::::info[代码]
const int N = 305;
int n, id[N][N];
using node = pair<i64, i64>;
node a[N], b[N];
double dis(const node& a, const node& b) {
return sqrt((a.fi - b.fi) * (a.fi - b.fi) + (a.se - b.se) * (a.se - b.se));
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
id[i][j] = flow.add(i, j+n, 1, dis(a[i], b[j]));
const int s = 0, t = 2 * n + 1;
for (int i = 1; i <= n; i++) flow.add(s, i, 1, 0);
for (int j = 1; j <= n; j++) flow.add(j+n, t, 1, 0);
flow(s, t);
for (int u = 1; u <= n; u++)
for (int v = 1; v <= n; v++)
if (flow.lim[id[u][v]] == 0) {
cout << v << ' '; break;
}
}
:::::
P11517 [CCO 2024] Infiltration
给出一棵节点数为 n 的无根树,有两个人 A & B 位于这棵树上,且不知道对方的位置。
在时刻为奇数时 A 可以选择不动,或者移动到相邻节点;在时刻为偶数时 B 可以选择不动,或者移动到相邻节点。
你需要为两个人各自制定 n 个策略,第 i 个策略代表这个人初始位于节点 i 时,接下来 T 个时刻内的移动策略。要求 T\le1440 。
记 d(u,v) 为 u,v 两点间距离,t(u,v) 为 A 从 u 出发且 B 从 v 出发,按照策略两人第一次相遇的时刻。你需要使
S=\max_{u=1}^n\max_{v=1}^n\dfrac{t(u,v)}{d(u,v)}
尽可能小。输出构造。
:::::success[题解]
首先,两人的地位是相同的,因此策略也应该相同,不能向子树里乱跑。于是有一个平凡构造:任意定根后,两人不断跳父亲,此时 S=2n ,可以获得 24pts。
我们要最小化比值,应该让距离小的 (u,v) 相遇的时刻较小,距离大的 (u,v) 相遇的时刻较大,可以考虑倍增。令 A & B 不断跳 2^0,2^1,2^2,\cdots,2^7 步,此时 S 被压缩到 \log n 级别,且 T 为 n\log n 级别。朴素的实现中,S\approx17.27 ,可以获得 80pts。
接下来是卡常环节。先引入第一个优化:选择树的中心定根。这里 n 很小,直接 O(n^2) 找中心即可,这样 100 的最大深度被压到 50 ,可以得到 88pts。
然后引入第二个优化:每次跳的步数不必须为 2 的幂次,考虑类似百万富翁那样乱搞一组步数序列。经过搜索和人力调参,取步数序列 1,2,5,14,28,43,60,80 可以通过本题数据。最大的 S=14.6 。
:::::info[代码]
const int N = 105;
const int num[8] = {1, 2, 5, 14, 28, 43, 60, 80};
int n, fa[N], dep[N];
vector<int> e[N], a[N], b[N];
void dfs1(int u, int fa) {
for (int v : e[u]) {
if (v == fa) continue;
dep[v] = dep[u] + 1, dfs1(v, u);
}
}
void dfs2(int u) {
for (int v : e[u]) {
if (v == fa[u]) continue;
fa[v] = u, dfs2(v);
}
}
void _main() {
cin >> n;
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
e[u].emplace_back(v), e[v].emplace_back(u);
}
dfs1(0, -1);
int rt = 0, md = *max_element(dep, dep + n);
for (int i = 1; i < n; i++) {
dep[i] = 0, dfs1(i, -1);
int cd = *max_element(dep, dep + n);
if (cd < md) rt = i, md = cd;
}
fa[rt] = rt, dfs2(rt);
const int m = 1024;
cout << m << '\n';
for (int u = 0; u < n; u++) {
int c = 0, p = u, l = 1, len = 2 * num[0], idx = 0;
for (int t = 1; t <= m; t++) {
if (t >= l + len) {
l += len, idx++, c ^= 1;
if (idx < 8) len = 2 * num[idx];
}
if (c == 0 && t % 2 == 1) p = fa[p];
cout << p << ' ';
}
cout << '\n';
}
for (int u = 0; u < n; u++) {
int c = 0, p = u, l = 1, len = 2 * num[0], idx = 0;
for (int t = 1; t <= m; t++) {
if (t >= l + len) {
l += len, idx++, c ^= 1;
if (idx < 8) len = 2 * num[idx];
}
if (c == 1 && t % 2 == 0) p = fa[p];
cout << p << ' ';
}
cout << '\n';
}
}
:::::
AGC006F Blackout
现有一个 n\times n 的矩阵,初始时有 m 个黑格 (a_i,b_i) 。一次操作选择两个黑格 (x,y),(y,z) ,将 (z,x) 染黑。
你可以执行任意次操作,最大化黑格的数目并输出。
:::::success[题解]
将矩阵视作图的邻接矩阵,问题重新表述为:
现有 n 个点的有向图 G ,初始有 m 条边,若存在边 x\to y 和 y\to z 则连边 z\to x 。最大化边数并输出。
我们注意到特定的 G 可以变为完全图,考虑如何刻画这类图的性质。
对 G 进行 DFS,按照 DFS 树上深度\bmod3 进行三染色。
若染色失败,则 G 必然可以变为完全图,贡献为 |V|^2 。
若染色成功,但颜色数 \le2 ,容易说明 G 无法进行操作,贡献为 |E| 。
若染色成功,且颜色数 =3 ,记 c_0,c_1,c_2 为三种颜色的数目,贡献为 c_0c_1+c_0c_2+c_1c_2 。构造形如按 0\to1\to2 顺序连边。
详细证明可以看这篇题解,这里只给结论。
复杂度 O(n+m) 。实现时,可以对图建立反边做三染色。
:::::
:::::info[代码]
const int N = 1e5 + 5;
int n, m;
vector<pair<int, int>> e[N];
i64 c[3], vc, ec, ok, col[N];
void dfs(int u) {
c[col[u]]++, vc++;
for (auto [v, w] : e[u]) {
int ncol = (col[u] + w + 3) % 3; ec += w==1;
if (col[v] != -1 && col[v] != ncol) ok = false;
if (col[v] == -1) col[v] = ncol, dfs(v);
}
}
void _main() {
cin >> n >> m;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
e[u].emplace_back(v, 1), e[v].emplace_back(u, -1);
}
fill(col + 1, col + n + 1, -1);
i64 res = 0;
for (int i = 1; i <= n; i++) {
if (col[i] != -1) continue;
col[i] = 0, c[0] = c[1] = c[2] = vc = ec = 0, ok = 1, dfs(i);
if (!ok) res += vc * vc;
else if (c[0] && c[1] && c[2]) res += c[0]*c[1] + c[0]*c[2] + c[1]*c[2];
else res += ec;
} cout << res;
}
:::::
P13356 [GDCPC 2024] 图
给出一个 n 个点 m 条边的无向图,你需要找到一个点对 (u,v) 使得 u\to v 存在 k 条边不交路径,其中 k=\lceil\frac{m}{n-1}\rceil 。输出构造或报告无解。
多测,\sum n\le10^5 ,\sum m\le2\times10^5 ,1 秒,512 MB。
:::::success[题解]
注意到 k 的实际意义可以被描述为:将 m 条边划分为若干组,每组的边数为 n-1 。于是考虑维护 k 棵树。
严谨的说,由于图不连通,我们维护的其实是 k 个森林。下面考虑如何用这些森林构造答案。
设最终的点对为 (u,v) ,我们希望 u\to v 在 k 个森林上都存在一条路径。考虑采取增量构造的方法,每加入原图中的一条边 (u,v) ,就二分出最小的 p 使得 u\to v 在第 p 个森林上没有路径,然后将这条边加入该森林中。
另一个说法是叠重边之后直接暴力建森林就是对的,复杂度根号。
总之我们可以得到 k 个森林,在第 k 个森林上任意找一条边 (u,v) ,将 (u,v) 作为最终答案,然后在前 k-1 个森林上 DFS 找路径即可。路径总长是 O(m) 级别的。视 n,m 同阶,上述做法的复杂度为 O(n\alpha(n)\log n) 。
注意如果二分找不到森林,说明 (u,v) 本身就是一组解。
:::::
:::::info[代码]
const int N = 2e5 + 5;
int n, m, k;
vector<int> e[N];
struct uf {
vector<int> fa;
void init(int n) {fa.assign(n + 5, 0), iota(fa.begin(), fa.end(), 0);}
int find(int x) {return x == fa[x] ? x : fa[x] = find(fa[x]);}
void unite(int x, int y) {fa[find(x)] = find(y);}
bool connected(int x, int y) {return find(x) == find(y);}
} d[N];
struct forest {
vector<vector<int>> e;
void init(int n) {e.assign(n + 5, vector<int>());}
void add(int u, int v) {e[u].emplace_back(v), e[v].emplace_back(u);}
void out(int u, int v) {
vector<int> p = {u};
function<bool(int, int)> dfs = [&](int u, int fa) -> bool {
if (u == v) return true;
for (int v : e[u]) {
if (v == fa) continue;
p.emplace_back(v);
if (dfs(v, u)) return true;
p.pop_back();
}
return false;
};
dfs(u, -1);
cout << p.size() << ' ';
for (int i : p) cout << i << ' ';
cout << '\n';
}
} f[N];
void work(int u, int v) {
cout << u << ' ' << v << '\n';
for (int i = 1; i < k; i++) f[i].out(u, v);
cout << 2 << ' ' << u << ' ' << v << '\n';
}
void _main() {
cin >> n >> m; k = (n + m - 2) / (n - 1);
for (int i = 1; i <= k; i++) d[i].init(n), f[i].init(n);
int au = -1, av = -1;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
e[u].emplace_back(v), e[v].emplace_back(u);
int l = 1, r = k, p = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (!d[mid].connected(u, v)) p = mid, r = mid - 1;
else l = mid + 1;
}
if (p == -1) au = u, av = v;
else d[p].unite(u, v), f[p].add(u, v);
}
if (au != -1) return work(au, av), void();
for (int u = 1; u <= n; u++)
for (int v : f[k].e[u]) return work(u, v), void();
}
:::::
P12204 [COI 2022] 委员选举 / Povierenstvo
给出一个 n 个点 m 条边的有向图 G=(V,E) ,保证不存在有向奇环。找到集合 S\subseteq V 使得
输出构造或报告无解。
:::::success[题解]
考虑 G 是 DAG 怎么做。显然,零入度点 v 一定在 S 中。这样,v 的后继 u 就不能是 S 中的点。
因此我们跑拓扑排序,每轮将零入度点加入 S ,并将其后继标记即可。
回到原问题,仍然考虑先跑拓扑排序删掉外围的点,这样会剩下若干 SCC。
题目保证了该 SCC 无向化后是二分图。考虑取零入度 SCC 的一组黑白染色,仍然标记 S 中点的后继,归纳构造即可,复杂度 O(nm) 。
考虑优化。注意到删去一个零入度点可能会导致 SCC 被分裂,而一组黑白染色劈成两半仍然合法。故直接对删点后的图黑白染色即可。
实现方式就是先 SCC 缩点,对着缩点以后的图拓扑排序。每遍历到一个 SCC,就在其内部用拓扑排序删掉零入度点,剩下的点取黑白染色,然后更新这个 SCC 向外的支配关系。
复杂度 O(n+m) ,注意代码细节。
:::::
:::::info[代码]
const int N = 5e5 + 5;
int n, m, col[N];
vector<int> e[N], re[N];
int dn, cnt, dfn[N], low[N], ins[N], bel[N];
stack<int> st;
vector<int> scc[N];
void tarjan(int u) {
dfn[u] = low[u] = ++dn, st.emplace(u), ins[u] = true;
for (int v : e[u]) {
if (!dfn[v]) tarjan(v), chkmin(low[u], low[v]);
else if (ins[v]) chkmin(low[u], dfn[v]);
}
if (dfn[u] != low[u]) return;
int x; cnt++;
do {
x = st.top(), st.pop(), ins[x] = false;
bel[x] = cnt, scc[cnt].emplace_back(x);
} while (x != u);
}
int deg[N];
void work(int id) {
for (int u : scc[id]) deg[u] = 0;
for (int u : scc[id]) {
if (col[u] != -1) continue;
for (int v : e[u])
if (bel[v] == id && col[v] == -1) deg[v]++;
}
queue<int> q;
for (int u : scc[id])
if (col[u] == -1 && deg[u] == 0) q.emplace(u), col[u] = 1;
while (!q.empty()) {
int u = q.front(); q.pop();
for (int v : e[u]) {
if (bel[v] != id || col[v] != -1) continue;
if (col[u] == 1) col[v] = 0, q.emplace(v);
else if (--deg[v] == 0) col[v] = 1, q.emplace(v);
}
}
function<void(int)> dfs = [&](int u) -> void {
for (int v : e[u]) {
if (col[v] != -1 || bel[v] != id) continue;
col[v] = col[u] ^ 1, dfs(v);
}
for (int v : re[u]) {
if (col[v] != -1 || bel[v] != id) continue;
col[v] = col[u] ^ 1, dfs(v);
}
};
for (int u : scc[id]) if (col[u] == -1) col[u] = 1, dfs(u);
for (int u : scc[id]) {
if (col[u] != 1) continue;
for (int v : e[u]) if (bel[v] != id) col[v] = 0;
}
}
void _main() {
cin >> n >> m;
for (int i = 1, u, v; i <= m; i++) {
cin >> v >> u;
e[u].emplace_back(v), re[v].emplace_back(u);
}
for (int i = 1; i <= n; i++) if (!dfn[i]) tarjan(i);
fill(col + 1, col + n + 1, -1);
for (int i = cnt; i >= 1; i--) work(i);
cout << count(col + 1, col + n + 1, 1) << '\n';
for (int i = 1; i <= n; i++) if (col[i] == 1) cout << i << ' ';
}
:::::
P3561 [POI 2017] Turysta
给出一张 n 个节点的竞赛图,对于每个点 u 求出从 u 出发的最长简单路径。输出构造。
::::::success[题解]
竞赛图找哈密顿回路练习题。
首先给出如下引理:
前两个定理在这篇 blog 讲的非常详细,这里不证。下面给出后两个定理的构造式证明:
::::success[Redéi 定理]
考虑增量构造。假设我们已经排好了 1\sim k-1 的哈密顿路 u_1\sim u_{k-1} ,尝试插入 k 。找到一个位置 i 使得 (k,u_i),(u_{i+1},k)\in E ,将 k 插入到 u_i,u_{i+1} 之间即可。注意特判放在首尾的情形。
::::
::::success[Camion-Moon 定理]
先用 Redéi 定理的构造找出一条哈密顿路,然后在路径上顺序扫描。
想象我们当前位于点 x ,左侧已经被折叠成环 c_1\to c_2\to\cdots\to c_m\to c_1 ,右侧还是一条链,链是哈密顿路的一部分。
我们尝试将 x 插入环中。分类讨论:
若存在 (c_i,x)\in E,(x,c_{i+1})\in E ,可以直接将 x 插入 c_i.c_{i+1} 之间。
否则,我们向后找到一个点 y ,使得 \exists i,(y,c_i)\in E 。将 x\to y 的子链插入 c_i 之前。
根据强连通的定义,必然存在这样的一个 y ,否则后面的点走不到回路上。
::::
我们把这些定理应用到这个问题上。
利用 Landau 定理推论找出所有 SCC 并缩点后,DAG 的形态类似一条链。
考虑找出每个 SCC 的哈密顿回路。根据 DAG 的形态,直接取一段后缀的哈密顿回路拼起来,就能构成一条简单路径。
这样,这个问题的做法就显然了:利用 Camion-Moon 定理的构造求得 SCC 的哈密顿回路。对于一点 u ,取拓扑序不小于其所在 SCC 的所有哈密顿回路拼起来。
精细实现复杂度 O(n^2) ,建议读者参照代码理解。
::::::
:::::info[代码]
const int N = 2005;
int n, m, d[N], p[N], bel[N];
vector<int> e[N], scc[N], hp[N];
bitset<N> has[N];
void work(int id) {
vector<int> P, C;
auto redei = [&]() -> void {
for (int u : scc[id]) {
int s = P.size();
for (auto it = P.begin(); it != P.end(); it++)
if (has[u][*it]) {
P.insert(it, u); break;
}
if ((int)P.size() == s) P.emplace_back(u);
}
};
auto camion = [&]() -> void {
C.emplace_back(P[0]);
int i = 1, n = P.size();
while (i < n) {
int c = C.size(), to = -1, u = P[i];
for (int j = 0; j < c; j++)
if (has[u][C[j]]) {
to = j; break;
}
if (to != -1) {
int p = 0;
for (int j = 0; j < c; j++) {
int k = (j + 1) % c;
if (has[C[j]][u] && has[u][C[k]]) {
p = k; break;
}
}
if (p == 0) C.emplace_back(u);
else C.insert(C.begin() + p, u);
i++;
} else {
int j = i + 1, p = -1;
for (; j < n && p == -1; j++)
for (int k = 0; k < c; k++)
if (has[P[j]][C[k]]) {
p = k; break;
}
if (p == 0) C.insert(C.end(), P.begin() + i, P.begin() + j);
else C.insert(C.begin() + p, P.begin() + i, P.begin() + j);
i = j;
}
}
};
redei(), camion(), hp[id].swap(C);
}
void _main() {
cin >> n;
for (int u = 2; u <= n; u++)
for (int v = 1, x; v < u; v++) {
cin >> x;
if (x) e[v].emplace_back(u), has[v][u] = 1, d[u]++;
else e[u].emplace_back(v), has[u][v] = 1, d[v]++;
}
iota(p + 1, p + n + 1, 1), sort(p + 1, p + n + 1, [](int u, int v) -> bool {
return d[u] < d[v];
});
for (int i = 1, sum = 0, last = 0; i <= n; i++) {
sum += d[p[i]];
if (sum == i * (i - 1) / 2) {
scc[++m] = vector<int>(p + last + 1, p + i + 1);
for (int j = last + 1; j <= i; j++) bel[p[j]] = m;
last = i;
}
}
for (int i = 1; i <= m; i++) work(i);
for (int u = 1; u <= n; u++) {
vector<int> vec = hp[bel[u]];
rotate(vec.begin(), find(vec.begin(), vec.end(), u), vec.end());
for (int i = bel[u] + 1; i <= m; i++)
vec.insert(vec.end(), hp[i].begin(), hp[i].end());
cout << vec.size() << ' ';
for (int v : vec) cout << v << ' ';
cout << '\n';
}
}
:::::
P8376 [APIO2022] 排列
给出正整数 k 。要求构造一个 0\sim n-1 的排列,使得上升子序列的数目恰为 k ,含空序列。
多测,T\le100 ,2\le k\le10^{18} ,满分要求 n\le90 ,1 秒,256 MB。
:::::success[题解]
::::info[71 pts]
这个做法是我 vp 时胡的,没有什么前途。
先忽略空序列,即令 k\gets k-1 。注意到 0 1 2 ... 这种长为 i 的块可以带来 2^i-1 的贡献,从大到小枚举 i 将 k 拆分即可。长度为 \frac{1}{2}\log^2 k ,可以得到 71pts。
考虑每次填入最大数,则有如下的归纳构造:
将最大数放在开头:k\gets k+1 ;
将最大数放在结尾:k\gets k\times2 。
递归边界为 k=1 ,此时给出空序列。长度为 2\log k ,可以得到 91pts。
::::info[假 100 pts]
考虑利用多元素块。考虑在结尾插入如下形式的排列:
加入这三个特判后已经可以通过,获得 100pts。
事实上有 hack:k=105\times2^{53}-1=945755921747804159 时,上述算法无法利用 3,5,7 的剪枝,最终 n=114 ,故这是一个假算。
考虑换一个视角,考虑在开头插入 [0,1] 后,有 k\gets k+3 ,可以压去二进制下连续的两个 1 。但是这种构造本身代价为 2 ,没有意义。
事实上,在从小到大填入的过程中,将数字插入第三位的效果和上述构造相同,这样做的代价仅为 1 。因此长度就被压到 1.5\log n ,可以通过。写法参考了这篇题解,太简洁了。
:::::info[代码]
vector<int> construct_permutation(i64 k) {
deque<int> q; int n = 0;
function<void(i64)> dfs = [&](i64 k) -> void {
if (k <= 4) {
while (--k) q.emplace_front(n++);
return;
}
if (k % 2 == 0) dfs(k >> 1), q.emplace_back(n++);
else if (k % 4 == 3) dfs(k - 3), q.insert(q.begin() + 2, n++);
else dfs(k - 1), q.emplace_front(n++);
};
dfs(k);
return vector<int>(q.begin(), q.end());
}
:::::
UOJ216 Jakarta Skyscrapers
现有集合 S ,初始 S=\{a,b\} 。一次操作选定 i,j 满足 i>j 且 i\in S,j\in S ,将 i-j 加入 S 。目标为 c\in S 。构造方案或报告无解。
:::::success[题解]
先进行初步观察:这个操作类似辗转相减求 GCD。由 Bézout 定理,能造出的数一定是 \gcd(a,b) 的倍数。并且这些数且不会超过 m=\max(a,b) 。
若 c 不满足这些必要条件则无解,否则我们断言必有解,下面给出构造式证明。
构造分为两步:先得到 g=\gcd(a,b) ,再得到 g 的若干倍数,从而得到 c 。
直接进行辗转相减,最坏复杂度为 O(m) 。考虑用给出的操作造出一些更人类的操作。
记题目中的操作为 S(a,b)=a-b 。可以通过如下方法得到操作 D(x)=2x :
\begin{aligned}
D(x)&=2x\\
&=m-(m-2x)\\
&=m-\left((m-x)-x)\right)\\
&=S\left(m,S\left(S(m,x),x\right)\right)
\end{aligned}
需要保证 x\in S\land2x\le m ,此时 D 操作的代价为 3 。
使用倍增思想结合 S,D 操作,我们可以构造一个约减操作 R(a,b,q)=a-qb 。先利用 D 操作造出 2b,4b,8b,\cdots,2^k b ,将 q 拆成二进制后,使用 S 操作减去对应的值即可。R 操作的代价为 \log q 级别,要求为 a,b\in S 。
容易发现,R(a,b,\frac{a}{b})=a\bmod b 。因此我们可以辗转相除直接得到 GCD。将操作记为 G(a,b)=\gcd(a,b) ,代价为 \log^2 m 级别。
记 c=x\times g ,求出 g 后只需将其翻 x 倍。但是这里没有加法,不能正面倍增。正难则反,我们计算 c'=R(m,g,x)=m-c ,最后一步减法即得 c=S(m,c') 。
至此完成构造,整体代价为 \log^2 m 级别且常数较小,可以通过。
:::::info[代码]
#define int long long
int a, b, c, m;
set<int> st;
vector<pair<int, int>> vec;
int S(int x, int y) {
if (x < y) swap(x, y);
if (x == y) return 0;
int z = x - y;
if (!st.count(z)) st.emplace(z), vec.emplace_back(x, y);
return z;
}
int D(int x) {return S(m, S(S(m, x), x));}
int R(int a, int b, int q) {
if (q == 0) return a;
if (q == 1) return S(a, b);
a = R(a, D(b), q >> 1);
if (q & 1) a = S(a, b);
return a;
}
int G(int a, int b) {
if (a % b == 0) return b;
return G(b, R(a, b, a / b));
}
void _main() {
cin >> a >> b >> c, m = max(a, b);
if (c > m || c % gcd(a, b)) return cout << -1, void();
st.emplace(a), st.emplace(b);
if (st.count(c)) return cout << 0, void();
int g = G(m, min(a, b));
if (!st.count(c)) {
int mc = R(m, g, c / g);
if (mc != 0) S(m, mc);
}
cout << vec.size() << '\n';
for (auto& i : vec) cout << i << '\n';
}
:::::
QOJ1870 Command and Conquer: Red Alert 2
你位于一个三维空间内,初始坐标 (-10^{100},-10^{100},-10^{100}) 。每一步可以从 (x,y,z) 走到 (x+1,y,z) 或 (x,y+1,z) 或 (x,y,z+1) ,终点为 (10^{100},10^{100},10^{100}) 。
现有 n 个任务,第 i 个任务坐标为 (x_i,y_i,z_i) 。你需要确定一个非负整数 k ,则位于 (x,y,z) 时可以完成任务 i 当且仅当 \max(|x-x_i|,|y-y_i|,|z-z_i|)\le k 。
求最小的 k 使得你可以完成所有任务。
多测,\sum n\le2\times10^6 ,|x_i|,|y_i|,|z_i|\le10^9 ,10 秒 ,512 MB。
:::::success[题解]
认为 (x,y,z) 可以完成任务 i 的充要条件为 x_i\in[x,x+2k]\land y_i\in[y,y+2k]\land z_i\in[z,z+2k] ,显然不会影响答案。不妨转为求 k'=2k 的最小值,则 k_{\min}=\lceil\frac{k'}{2}\rceil 。
我们可以贪心走到 (x_{\min},y_{\min},z_{\min}) 作为初始位置。
考虑求出 x_a 取得最小的 a ,同理得到 y_b 最小的 b 和 z_c 最小的 c 。此时一定要完成任务 a,b,c 其中之一。
记 f(x) 为完成任务 x 所需的最小 k' 。则 f(a)=\max(y_a-y_b,z_a-z_c) ,同理可以计算 f(b),f(c) 。
用 std::set 模拟上述过程,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 5e5 + 5;
using node = pair<int, int>;
int n, x[N], y[N], z[N];
set<node> X, Y, Z;
void _main() {
X.clear(), Y.clear(), Z.clear();
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i] >> z[i];
X.emplace(x[i], i), Y.emplace(y[i], i), Z.emplace(z[i], i);
}
int k = 0;
for (int i = 1; i <= n; i++) {
auto [xa, a] = *X.begin();
auto [yb, b] = *Y.begin();
auto [zc, c] = *Z.begin();
int fa = max(y[a] - y[b], z[a] - z[c]);
int fb = max(x[b] - x[a], z[b] - z[c]);
int fc = max(x[c] - x[a], y[c] - y[b]);
int f = min({fa, fb, fc}); chkmax(k, f);
int p = f == fa ? a : f == fb ? b : c;
X.erase(node(x[p], p)), Y.erase(node(y[p], p)), Z.erase(node(z[p], p));
}
cout << (k + 1) / 2 << '\n';
}
```
:::::
:::::success[另解]
二分答案 $k$。则此时每个任务形成一个正方体,在正方体内才能完成它。
对于任务 $i,j$,先 $i$ 后 $j$ 的顺序必须满足 $x_i-k\le x_j+k\land y_i-k\le y_j+k\land z_i-k\le z_j+k$。如果满足这个条件,则连边 $i\to j$。则答案 $k$ 合法当且仅当图是一个 DAG,即存在一组拓扑序。
直接建图然后拓扑排序是 $O(n^2\log V)$,无法通过。
考察图的形态,对于零入度点 $u$,根据条件列出不等式,整理得 $\max(x_u-x_{\min},y_u-y_{\min},z_u-z_{\min})\le2k$,其中 $\min$ 为图上未遍历节点的坐标最小值。
可以直接维护剩余点三个维度的最小值。用 set 维护带一个 $\log$ 比较危险,考虑队列模拟 set。
我们将所有点按照 $x_i,y_i,z_i$ 分别排序,维护六个指针,用于动态更新 $\min$ 和将节点入队,模拟拓扑过程即可,复杂度 $O(n\log V)$。[代码](https://qoj.ac/submission/2246740)。
:::::
## [P9521 [JOIST 2022] 京都观光 / Sightseeing in Kyoto](https://www.luogu.com.cn/problem/P9521)
> 现有一个 $n\times m$ 的网格图,你需要从 $(1,1)$ 走到 $(n,m)$,只能向右 / 向下移动。在第 $i$ 行向下移动花费 $a_i$ 的代价,第 $j$ 列向右移动花费 $b_j$ 的代价。求最小代价。
>
> $n,m\le10^5$,$1\le a_i,b_i\le10^9$,2 秒,1024 MB。
:::::success[题解]
这题神了。
刻画局部性质。如下图所示,考虑最优解中的一个折线:

(图源:[官方题解](https://www2.ioi-jp.org/camp/2022/2022-sp-tasks/contest1/kyoto-review.pdf))
则向下后右的代价为 $b_1+a_2$,先右后下的代价为 $a_1+b_2$。钦定后者更优的话,则有 $a_1+b_2<b_1+a_2\iff a_1-a_2<b_1-b_2$。此时行列分离。

考虑求出 $a,b$ 的差分,则最大差分对应的行 / 列一定不会出现折线,可以直接将其删去,如上图所示。删去以后,原本的 $1\to9$ 行会变成一个长为 $2$ 的矩形。
进一步推广上述结论。对于行 $x_1,x_2$,列 $y_1,y_2$,从左下边界转移的代价为 $b_{y_1}(x_2-x_1)+a_{x_2}(y_2-y_1)$,从右上边界转移的代价为 $a_{x_1}(y_2-y_1)+b_{y_2}(x_2-x_1)$。钦定后者更优,移项整理得 $\frac{a_{x_1}-a_{x_2}}{x_1-x_2}<\frac{b_{y_2}-b_{y_1}}{y_2-y_1}$,行列仍然分离。
假定 $n,m$ 同阶,此时得到一个 $O(n\log n)$ 做法。我们可以用 std::set & 链表模拟删边过程,每轮找到最大差分,然后在双向链表中考虑:若该点为链表头节点则加入答案,否则合并其前驱。
事实上有更为简洁的做法:考虑一维情形,对于点 $(i,a_i),(j,a_j),(k,a_k)$,若三点不成下凸,此时 $i\to j\to k$ 一定劣于 $i\to k$。那么最优解一定位于 $(i,a_i)$ 的凸包上。
进一步,二维情形的答案也具有凸性,且可以视为行列答案的 Minkowski 和。于是可以求出凸包后,用双指针在两个下凸壳上扫描,向斜率较小的一侧移动,严格 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, m, a[N], b[N];
vector<int> x, y;
void convex(int *a, int n, vector<int>& st) {
for (i64 i = 1; i <= n; i++) {
while (st.size() >= 2) {
i64 q = st.back(), p = st[st.size() - 2];
if ((i - q) * (a[q] - a[p]) < (q - p) * (a[i] - a[q])) break;
st.pop_back();
}
st.emplace_back(i);
}
}
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> b[i];
convex(a, n, x), convex(b, m, y);
int s1 = x.size(), s2 = y.size();
i64 res = 0;
auto chk = [](int x1, int y1, int x2, int y2) -> bool {
return 1LL * (y2 - y1) * (a[x1] - a[x2]) < 1LL * (x1 - x2) * (b[y2] - b[y1]);
};
for (int i = 0, j = 0; i+1 < s1 || j+1 < s2; ) {
if (i+1 >= s1 || (j+1 < s2 && chk(x[i], y[j], x[i + 1], y[j + 1]))) {
res += 1LL * a[x[i]] * (y[j + 1] - y[j]), j++;
} else {
res += 1LL * b[y[j]] * (x[i + 1] - x[i]), i++;
}
}
cout << res;
}
```
:::::
## [ARC076F Exhausted?](https://www.luogu.com.cn/problem/AT_arc076_d)
> 现有 $n$ 个人,第 $i$ 个人希望坐在坐标 $\in(-\infty,l_i]\cup[r_i,+\infty)$ 的椅子上。另有 $m$ 把椅子,分别位于坐标 $1,2,\cdots,m$。每把椅子只能坐一个人。
>
> 你可以在任意实数坐标添加椅子,最小化添加椅子的数目并输出。
>
> $n,m\le2\times10^5$,$0\le l_i<r_i\le m+1$,2 秒,256 MB。
:::::success[题解]
显然是一个匹配问题,考虑建二分图,即对于第 $i$ 个人,向坐标 $\in(-\infty,l_i]\cup[r_i,+\infty)$的椅子连边。我们找出二分图的最大匹配,失配的人数就是答案。
由 Hall 定理推论,二分图$G=(X,Y,E)$ 的最大匹配数
$$
|M|=|X|-\max_{W\subseteq X}(|W|-|N(W)|)
$$
所求为 $n-|M|$ 且 $|X|=n$,故答案为
$$
\begin{aligned}
&\max_{W\subseteq X}(|W|-|N(W)|)\\
=&\max_{W\subseteq X}\left(|W|-\left|\bigcup_{u\in W}N(u)\right|\right)\\
=&\max_{W\subseteq X}\left(|W|-\left|U\setminus\bigcap_{u\in W}(U\setminus N(u))\right|\right)\\
=&\max_{W\subseteq X}\left(|W|-\left(m-\left|\bigcap_{u\in W}(l_u,r_u))\right|\right)\right)\\
=&\max_{W\subseteq X}\left(|W|+\left|\bigcap_{u\in W}(l_u,r_u)\right|\right)-m
\end{aligned}
$$
先特判掉区间无交的情形,此时取 $W=X$ 不劣,答案为 $n-m$。
如果区间有交,答案式可以进一步化为
$$
\begin{aligned}
&\max_{W\subseteq X}\left(|W|+\left|\bigcap_{u\in W}(l_u,r_u)\right|\right)\\
=&\max_{W\subseteq X}\left(|W|+\min_{u\in W}r_u-\max_{u\in W}l_u-1\right)
\end{aligned}
$$
记 $x=\max\limits_{u\in W}l_u,y=\min\limits_{u\in W}r_u$,只要最大化 $|W|+y-x$。同时,$i\in W$ 的充要条件是 $l_i\le x\land r_i\ge y$。
转二维平面分析,将 $(l_i,r_i)$ 画在二维平面上,则 $W$ 形成了一个以 $(x,y)$ 为右下角的 2-side 矩形。
对 $x$ 扫描线,将 $l_i\le x$ 的点全部激活,则 $|W|$ 变为 $r_i\ge y$ 的活跃点数目,将其记为 $w(y)$。考虑在 $y$ 轴上用一个数据结构维护 $w(y)+y$,加点 $(l_i,r_i)$ 就是将 $w(0)\sim w(r_i)$ 区间 $+1$。
使用线段树维护前缀加与全局 $\max$ 即可。视 $n,m$ 同阶复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, m;
struct node {
int x, y;
} a[N];
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
int val[N << 2], tag[N << 2];
void pushup(int rt) {val[rt] = max(val[ls], val[rs]);}
void apply(int rt, int c) {val[rt] += c, tag[rt] += c;}
void pushdown(int rt) {
if (!tag[rt]) return;
apply(ls, tag[rt]), apply(rs, tag[rt]), tag[rt] = 0;
}
void build(int l = 0, int r = m + 1, int rt = 1) {
if (l == r) return val[rt] = l, void();
int mid = (l + r) >> 1;
build(l, mid, ls), build(mid + 1, r, rs), pushup(rt);
}
void update(int tl, int tr, int c, int l = 0, int r = m + 1, int rt = 1) {
if (tl <= l && r <= tr) return apply(rt, c), void();
int mid = (l + r) >> 1; pushdown(rt);
if (tl <= mid) update(tl, tr, c, l, mid, ls);
if (tr > mid) update(tl, tr, c, mid + 1, r, rs);
pushup(rt);
}
int all() {return val[1];}
} T;
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i].x >> a[i].y;
int res = max(0, n - m);
sort(a + 1, a + n + 1, [](const node& a, const node& b) -> bool {
return a.x < b.x;
});
T.build();
for (int x = 0, i = 1; x <= m + 1; x++) {
for (; i <= n && a[i].x <= x; i++) T.update(0, a[i].y, 1);
chkmax(res, T.all() - x - 1 - m);
} cout << res;
}
```
:::::
:::::success[另解]
首先将问题刻画为匹配,并且转为最大化有椅子的人数。
我们先假定第 $i$ 个人只能匹配 $[1,l_i)$ 中的椅子。显然按照 $l_i$ 升序排序并填到最左侧不劣。
扫描到第 $i$ 个人时,有可能出现填入失败的情况。考虑反悔贪心,动态调整,即在前缀中决策一个人 $j$,并令 $j$ 填入 $(r_j,m]$ 中。
我们选出所有 $j$ 并在最后决策。那么根据类似的逻辑,按 $r_i$ 降序排序并填到最右侧不劣。考虑这个整体调整的过程,可以发现 $r_j$ 越小越优。
因此,动态调整时只要选出前缀中 $r_j$ 最小的人,将其调整到右侧,然后将第 $i$ 个人填入。
使用小根堆维护上述过程,复杂度 $O(n\log n)$。[submission](https://atcoder.jp/contests/arc076/submissions/76892765)。
:::::
## [P7838 「Wdoi-3」夜雀 treating](https://www.luogu.com.cn/problem/P7838)
> 给定一个 $1\sim2n+1$ 的排列 $a_i$。你持有一个集合 $S$,初始为空集。对 $a$ 进行 $n+1$ 轮操作,第 $i$ 轮操作中:
>
> - 将当前正中央的数字取出,加入集合 $S$。
> - 若 $i\le n$,则任取一个数字将其删去。
>
> 操作完成后,$a$ 序列为空,且 $|S|=n+1$。
>
> 记 $S$ 的价值为满足 $T\subseteq S$ 且 $T$ 内元素构成公差为 $1$ 的等差数列的最大的 $|T|$。最大化 $S$ 的价值并输出。
>
> $n\le2\times10^5$,1 秒,250 MB。
:::::success[题解]
先对操作进行转化。首先,$a_{n+1}$ 在第一轮必然加入 $S$。之后,我们得到了两个长为 $n$ 的序列 $L=[a_n,a_{n-1},\cdots,a_1],R=[a_{n+2},a_{n+3},\cdots,a_{2n+1}]$。
定义元素 $i$ 到中心的距离为 $d_i$。将操作描述为:在某侧序列删去一个元素,并使得另一侧序列中 $d_i$ 最小的元素 $i$ 加入 $S$。
考虑枚举 $T=[l,r]$,将 $T$ 内的元素记为 $1$,$T$ 外的元素记为 $0$。我们需要寻找 $T$ 合法的充要条件。
直观上,$T$ 合法的条件是所有 $1$ 都被归入 $S$。将一轮操作中,被删去的元素和加入 $S$ 的元素描述为一组匹配,从而:
- $L$ 中的 $1$ 被加入 $S$,必能匹配到 $R$ 侧的 $0$。
- $R$ 中的 $1$ 被加入 $S$,必能匹配到 $L$ 侧的 $0$。
考察 $L$ 中的一个 $1$,将其记作 $y$。令 $R$ 侧与 $y$ 匹配的 $0$ 为 $x$,则必有 $d_x\ge d_y$。建二分图 $G=(X,Y,E)$,对 $d_x\ge d_y$ 连边 $x\to y$,此处 $T$ 合法的条件被转化为 $G$ 存在 $Y$ 的完美匹配。由 Hall 定理进一步转化为
$$
\min_{W\subseteq Y}(|N(W)|-|W|)\ge0
$$
分析知,上式取 $\min$ 的 $W$ 的形态必定是一段后缀。枚举后缀长度 $d$,记 $p_d$ 为 $L$ 中距离 $\ge d$ 的 $1$ 的数目,$q_d$ 为 $R$ 中距离 $\ge d$ 的 $1$ 的数目,则 $|W|=p_d,|N(W)|=n-d+1-q_d$。条件转化为
$$
n-d+1-q_d-p_d\ge0\iff p_d+q_d+d\le n+1
$$
其中 $p_d+q_d$ 的实际意义是:距离中心 $\ge d$ 的 $1$ 的数目。条件改写成
$$
\forall d\in[1,n],\sum_{i=l}^r[d_i\ge d]+d\le n+1
$$
对 $T$ 双指针,用线段树维护 $\sum\limits_{i=l}^r[d_i\ge d]+d$ 的全局 $\max$。具体地,线段树初始化为 $1,2,\cdots,n$,加入数值 $i$ 时对 $[1,d_i]$ 区间 $+1$,删去数值 $i$ 时对 $[1,d_i]$ 区间 $-1$ 即可。
复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 4e5 + 5;
int n, a[N], d[N];
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
int val[N << 2], tag[N << 2];
void pushup(int rt) {val[rt] = max(val[ls], val[rs]);}
void apply(int rt, int c) {val[rt] += c, tag[rt] += c;}
void pushdown(int rt) {
if (!tag[rt]) return;
apply(ls, tag[rt]), apply(rs, tag[rt]), tag[rt] = 0;
}
void build(int l = 0, int r = n, int rt = 1) {
if (l == r) return val[rt] = l, void();
int mid = (l + r) >> 1;
build(l, mid, ls), build(mid + 1, r, rs), pushup(rt);
}
void add(int tl, int tr, int c, int l = 0, int r = n, int rt = 1) {
if (tl <= l && r <= tr) return apply(rt, c), void();
int mid = (l + r) >> 1; pushdown(rt);
if (tl <= mid) add(tl, tr, c, l, mid, ls);
if (tr > mid) add(tl, tr, c, mid + 1, r, rs);
pushup(rt);
}
int all() {return val[1];}
} T;
void add(int x) {T.add(1, d[x], 1);}
void del(int x) {T.add(1, d[x], -1);}
void _main() {
cin >> n;
for (int i = 1; i <= 2*n+1; i++) cin >> a[i];
for (int i = 1; i <= n; i++) d[a[i]] = n+1 - i;
for (int i = n+2; i <= 2*n+1; i++) d[a[i]] = i - (n+1);
T.build(); int res = 0;
for (int l = 1, r = 1; r <= 2*n+1; r++) {
add(r);
while (l <= r && T.all() > n+1) del(l++);
chkmax(res, r - l + 1);
} cout << res;
}
```
:::::
## [P2541 [USACO16DEC] Robotic Cow Herd P](https://www.luogu.com.cn/problem/P2541)
> 给定 $n$ 个序列 $a_i$。对所有 $p_1,p_2,\cdots,p_n$ 满足 $\forall i,p_i\in[1,|a_i|]$,取 $\sum\limits_{i=1}^n a_{p_i}$ 为一组解,求前 $k$ 小解的和,保证有解。
>
> $n,k\le10^5$,$1\le|a_i|\le10$,3 秒,250 MB。
:::::success[题解]
首先对所有 $a_i$ 升序排序。
考虑 Shopping Plans Trick。直观的想法是将状态构造为 $S=(p_1,p_2,\cdots,p_n)$,此时 $S(x_1)=(1,1,\cdots,1)$。
转移即为枚举 $i\in[1,n]$,令 $p_i\gets p_i+1$。最优性和覆盖性成立,使用算法 1 解决。
我们发现 $S$ 需要 $O(n)$ 级别的信息,去重和转移的代价均不可接受。
为了避免维护解序列的形态,我们转而关注可行解关于最小解的**增量**。由于 $|a_i|=1$ 的序列无法提供增量,故将其删去。由于维护增量的要求,初始入堆的状态值应当是 $(2,1,1,\cdots,1)$。
钦定转移的拓扑序,决策移动第 $i$ 个指针后,之后只允许移动下标 $\ge i$ 的指针。从而状态转为 $S=(w,i,p_i,p_{i+1},\cdots,p_n)$,其中 $w$ 为当前权值和。
为书写简便,记 $\delta_i=a_{i,2}-a_{i,1}$,容易构造 $S$ 的转移为:
- 决策移动当前指针 $p_i$,$S\to(w-a_{i,p_i}+a_{i,p_i+1},i,p_i+1,\cdots)$。
- 枚举指针 $j\in(i,n]$ 并决策移动指针 $p_j$,$S\to(w+\delta_j,j,2,p_{j+1},\cdots)$。
观察上述转移,可以发现 $(p_{i+1},\cdots,p_n)$ 这些信息无用,可以将其删去,状态改为 $S=(w,i,p_i)$,转移为 $S\to(w-a_{i,p_i}+a_{i,p_i+1},i,p_i+1)$ 和 $S\to(w+\delta_j,j,2)$。
不难自行验证最优性、覆盖性、唯一性满足。使用算法 2 解决,由 $|\text{trans}(S)|=O(n)$ 得复杂度 $O(nk\log k)$,无法通过。
视 $-a_{i,p_i}+a_{i,p_i+1}$ 和 $\delta_j$ 为出边权值。考察转移图 $G$ 的形态,其构成以 $\left(\sum\limits_{i=1}^n a_{i,1}-\delta_1,1,1\right)$ 为根的多叉外向树,节点出度达到 $O(n)$。
我们希望优化 $S\to(w+\delta_j,j,2)$ 的转移,故拉出相关转移边的导出子图 $G'$ 并在 $G'$ 上思考问题。想象状态节点 $x\in\Omega$,我们将 $x$ 的所有儿子按出边权值升序排序,并将出边形态改为左儿子右兄弟表示法,出边权值变为邻项差分,如图:

这里将儿子按出边权值排序的目的是,保证上述变换后边权非负,导出最优性成立。
我们所有节点同时做上述操作,转移图变为外向二叉树,节点出度为 $O(1)$,容易说明两种转移图等效。
思考左儿子右兄弟优化在本题转移中的实际意义,就是将枚举 $j\in(i,n]$ 的过程转化只考虑 $j=i+1$,通过兄弟指针平移到 $i+2$。
$G'$ 上的转移如下:
- 左儿子:$(w,i,p_i)\to(w+\delta_{i+1},i+1,2)$。
- 右兄弟:若 $\textcolor{red}{p_i=2}$ 有 $(w,i,p_i)\to(w_i-\delta_i+\delta_{i+1},i+1,2)$。
注意到右兄弟的转移边权为 $-\delta_i+\delta_{i+1}\ge0$,需要按 $\delta_i$ 将所有序列升序排序。
注意原转移 $(w,i,p_i)\to(w-a_{i,p_i}+a_{i,p_i+1},i,p_i+1)$ 仍成立。
再使用算法 2,我们得到了 $O(\sum|a_i|\log|a_i|+n\log n+k\log k)$ 的做法,可以通过本题。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, m, k;
vector<int> a[N];
i64 delta(int i) {return a[i][2] - a[i][1];}
using state = tuple<i64, int, int>; // (w, i, p_i)
priority_queue<state, vector<state>, greater<state>> q;
void _main() {
cin >> m >> k;
i64 sum = 0, res = 0;
for (int i = 1, l; i <= m; i++) {
cin >> l; vector<int> vec;
for (int x; l--; ) cin >> x, vec.emplace_back(x);
sort(vec.begin(), vec.end()), res += vec[0];
if (vec.size() == 1) sum += vec[0];
else vec.insert(vec.begin(), -1), a[++n].swap(vec);
}
if (n == 0) return cout << sum, void();
sort(a + 1, a + n + 1, [](vector<int>& a, vector<int>& b) -> bool {
return a[2] - a[1] < b[2] - b[1];
});
q.emplace(res + delta(1), 1, 2);
while (--k) {
auto [w, i, pi] = q.top(); q.pop();
res += w + sum;
if (pi+1 < (int)a[i].size()) q.emplace(w + a[i][pi+1] - a[i][pi], i, pi+1);
if (i < n) q.emplace(w + delta(i+1), i+1, 2);
if (i < n && pi == 2) q.emplace(w - delta(i) + delta(i+1), i+1, 2);
} cout << res;
}
```
:::::
## [P6646 [CCO 2020] Shopping Plans](https://www.luogu.com.cn/problem/P6646)
> 给定 $n$ 个多重集 $S_i$ 和 $n$ 个区间 $[l_i,r_i]$,对所有 $c_1\sim c_n$ 满足 $\forall c_i\in[l_i,r_i]$,从 $S_i$ 中选取恰好 $c_i$ 个元素作为一组解,权值为选取的元素之和。求前 $k$ 小解,或报告无解。
>
> $n,k,\sum|S_i|\le2\times10^5$,2 秒,512 MB。
:::::success[题解]
假定对于多重集 $S_i$,我们得到特定算法,可以不重不漏地生成该集合上第 $1,2,3,\cdots$ 小合法方案的权值,记作序列 $a_i$。问题等价于从 $n$ 个序列中各取一个元素,求前 $k$ 小权值和,这正是上一题 [P2541](https://www.luogu.com.cn/problem/P2541)。
套用 [P2541](https://www.luogu.com.cn/problem/P2541) 的解法。由于我们只求全局前 $k$ 小,多重集上被索取次优解的总次数不会超过 $O(k)$。从而问题转化为:
给定不降序列 $a_1\sim a_m$,对 $c\in[l,r]$ 选取恰好 $c$ 个元素作为一组解,在线查询第 $k'$ 小解,且每次操作的 $k'$ 必然比上一轮多 $1$。
将问题弱化到 $l=r$。考虑 Shopping Plans Trick,将状态视作 $S=(p_1,p_2,\cdots,p_l)$,其中 $p_1<p_2<\cdots<p_l$,表示权值为 $\sum\limits_{i=l}^r a_{p_i}$ 的一组解。初始解是 $(1,2,\cdots,l)$。
钦定转移的拓扑序。我们找到最小的 $i$ 使得 $p_i<p_{i+1}$ 并枚举 $\delta\in[1,p_{i+1}-p_i)$ 令 $p_i\gets p_i+\delta$ 作为 $\text{trans}$,易证最优性、覆盖性、唯一性满足。由于 $|\text{trans}(S)|=O(n)$,复杂度 $O(nk\log k)$ 无法接受。
套路地考察转移图的形态为外向多叉树,对其做左儿子右兄弟优化,转化为外向二叉树。
对应到状态设计上,可以将状态改为 $(w,i,p_i,p_{i+1})$,其中 $w$ 为当前解权值,且我们钦定 $p_1\sim p_{i-1}$ 未移动。在二叉树上的转移为:
- 左儿子:$(w,i,p_i,p_{i+1})\to(w-a_{i-1}+a_i,i-1,i,p_i)$。要求 $p_i>i$。
- 右兄弟:$(w,i,p_i,p_{i+1})\to(w+a_{p_i+1}-a_{p_i},i,p_i+1,p_{i+1})$。要求 $p_i<p_{i+1}$。
可以说明转移图的等效性,进而使用算法 2 解决 $l=r$ 的情形。
考虑一般情形。直观的想法是使用算法 3,将所有 $(w,i,i,n+1)$ 入堆,但初始化代价不可接受。
观察算法 3 的本质是将外向树森林的根入堆。不妨建一个超级源点,连向所有 $(w,i,i,n+1)$,并对超级源点的儿子做左儿子右兄弟优化。这样仍可以用算法 2 解决问题,且复杂度正确。注意实现时要在状态中再加一个维度,表示节点是否为虚点。
至此,我们通过套两个 Shopping Plans Trick 的方法解决了此问题,复杂度 $O(\sum|S_i|\log|S_i|+n\log n+k\log k)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
const i64 inf = 1e18;
int n, m, k;
struct box {
using state = tuple<i64, int, int, int, int>; // (w, i, p_i, p_{i+1}, type)
priority_queue<state, vector<state>, greater<state>> q;
int l, r, n;
vector<i64> a, sol;
box() : l(-1), r(-1) {sol.emplace_back(-1);}
i64 operator[] (int k) const {return k >= (int)sol.size() ? -1 : sol[k];}
void add(i64 x) {a.emplace_back(x);}
void init(int _l, int _r) {
l = _l, r = _r, n = a.size();
if (l > r || l > n) return;
sort(a.begin(), a.end());
q.emplace(accumulate(a.begin(), a.begin() + l, 0LL), l-1, l-1, n, 1);
}
i64 kth(int k) {
while ((int)sol.size() <= k && !q.empty()) {
auto [w, i, pi, nxt, t] = q.top(); q.pop();
sol.emplace_back(w);
if (t && i+1 < r && i+1 < n) q.emplace(w + a[i+1], i+1, i+1, n, 1);
if (i > 0 && pi > i) q.emplace(w - a[i-1] + a[i], i-1, i, pi, 0);
if (i >= 0 && pi+1 < nxt) q.emplace(w - a[pi] + a[pi+1], i, pi+1, nxt, 0);
}
return this->operator[](k);
}
} a[N];
i64 delta(box& b) {return b[2] == -1 ? inf : b[2] - b[1];}
using state = tuple<i64, int, int>; // (w, i, p_i)
priority_queue<state, vector<state>, greater<state>> q;
void _main() {
cin >> n >> m >> k;
for (int i = 1, t, c; i <= n; i++) cin >> t >> c, a[t].add(c);
i64 sum = 0;
for (int i = 1, l, r; i <= m; i++) {
cin >> l >> r, a[i].init(l, r), a[i].kth(2);
if (a[i][1] == -1) {
while (k--) cout << -1 << '\n';
return;
}
sum += a[i][1];
}
cout << sum << '\n';
sort(a + 1, a + m + 1, [](box& a, box& b) -> bool {
return delta(a) < delta(b);
});
if (delta(a[1]) != inf) q.emplace(sum + delta(a[1]), 1, 2);
while (--k) {
if (q.empty()) {
cout << -1 << '\n'; continue;
}
auto [w, i, pi] = q.top(); q.pop();
cout << w << '\n';
if (a[i].kth(pi+1) != -1) q.emplace(w + a[i][pi+1] - a[i][pi], i, pi+1);
if (i < m && delta(a[i+1]) != inf) {
q.emplace(w + delta(a[i+1]), i+1, 2);
if (pi == 2) q.emplace(w - delta(a[i]) + delta(a[i+1]), i+1, 2);
}
}
}
```
:::::
## [P2048 [NOI2010] 超级钢琴](https://www.luogu.com.cn/problem/P2048)
> 给定长为 $n$ 的序列 $a_i$ 和正整数 $L,R$。对区间 $[l,r]$ 满足 $r-l+1\in[L,R]$,将 $\sum\limits_{i=l}^r a_i$ 作为一组解。求前 $k$ 大解的和,保证有解。
>
> $n,k\le5\times10^5$,2 秒,500 MB。
:::::success[题解]
记 $s_i$ 为 $a_i$ 的前缀和。合法区间 $(l,r]$ 的取值被刻画为 $s_r-s_l$,且 $r-l\in[L,R]\implies l\in[r-R,r-L]$。
构造状态 $S=(w,l_{\min},l_{\max},r)$,$w$ 是当前状态的最优子段和,即 $w=s_r-\min\limits_{l\in[l_{\min},l_{\max}]}s_l$。
设 $p$ 为 $s_i$ 中 $[l_{\min},l_{\max}]$ 区间 $\min$ 的下标。我们将区间分裂成 $[l_{\min},p)$ 和 $(p,l_{\max}]$ 进行转移:
$$
S\to\left(s_r-\min_{l\in[l_{\min},p)}s_l,l_{\min},p-1,r\right)\\
S\to\left(s_r-\min_{l\in(p,l_{\max}]}s_l,p+1,l_{\max},r\right)
$$
最优性显然满足。下面考察转移图的形态,从而说明覆盖性和唯一性。
考察初始状态 $S_r=(w,r-R,r-L,r)$,上述转移的实质是,对 $s_{r-R}\sim s_{r-L}$ 不断从区间 $\min$ 处断开递归。从而转移图是以 $s_{r-R}\sim s_{r-L}$ 的小根笛卡尔树,则转移图恰为以 $S_r$ 为根的外向树。
进一步,整个转移图的形态是以 $S_1\sim S_n$ 为根的外向树森林,每棵树都是 $s_i$ 的某个特定区间的小根笛卡尔树。 这满足广义覆盖性,可以使用算法 3 解决。
ST 表优化 $p$ 的查找,复杂度 $O(n\log n+k\log k)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 5e5 + 5;
int n, k, L, R, a[N];
using node = pair<int, int>;
node st[20][N];
node ask(int l, int r) {
int k = lg(r - l + 1);
return min(st[k][l], st[k][r - (1<<k) + 1]);
}
using state = tuple<int, int, int, int>; // (w, l_min, l_max, r)
priority_queue<state> q;
void _main() {
cin >> n >> k >> L >> R;
for (int i = 1; i <= n; i++) cin >> a[i], a[i] += a[i - 1];
for (int i = 0; i <= n; i++) st[0][i] = {a[i], i};
for (int i = 1; (1 << i) <= n; i++)
for (int j = 0; j <= n; j++)
st[i][j] = min(st[i-1][j], st[i-1][j + (1<<(i-1))]);
for (int r = L; r <= n; r++) {
int lo = max(0, r - R), hi = r - L;
q.emplace(a[r] - ask(lo, hi).fi, lo, hi, r);
}
i64 res = 0;
while (k--) {
auto [w, lo, hi, r] = q.top();
q.pop(), res += w;
int p = ask(lo, hi).se;
if (lo < p) q.emplace(a[r] - ask(lo, p-1).fi, lo, p-1, r);
if (p < hi) q.emplace(a[r] - ask(p+1, hi).fi, p+1, hi, r);
}
cout << res;
}
```
:::::
## [P8316 [CQOI2016] 伪光滑数 加强版](https://www.luogu.com.cn/problem/P8316)
> 对 $m>1$,设其质因数分解为 $m=\prod p_i^{\alpha_i}$,记 $q=\sum\alpha_i$,$p$ 为 $m$ 的最大质因子。若 $p^q\le n\land p\le397$,则称 $m$ 为伪光滑数。
>
> 给定 $n,k$,求第 $k$ 大的伪光滑数。保证有解。
>
> $n\le10^{11}$,1 秒,256 MB。
:::::success[题解]
对于伪光滑数 $m=\prod p_i^{\alpha_i}$,设 $p$ 为最大质因子,$q$ 为指数和,则 $p^q\le n$。显然将 $m$ 的所有质因子都替换为 $p$,所得数字 $m_{\max}=p^q\le n$。
这启发我们将 $m_{\max}=p^q$ 作为初始解。对于任意伪光滑数 $m$,必能找到唯一的 $m_{\max}$,使得将其中的 $c$ 个 $p$ 替换为更小质因子所得,其中替换次数 $c<q$。
套用 Shopping Plans Trick 的算法 3。初始枚举所有 $p^q\le n$,将其入堆,广义覆盖性满足。
考虑构造转移。钦定转移的拓扑序,规定替换的质因子单调不降。直观转移可以设计为当前所有替换方案,但 $|\text{trans}(S)|$ 无法接受。
记 $\text{prime}$ 为 $[2,397]$ 的质数表。套路地进行左儿子右兄弟优化,得到如下状态设计:
- 当前伪光滑数的数值为 $m$。
- 最大质因子的在质数表中的下标为 $p$。
- 当前需要决策,是否将 $\text{prime}_p$ 因子替换为 $\text{prime}_i$ 因子。
- 已经完成 $\text{cnt}$ 次替换。
- 最多允许 $\text{lim}$ 次替换,即初始解的 $q-1$。
对 $S=(m,p,i,\text{cnt},\text{lim})$,构造如下转移:
- 若 $\text{cnt}=0$,未进行过替换,转移 $S\to\left(\dfrac{m}{\text{prime}_p}\times\text{prime}_{p-1},p,i-1,1,\text{lim}\right)$。
- 若 $\text{cnt}>0$,则有
- 左儿子:$S\to\left(\dfrac{m}{\text{prime}_i}\times\text{prime}_{i-1},p,i-1,\text{cnt},\text{lim}\right)$。
- 右兄弟:$S\to\left(\dfrac{m}{\text{prime}_p}\times\text{prime}_{i},p,i,\text{cnt}+1,\text{lim}\right)$。要求 $\text{cnt}<\text{lim}$。
容易自行验证覆盖性、最优性、唯一性满足。复杂度瓶颈 $O(k\log k)$。
:::::
:::::info[代码]
```cpp line-numbers
const int P[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47,
53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127,
131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197,
199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277,
281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367,
373, 379, 383, 389, 397};
i64 n, k;
using state = tuple<i64, int, int, int, int>; // (m, p, i, cnt, lim)
priority_queue<state> q;
void _main() {
cin >> n >> k;
for (int x = 0; x < 78; x++)
for (i64 cur = P[x], c = 1; cur <= n; cur *= P[x], c++)
q.emplace(cur, x, x, 0, c - 1);
while (k--) {
auto [m, p, i, cnt, lim] = q.top(); q.pop();
if (k == 0) return cout << m, void();
if (cnt == 0) {
if (lim > 0 && i > 0) q.emplace(m / P[p] * P[p-1], p, i-1, 1, lim);
} else {
if (i > 0) q.emplace(m / P[i] * P[i-1], p, i-1, cnt, lim);
if (cnt < lim) q.emplace(m / P[p] * P[i], p, i, cnt+1, lim);
}
}
}
```
:::::
## [P10191 [USACO24FEB] Test Tubes S](https://www.luogu.com.cn/problem/P10191)
> 给你两个栈 $A,B$ 和一个空栈 $C$。初始时,$A,B$ 栈中存有一段长为 $n$ 的颜色序列,颜色只有两种。
>
> 一次操作可以将一个非空栈栈顶的颜色段弹出,加入另一个栈。你的目标是最终 $A,B$ 栈中只有一种颜色,且 $C$ 为空。
>
> 最小化操作次数,并构造一组操作方案。
>
> 多测,$T\le10$,$n\le10^5$,2 秒,256 MB。
:::::success[题解]
思路叙述起来是自然的,但是很难想。
首先,我们发现颜色段是一起操作的,于是将一个颜色段缩成一个点。同时当入栈的颜色与栈顶颜色相同时,我们将这两个颜色也缩成一点。
接下来,我们给出两个关键观察:
1. 无论何时,$C$ 的大小不超过 $1$。
2. 当 $A,B$ 栈顶相同时,应当用较大的栈向较小的栈移动。
先说明第一个观察。由于目标状态中 $C$ 为空,向 $C$ 移动必然支付额外代价。
考虑 $A,B$ 的栈顶为 $a,b$,若 $a=b$,此时直接做一个 $A\to B$ 或者 $B\to A$ 的移动,优于 $A\to C,B\to C$ 这样的操作序列。
若 $a\ne b$ 且 $C$ 为空,我们必须选择一种颜色放入 $C$,否则会卡死。反之,若 $C$ 中有一种颜色,我们一定选择与 $C$ 栈顶颜色相同的,这样会发生颜色合并,操作次数减少。
再说明第二个观察。不妨设 $|A|>|B|$。考虑反证,如果我们是从 $B$ 往 $A$ 转移,极端情况 $|B|=1$,继续执行策略的结果是直接毁灭 $|B|=1$ 的情况。想要恢复这个情况,就必须借助 $C$ 来转移。
反之,如果我们从 $A$ 往 $B$ 转移,仍考虑极端情况 $|B|=1$,继续执行策略始终保留了 $|B|=1$ 的优秀情况。
基于上述观察,本题的策略已经十分显然。在实现时,我们维护三个栈 $A,B,C$,进行循环并分类讨论:
- 若 $A$ 为空:转移 $B\to A$;
- 若 $B$ 为空:转移 $A\to B$;
- 若 $A,B$ 栈顶相同:较大的栈向较小的转移;
- 若 $A,B$ 栈顶不同:与 $C$ 栈顶相同的栈转移到 $C$。
循环终止条件只需任意满足以下三者之一:
- $A$ 为空且 $|B|=1$;
- $B$ 为空且 $|A|=1$;
- $|A|=1$ 且 $|B|=1$。
最后再讨论一下 $C$ 是否为空,如果不为空就再转移一次。
按 $C$ 栈顶颜色分为两类,做两次循环,取操作次数较小者即可,复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int k, opt;
using node = pair<int, int>;
stack<int> sta, stb;
vector<node> solve(int x) {
stack<int> a = sta, b = stb, c;
vector<node> vec;
#define mov(a, b) vec.emplace_back(a, b)
auto check = [&]() -> bool {
if (a.empty()) return b.size() == 1;
if (b.empty()) return a.size() == 1;
return a.size() == 1 && b.size() == 1 && a.top() != b.top();
};
while (!check()) {
if (a.empty()) {
a.emplace(b.top()), b.pop(), mov(2, 1);
} else if (b.empty()) {
b.emplace(a.top()), a.pop(), mov(1, 2);
} else if (a.top() == b.top()) {
if (a.size() >= b.size()) a.pop(), mov(1, 2);
else b.pop(), mov(2, 1);
} else {
if (c.empty()) c.emplace(x);
if (a.top() == c.top()) a.pop(), mov(1, 3);
else b.pop(), mov(2, 3);
}
}
if (!c.empty()) {
if (a.empty() || c.top() == a.top()) c.pop(), mov(3, 1);
else c.pop(), mov(3, 2);
} return vec;
}
void _main() {
cin >> k >> opt;
while (!sta.empty()) sta.pop();
while (!stb.empty()) stb.pop();
for (int i = 1; i <= k; i++) {
char ch; cin >> ch;
if (sta.empty() || ch - '0' != sta.top()) sta.emplace(ch ^ 48);
}
for (int i = 1; i <= k; i++) {
char ch; cin >> ch;
if (stb.empty() || ch - '0' != stb.top()) stb.emplace(ch ^ 48);
}
auto x = solve(1), y = solve(2);
if (x.size() > y.size()) x.swap(y);
cout << x.size() << '\n';
if (opt != 1) for (auto& i : x) cout << i << '\n';
}
```
:::::
## [P7115 [NOIP2020] 移球游戏](https://www.luogu.com.cn/problem/P7115)
> 现有 $n+1$ 个栈,$ 1\sim n$ 号栈中各有 $m$ 个数,$n+1$ 号栈初始为空。这 $n\times m$ 个数共有 $n$ 种,每种数恰好 $m$ 个。
>
> 一次操作将某个栈的栈顶弹出,并放入另一个栈中。栈的最大容量为 $m$。
>
> 你需要使用若干次操作,使得同种数字被放入同一个栈中。
>
> $n\le50$,$m\le400$,满分操作步数 $\le8.2\times10^5$,1 秒,512 MB。
::::::success[题解]
从 $n=2$ 入手考虑。观察大样例 `ball2`,我们给出如下策略:
::::info[样例 2 的移动策略]
初始局面:

我们的原则是,先将栈 $1$ 中的两种颜色分离,再将栈 $2$ 中的元素逐次加入。
为此,我们考虑将栈 $2$ 中的 $7$ 个元素先移动到栈 $3$。这样,栈 $1$ 中的 $7$ 个 $1$ 就能被放到栈 $2$,剩下的 $2$ 就被放到栈 $3$。


此时,来自栈 $1$ 的两种颜色已经在栈顶形成了两个颜色段。我们将两个颜色段放回栈 $1$,并将栈 $2,3$ 留出一个空栈。


这样,我们就可以将栈 $1$ 顶部的颜色段移动到空栈中:

如此操作后,我们成功分离了原本栈 $1$ 中的两种颜色。对于栈 $2$,只要顺次扫描一遍,放到对应的栈顶即可。

操作次数为 $87$。
::::
根据这个样例,我们实现了将两种颜色分离的操作。描述一下流程:
- 设满栈 $A,B$,空栈 $C$。计算栈 $A$ 中颜色 $1$ 的数目,记为 $a$。
- 将 $B$ 的栈顶 $a$ 个元素移动到 $C$,代价 $a$。
- 利用栈 $B,C$,将栈 $A$ 的两种颜色分到 $B,C$ 中,代价 $m$。
- 将栈 $B,C$ 顶部的颜色段移动到栈 $A$,代价 $m$。
- 将栈 $C$ 的剩余元素移到栈 $B$,代价 $a$。
- 将栈 $A$ 顶部的颜色段移到栈 $C$,代价 $m-a$。
- 顺序扫描栈 $B$,根据颜色分配到栈 $A,C$ 中,代价 $m$。
称这个操作为 $\text{OP}(A,B,C)$,代价为 $4m+a$。最坏 $a=m$ 时可以认为是 $5m$。
我们构造出的 $\text{OP}$ 事实上是这个题的核心操作,考虑如下算法:
对值域分治,每层分治维护若干栈,将所有数染成两种颜色,顺次扫描每个站,然后使用上面的做法分离,再对两个部分递归处理,直到 $l=r$ 终止。
分析一下复杂度,列出递归式 $T(n)=2T\left(\dfrac{n}{2}\right)+5mn$ 得 $T(n)=5mn\log n$。代入数据得 $T(n)<564386\le8.2\times10^5$,可以通过。
注意细节:分治时两种颜色可能不平衡,最后一步有可能导致栈的大小超过 $m$,需要特判一下。
::::::
:::::info[代码]
```cpp line-numbers
const int N = 205;
int n, m, id;
vector<pair<int, int>> vec;
vector<int> s[N];
void move(int u, int v) {
vec.emplace_back(u, v);
assert(!s[u].empty() && (int)s[v].size() < m);
s[v].emplace_back(s[u].back());
s[u].pop_back();
}
void OP(int A, int B, int C, int p) {
int a = 0;
for (int i : s[A]) if (i <= p) a++;
for (int i = 1; i <= a; i++) move(B, C);
while (!s[A].empty()) {
int u = s[A].back();
if (u <= p) move(A, B);
else move(A, C);
}
for (int i = 1; i <= a; i++) move(B, A);
for (int i = 1; i <= m - a; i++) move(C, A);
for (int i = 1; i <= a; i++) move(C, B);
for (int i = 1; i <= m - a; i++) move(A, C);
while (!s[B].empty()) {
int u = s[B].back();
if (u <= p) (int)s[A].size() < m ? move(B, A) : move(B, C);
else (int)s[C].size() < m ? move(B, C) : move(B, A);
}
}
void solve(int l, int r, vector<int> x) {
if (l == r) return;
int a = x[0], mid = (l + r) >> 1;
vector<int> xl, xr;
auto chk = [&](int u) -> bool {
if (s[u].empty()) return false;
set<int> st;
for (int i : s[u]) st.emplace(i <= mid ? 1 : 2);
if (st.size() >= 2) return true;
if (*st.begin() == 1) xl.emplace_back(u);
else xr.emplace_back(u);
return false;
};
for (int i = 1; i < (int)x.size(); i++) {
OP(a, x[i], id, mid);
if (!chk(a)) a = id;
else chk(id);
id = x[i];
}
if (s[a][0] <= mid) xl.emplace_back(a);
else xr.emplace_back(a);
solve(l, mid, xl), solve(mid + 1, r, xr);
}
void _main() {
cin >> n >> m; id = n + 1;
for (int i = 1; i <= n; i++)
for (int j = 1, x; j <= m; j++) {
cin >> x;
s[i].emplace_back(x);
}
vector<int> x;
for (int i = 1; i <= n; i++) x.emplace_back(i);
solve(1, n, x);
cout << vec.size() << '\n';
for (auto& i : vec) cout << i << '\n';
}
```
:::::
## [P8866 [NOIP2022] 喵了个喵](https://www.luogu.com.cn/problem/P8866)
> 给出长为 $m$ 的序列 $a_i$,表示牌堆。共有 $k$ 种牌,每种牌出现偶数次。初始时有 $n$ 个空栈,你每轮可以执行两种操作:
>
> 1. 选择栈 $s$,将牌堆顶的牌放入 $s$ 栈顶。若操作后栈顶上方两张牌相同,则两张牌被消去。
> 2. 选择栈 $s_1,s_2$,其中 $s_1\ne s_2$,若两个栈栈底卡牌相同,则两张牌被消去。
>
> 你的目标是将所有牌消去,构造方案,要求操作次数 $\in[m,2m]$。
>
> 多测,$\sum m\le2\times10^6$,$n\le300$,$k\in\{2n-2,2n-1\}$,1 秒,512 MB。
::::::::success[题解]
[这里](https://www.luogu.me/paste/ndgasfaz)是 Gemini 3.1 Pro 编写的一个小游戏,需要 `pygame` 库。同时,我们给出五组比较有启发性的样例:
```plain
1 3 2 4 2 3 4 1
1 2 3 4 5 2 3 4 5 1
1 3 2 4 5 2 1 5 4 3
1 3 2 4 5 2 2 1 5 2 4 3
1 3 2 4 5 4 4 1 2 5 4 3
```
:::::info[样例 1 的消除策略]
初始局面:

我们需要一个机械性的策略。
在这里,我们用栈 $1$ 来存放卡牌 $1,2$,用栈 $2$ 存放卡牌 $3,4$。当新加入一张牌时:
- 如果这张牌与某个栈的栈顶相同,执行操作一并消去;
- 如果这张牌与某个栈的栈底相同,将其加入栈 $3$ 后执行操作二并消去;
- 否则,直接加入对应栈。
例如下面这种情况,我们将 $2$ 加入栈 $1$,执行操作一:

完成这个操作以后,我们面临下图所示的局面。此时将 $3$ 加入栈 $3$,并对栈 $2,3$ 做操作二。

重复上述流程,至牌堆为空。
:::::
根据上述消除策略,我们得到了 $k=2n-2$ 的做法,留一个空栈,剩余的 $n-1$ 个栈内只放两张牌,模拟即可。可以获得 [15 分](https://www.luogu.com.cn/record/268858946)。
考虑 $k=2n-1$。当所有普通栈都塞满,而此时发来的又是一张没有匹配的新牌时,套用上述讨论很可能陷入死局。
注意到本题中我们并不需要在线决策,而是可以看到牌堆的全貌。那么记第一个将会出现的栈底牌为 $x$,压在它上面的牌为 $y$。为了解决这种局面,我们希望消去 $x$,那么就需要讨论是先消去 $y$,还是直接绕过 $y$。
:::::info[样例 3 的消除策略]
初始局面:

按照平凡策略得到的局面:

此时我们有 $x=1,y=2$。观察牌堆,在 $1$ 出现之前,$2$ 只出现了一次。于是我们有如下操作:
- 将 $5$ 放入栈 $3$;
- 用发下来的 $2$ 消去栈 $1$ 顶部的 $2$;
- 用发下来的 $1$ 消去栈 $1$ 顶部的 $1$。
操作结束后的局面为:

此时我们制造了一个空栈,可以继续用平凡策略消除了。
:::::
:::::info[样例 4 的消除策略]
初始局面不放了,按照平凡策略消去后的局面为:

此时仍有 $x=1,y=2$。但是再按样例 3 的做法是错误的。如果将 $5$ 放入栈 $3$,两个 $2$ 下来消除后,还会剩下一个 $2$:

这个局面已经无解。
考虑问题出现在哪里,发现这里 $2$ 出现了**偶数次**!这里的正解是:
- 将 $5$ 直接放入栈 $1$;
- 偶数个 $2$ 任选一个栈消掉
- 然后将 $1$ 放入栈 $3$,对栈 $1,3$ 执行操作二。
示例图:

:::::
观察样例 $3,4$ 消除策略的异同点,我们发现:
- 当 $y$ 出现奇数次时,多出来的牌可以直接放入辅助栈,被堵住的栈可以用 $y$ 来打通;
- 当 $y$ 出现偶数次时,新牌要叠在 $y$ 上面,然后利用空栈消除栈底。
上述策略可能存在一个问题,就是 $x,y$ 之间混入其他牌。让我们来看一下样例 5:
:::::info[样例 5 的消除策略]
快进到这个局面:

此时 $x=1,y=2$,但是我们发现 $5\to1$ 的过程中有一堆 $4$ 的干扰。
仔细思考一下,如果 $4$ 出现奇数次,放入栈 $2$ 消除以后,栈 $2$ 中只有一个 $3$,不会影响。
而如果出现偶数次,我们仍然可以在栈 $2$ 中消除,消除后的局面:
(这里由于 $y$ 出现偶数次,将 $5$ 放入栈 $1$)

此时我们再使用样例 $3,4$ 的消除方法即可。
:::::
观察样例 5 的消除策略,中间穿插的其他栈顶牌,直接按照其归属消除即可,不会影响我们对目标栈的策略。
分析到这里,本题的贪心构造已经显然了。我们先执行平凡策略,遇到特殊局面时,找到 $x$ 和 $y$,然后按照 $y$ 出现次数的奇偶性分类讨论。如果中间有其他栈顶牌干扰,就使用平凡策略消去。
一共只有 $m$ 张牌,只要操作二是有效的,操作次数的上限不会超过 $2m$。所以不用卡常,模拟这个流程即可。
接下来是大模拟环节,我们需要考虑一下代码实现:
- 维护每个栈的内部情况、每张卡牌属于哪个栈。
- 找 $x,y$ 可以直接暴力,因为外层指针的移动次数是 $O(m)$ 的。
- 找大小 $<2$ 的栈不能暴力,否则复杂度退化为 $O(nm)$。我们需要维护一个队列,维护所有可能有空位的普通栈。使用懒惰删除策略,每次出栈同步修改这个队列,入栈则忽略修改,使用时再判断合法性。
- 注意分类讨论各种情况。
正确实现的复杂度为 $O(n+m)$。
::::::::
:::::info[代码]
```cpp line-numbers
const int N = 605, M = 2e6 + 5;
int n, m, k, a[M];
deque<int> q[N];
vector<tuple<int, int, int>> vec;
#define op1(s) vec.emplace_back(1, s, -1)
#define op2(s1, s2) vec.emplace_back(2, s1, s2)
void out() {
cout << vec.size() << '\n';
for (auto [op, x, y] : vec) {
if (op == 1) cout << op << ' ' << x << '\n';
else cout << op << ' ' << x << ' ' << y << '\n';
}
}
void sub1() {
for (int i = 1; i <= m; i++) {
int x = (a[i] + 1) / 2;
if (!q[x].empty() && q[x].back() == a[i]) op1(x), q[x].pop_back();
else if (!q[x].empty() && q[x].front() == a[i]) op1(n), op2(x, n), q[x].pop_front();
else op1(x), q[x].emplace_back(a[i]);
} out();
}
int bel[N];
void sub2() {
fill(bel + 1, bel + k + 1, -1);
int h = n; // 辅助栈
queue<int> u;
for (int i = 1; i < n; i++) u.emplace(i);
auto get = [&](int b) -> int {
while (!u.empty()) {
int x = u.front();
if (x != h && q[x].size() < 2 && x != b) return x;
u.pop();
} return -1;
};
for (int i = 1; i <= m; i++) {
int c = a[i];
if (bel[c] != -1) {
if (q[bel[c]].back() == c) op1(bel[c]), q[bel[c]].pop_back();
else op1(h), op2(h, bel[c]), q[bel[c]].pop_front();
u.emplace(bel[c]), bel[c] = -1;
continue;
}
int tar = get(-1);
if (tar != -1) {
op1(tar), q[tar].emplace_back(c), bel[c] = tar;
continue;
}
int j = i + 1;
for (; j <= m; j++) {
if (a[j] == c) break;
if (bel[a[j]] != -1 && q[bel[a[j]]].front() == a[j]) break;
}
if (a[j] == c) {
op1(h), q[h].emplace_back(c), bel[c] = h;
for (int k = i + 1; k < j; k++) {
if (bel[a[k]] != -1) {
int& s = bel[a[k]];
op1(s), q[s].pop_back(), u.emplace(s), s = -1;
} else {
int s = -1;
while (!u.empty()) {
s = u.front();
if (s != h && q[s].size() < 2) break;
else u.pop();
}
op1(s), q[s].emplace_back(a[k]), bel[a[k]] = s;
}
}
op1(h), q[h].pop_back(), bel[c] = -1;
} else {
int y = a[j], z = q[bel[y]].back(), cnt = 0;
for (int k = i + 1; k < j; k++) cnt += a[k] == z;
if (cnt & 1) {
op1(h), q[h].emplace_back(c), bel[c] = h;
for (int k = i + 1; k < j; k++) {
int x = a[k];
if (x == z) {
op1(bel[y]);
if (bel[x] != -1) q[bel[y]].pop_back(), bel[x] = -1;
else q[bel[y]].emplace_back(x), bel[x] = bel[y];
} else if (bel[x] != -1) {
int& s = bel[x];
op1(s), q[s].pop_back(), u.emplace(s), s = -1;
} else {
int s = get(bel[y]);
op1(s), q[s].emplace_back(x), bel[x] = s;
}
}
int s = bel[y];
op1(s), q[s].pop_back();
u.emplace(h), bel[y] = -1, h = s;
} else {
op1(bel[y]), q[bel[y]].emplace_back(c), bel[c] = bel[y];
for (int k = i + 1; k < j; k++) {
int x = a[k];
if (x == z) {
op1(h);
if (bel[x] == h) q[h].pop_back(), bel[x] = bel[y];
else q[h].emplace_back(x), bel[x] = h;
} else if (bel[x] != -1) {
int& s = bel[x];
op1(s), q[s].pop_back(), u.emplace(s), s = -1;
} else {
int s = get(bel[y]);
op1(s), q[s].emplace_back(x), bel[x] = s;
}
}
op1(h), q[h].emplace_back(y), op2(bel[y], h);
q[bel[y]].pop_front(), q[h].pop_front(), bel[y] = -1;
}
}
i = j;
} out();
}
void _main() {
cin >> n >> m >> k, vec.clear();
for (int i = 1; i <= n; i++) q[i].clear();
for (int i = 1; i <= m; i++) cin >> a[i];
if (k == 2 * n - 2) sub1();
else sub2();
}
```
:::::
## [P1861 星之器](https://www.luogu.com.cn/problem/P1861)
> 给出一个 $n\times m$ 的矩阵 $a_{i,j}$,表示格子 $(i,j)$ 上有 $a_{i,j}$ 个物体。
>
> 一次操作选择同一行或同一列的两个不相邻格子,在格子中各取一个物体,向中心移动 $1$ 格,并将两个格子间的距离作为得分。要求操作时格子上必须有物体。
>
> 再给出目标矩阵 $b_{i,j}$。你需要通过若干次操作将 $a$ 变成 $b$,最大化得分并输出。数据保证有解。
>
> $ n,m \le 200$,$a_{i,j},b_{i,j} \le 10^3$,1 秒,125 MB。
:::::success[题解]
记所有可能的局面构成的集合为$S$。考虑构造一个 $S\to\mathbb{N}$ 的映射 $\varphi$,使得 $\varphi(a)-\varphi(b)$ 为答案。
假设一次操作后状态 $a$ 变为 $a'$,我们希望 $\varphi(a)-\varphi(a')$ 是得分的变化量。$\varphi$ 的性质与物理中的势能类似,因此我们称 $\varphi$ 是状态的**势能函数**。 初势能减末势能即为答案。
将状态的势能拆成所有物体的势能之和。注意到两维是对称的,可以直接构造势能函数 $\phi(x)$ 表示:单维度上位于第 $x$ 个位置的一个物体的势能。这样
$$
\varphi(a)=\sum_{i=1}^n\sum_{j=1}^m a_{i,j}(\phi(i)+\phi(j))
$$
考察 $\phi$ 的性质。想象数轴上两个位于 $x_1,x_2$ 的物体,且 $x_1+1<x_2$。原势能为 $\phi(x_1)+\phi(x_2)$,一次操作后得分增加 $x_2-x_1-1$ 且势能变为 $\phi(x_1+1)+\phi(x_2-1)$,列出式子
$$
\phi(x_1)+\phi(x_2)-\phi(x_1+1)-\phi(x_2-1)=x_2-x_1-1
$$
整理得
$$
\phi(x_1+1)-\phi(x_1)-x_1=\phi(x_2+1)-\phi(x_2)-x_2
$$
只要 $\phi(x+1)-\phi(x)-x$ 恒为常数 $C$。移项得
$$
\phi(x+1)-\phi(x)=x+C
$$
这是一个差分方程。观察到 $x+C$ 是关于 $x$ 的一次式,这表明,$\phi(x)$ 可能是一个关于 $x$ 的二次函数。
使用待定系数法,设 $\phi(x)=ax^2+bx$,代入并对比系数
$$
a(x+1)^2+b(x+1)-ax^2-bx=x+C\\
2ax+a+b=x+C\\
\implies\left\{\begin{matrix}
2a=1 \\
a+b=C
\end{matrix}\right.
$$
解得 $a=\frac{1}{2},b=C-\frac{1}{2}$,故 $\phi(x)=\frac{1}{2}x^2+(C-\frac{1}{2})x$。取 $C=\frac{1}{2}$ 得 $\phi(x)=\frac{1}{2}x^2$,将其作为构造即可。
代码是简单的,复杂度 $O(nm)$。
**启示:答案只与初末状态有关的确定性问题,考虑势能分析。**
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
int n, m;
void _main() {
cin >> n >> m;
int p = 0;
for (int i = 1; i <= n; i++)
for (int j = 1, x; j <= m; j++)
cin >> x, p += x * (i * i + j * j);
for (int i = 1; i <= n; i++)
for (int j = 1, x; j <= m; j++)
cin >> x, p -= x * (i * i + j * j);
cout << p / 2;
}
```
:::::
## [QOJ14950 Relay Jump](https://qoj.ac/problem/14950)
> 二维平面上有 $n$ 个点 $(x_i,y_i)$。对第 $i$ 个点进行操作时,可能出现如下两种情况:
>
> - 选择点 $(x_j,y_j)$ 满足 $i\ne j$,将第 $i$ 个点的坐标关于 $(x_j,y_j)$ 作对称,并对第 $j$ 个点进行操作。
> - 坐标不变,终止所有操作。
>
> 给定 $n$ 个点在操作后的终止位置 $(x_1',y_1')\sim(x_n',y_n')$。已知初始时对第 $s$ 个点进行操作,设终止操作的点的编号为 $t$。
>
> 保证 $(x_i,y_i)$ 互不相同,$(x_i',y_i')$ 互不相同。操作的具体过程未知,你需要根据给定的信息求出 $t$。
>
> $n\le10^5$,1 秒,1024 MB。
:::::success[题解]
注意到答案与初状态和末状态强相关,考虑势能分析。对于本题,我们设法构造势能函数 $\varphi$ 使得**势能守恒**,对初末状态列守恒的方程来求解 $t$。
设第 $i$ 个点的位置向量 $\vec{P_i}=(x_i,y_i)$。对 $i$ 进行操作时,若选择 $j$,则 $\vec{P_i}$ 的新位置满足
$$
\vec{P_i'}=2\vec{P_j}-\vec{P_i}
$$
过程中,系统重心的偏移量为
$$
\sum_{i=1}^n\vec{P'_i}-\sum_{i=1}^n\vec{P_i}=\vec{P'_i}-\vec{P_i}=2\vec{P_j}-2\vec{P_i}
$$
且当前的激活位置由 $i$ 变成了 $j$。记 $i$ 为当前的激活位置,取如下构造
$$
\varphi(S)=2\vec{P_i}-\sum_{i=1}^n\vec{P_i}
$$
变换 $i\to j$ 后的势能为
$$
\begin{aligned}
\varphi(S')&=2\vec{P'_j}-\sum_{i=1}^n\vec{P'_i}\\
&=2\vec{P_j}-\left(\sum_{i=1}^n\vec{P_i}+2\vec{P_j}-2\vec{P_i}\right)\\
&=2\vec{P_i}-\sum_{i=1}^n\vec{P_i}=\varphi(S)
\end{aligned}
$$
势能守恒成立。记 $\vec{Q_i}=(x_i',y_i')$,对初末状态列势能守恒的方程
$$
2\vec{P_s}-\sum_{i=1}^n\vec{P_i}=2\vec{Q_t}-\sum_{i=1}^n\vec{Q_i}
$$
容易得到 $\vec{Q_t}$,直接在数组中查找其所在位置即可。复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
using node = pair<i64, i64>;
node operator+ (const node& a, const node& b)
{return {a.fi + b.fi, a.se + b.se};}
node operator- (const node& a, const node& b)
{return {a.fi - b.fi, a.se - b.se};}
node operator/ (const node& a, i64 b) {return {a.fi / b, a.se / b};}
int n, k;
node p[N], q[N];
void _main() {
cin >> n >> k;
node a, b;
for (int i = 1; i <= n; i++) {
cin >> p[i] >> q[i];
a = a + p[i], b = b + q[i];
}
node x = p[k] - (a - b) / 2;
cout << find(q + 1, q + n + 1, x) - q;
}
```
:::::
## [P6776 [NOI2020] 超现实树](https://www.luogu.com.cn/problem/P6776)
> 以下所指的树,均为非空、有根、无标号、区分左右儿子的二叉树。
>
> 对于树 $T_1$,称其生长得到 $T_2$,当且仅当将 $T_1$ 的若干叶子替换为任意树后得到 $T_2$。
>
> 给出树的集合 $\mathscr{T}$,定义 $\operatorname{grow}(\mathscr{T})$ 为 $\mathscr{T}$ 中的树生长所得的树的集合。判定 $\operatorname{grow}(\mathscr{T})$ 是否包含了几乎所有的树。也即,不存在无穷多棵树未被包含。
>
> 记 $\sum n$ 为节点数之和。多测,$\sum n\le2\times10^6$,1 秒,512 MB。
:::::success[题解]
考察合法的树的形态。我们注意到,下图所示的树是无效的:

原因是,这种树无法生成下面这种形态的树:

其中 $T$ 可以是任意树。
我们将所有无效树丢掉,有用的树其实只会有四种形态:

如果这四种形态的树都存在,那么这一层的树可以被生成。
考虑递归判定。我们将四种情形对应的子树抽取出来,作为新的集合 $\mathscr{T}$ 判断。如果四种情况都合法,那么原集合就是合法的。
递归的终止条件是 $\mathscr{T}=\varnothing$ 或者 $\mathscr{T}$ 包含单点。
分析一下复杂度,四种情形几乎无交,唯一有交的是

这种形态的树,可以忽略掉。那么每层递归的总代价是 $|\mathscr{T}|$ 的,复杂度就是 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e6 + 5;
int m, l[N], r[N];
bool solve(vector<int> s) {
if (s.empty()) return false;
for (int u : s)
if (!l[u] && !r[u]) return true;
vector<int> s1, s2, s3, s4;
for (int u : s) {
if (!l[u] && r[u]) s1.emplace_back(r[u]);
if (!r[u] && l[u]) s2.emplace_back(l[u]);
if (l[u] && !l[l[u]] && !r[l[u]] && r[u]) s3.emplace_back(r[u]);
if (r[u] && !r[r[u]] && !l[r[u]] && l[u]) s4.emplace_back(l[u]);
}
return solve(s1) && solve(s2) && solve(s3) && solve(s4);
}
void _main() {
cin >> m;
vector<int> rt;
int off = 0;
for (int i = 1, k; i <= m; i++) {
cin >> k;
for (int u = 1, x, y; u <= k; u++) {
cin >> x >> y;
l[u+off] = x ? x+off : 0, r[u+off] = y ? y+off : 0;
}
rt.emplace_back(1+off), off += k;
}
cout << (solve(rt) ? "Almost Complete" : "No") << '\n';
}
```
:::::
## [CF1270G Subset with Zero Sum](https://www.luogu.com.cn/problem/CF1270G)
> 给出长为 $n$ 的序列 $a_i$,保证 $i-n\le a_i\le i-1$。求出一个非空子集,使得元素之和为 $0$,输出构造。
>
> 多测,$\sum n\le10^6$,2 秒,250 MB。
:::::success[题解]
将条件转化为 $1\le i-a_i\le n$。
我们充分发扬人类智慧,连边 $i\to i-a_i$ 形成一个内向基环树森林。考察其中一个环,设环上的节点集合为 $S$,那么
$$
\sum_{i\in S}i=\sum_{i\in S}(i-a_i)\implies\sum_{i\in S}a_i=0
$$
拓扑排序找环即可,复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e6 + 5;
int n, a[N], deg[N], vis[N];
vector<int> e[N];
void _main() {
cin >> n;
fill(vis + 1, vis + n + 1, 0), fill(deg + 1, deg + n + 1, 0);
for (int i = 1; i <= n; i++) e[i].clear();
for (int i = 1; i <= n; i++) {
cin >> a[i];
e[i].emplace_back(i - a[i]), deg[i - a[i]]++;
}
queue<int> q;
for (int i = 1; i <= n; i++) if (deg[i] == 0) q.emplace(i), vis[i] = true;
while (!q.empty()) {
int u = q.front(); q.pop();
for (int v : e[u]) if (--deg[v] == 0) q.emplace(v), vis[v] = true;
}
vector<int> vec;
for (int i = 1; i <= n; i++) if (!vis[i]) vec.emplace_back(i);
cout << vec.size() << '\n';
for (int i : vec) cout << i << ' ';
cout << '\n';
}
```
:::::
## [CF1844G Tree Weights](https://www.luogu.com.cn/problem/CF1844G)
> 给出一棵 $n$ 个节点的无根树,边带权且为 $[1,10^{12}]$ 中的整数,初始无法得知边权。给出 $a_i=\text{DIS}(i,i+1)$,即树上两点间距离。构造一组合法的边权,或报告无解。
>
> $n\le10^5$,5 秒,250 MB。
:::::success[题解]
不妨任意定根,将 $1$ 作为根。记 $d_i=\text{DIS}(1,i),p(i)=\text{LCA}(i,i+1)$,则题目给出 $n-1$ 个方程
$$
d_i+d_{i+1}-2\times d_{p(i)}=a_i
$$
我们充分发扬人类智慧,将等式两边同时对 $2$ 取模:
$$
d_i+d_{i+1}\equiv a_i\pmod2
$$
由 $d_1=0$ 可以递推出所有 $d_i\bmod2$。继续使用人类智慧,将方程两边对 $4$ 取模:
$$
d_i+d_{i+1}-2(d_{p(i)}\bmod2)\equiv a_i\pmod4
$$
由于 $d_{p(i)}\bmod2$ 在上一轮递推出来,因此我们可以递推出所有 $d_i\bmod4$。
一般地,考虑迭代 $k$ 轮:
$$
d_i+d_{i+1}-2(d_{p(i)}\bmod2^{k-1})\equiv a_i\pmod{2^k}
$$
可以求出所有 $d_i\bmod2^k$。取 $k=60$ 可以直接还原出所有 $d_i$,边权将两端点作差即可,注意判无解。
复杂度 $O(n\log V)$。牛到家了。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, fa[N], sz[N], dep[N], son[N], top[N];
vector<pair<int, int>> e[N];
void dfs1(int u) {
sz[u] = 1;
for (auto [v, id] : e[u]) {
if (v == fa[u]) continue;
fa[v] = u, dep[v] = dep[u] + 1, dfs1(v), sz[u] += sz[v];
if (sz[v] > sz[son[u]]) son[u] = v;
}
}
void dfs2(int u, int t) {
top[u] = t;
if (son[u]) dfs2(son[u], t);
for (auto [v, id] : e[u]) if (v != fa[u] && v != son[u]) dfs2(v, v);
}
int lca(int u, int v) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
u = fa[top[u]];
} return dep[u] < dep[v] ? u : v;
}
i64 a[N], p[N], f[64][N], ans[N];
void dfs3(int u) {
for (auto [v, id] : e[u]) {
if (v == fa[u]) continue;
ans[id] = f[60][v] - f[60][u];
if (ans[id] <= 0 || ans[id] > 1e12) cout << -1, exit(0);
dfs3(v);
}
}
void _main() {
cin >> n;
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
e[u].emplace_back(v, i), e[v].emplace_back(u, i);
}
dfs1(1), dfs2(1, 1);
for (int i = 1; i < n; i++) p[i] = lca(i, i + 1);
for (int i = 1; i < n; i++) cin >> a[i];
for (int k = 1; k <= 60; k++) {
i64 mask = (1LL << k) - 1;
for (int i = 1; i < n; i++) {
f[k][i + 1] = a[i] - f[k][i] + 2 * f[k - 1][p[i]];
f[k][i + 1] &= mask;
}
}
dfs3(1);
for (int i = 1; i < n; i++) cout << ans[i] << '\n';
}
```
:::::
## [CF1054G New Road Network](https://www.luogu.com.cn/problem/CF1054G)
> 现有 $n$ 个点和 $m$ 个集合 $S_i$,构造一棵 $n$ 个点的树 $T$,使得 $\forall i\in[1,m],S_i$ 的导出子图连通。输出构造或报告无解。
>
> 多测,$\sum n,\sum m\le2\times10^3$,2 秒,250 MB。
:::::success[题解]
对集合 $S_i$,若 $S_i$ 在 $T$ 上连通,则 $S_i$ 的导出子图必然是一棵树,恰有 $|S_i|-1$ 条边。若导出子图分裂成森林,则边数严格小于 $|S_i|-1$。
设所有 $S_i$ 导出子图的边数和为 $f(T)$,则 $f(T)\le\sum\limits_{i=1}^m(|S_i|-1)$,当且仅当所有集合均连通时等号成立。
另一方面,记 $A_u=\{i\mid u\in S_i\}$,枚举树边 $(u,v)$,则 $(u,v)$ 对 $f(T)$ 的贡献为 $|A_u\cap A_v|$。只要最大化 $\sum\limits_{(u,v)}|A_u\cap A_v|$ 并判定这个值是否取等,即可得到构造。
取完全图 $K_n$,将边 $(u,v)$ 的边权设为 $|A_u\cap A_v|$,求最大生成树即可。$A_u$ 可以使用 bitset 优化,总复杂度 $O\left(\dfrac{n^3}{w}\right)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2005;
int n, m, fa[N];
int find(int x) {return x == fa[x] ? x : fa[x] = find(fa[x]);}
char s[N];
bitset<N> a[N];
struct edge {
int u, v, w;
bool operator< (const edge& o) const {return w > o.w;}
} e[N*N];
void _main() {
cin >> n >> m; iota(fa + 1, fa + n + 1, 1);
for (int u = 1; u <= n; u++) a[u].reset();
int sum = 0, mst = 0;
for (int i = 1; i <= m; i++) {
cin >> (s + 1);
for (int u = 1; u <= n; u++) if (s[u] == '1') a[u][i] = 1;
sum += count(s + 1, s + n + 1, '1') - 1;
}
int tot = 0;
for (int u = 1; u <= n; u++) for (int v = 1; v < u; v++)
e[++tot] = {u, v, (a[u] & a[v]).count()};
sort(e + 1, e + tot + 1);
vector<edge> T;
for (int i = 1; i <= tot; i++) {
int u = find(e[i].u), v = find(e[i].v), w = e[i].w;
if (u == v) continue;
fa[u] = v, mst += w, T.emplace_back(e[i]);
}
if (mst != sum) return cout << "NO\n", void();
cout << "YES\n";
for (auto [u, v, w] : T) cout << u << ' ' << v << '\n';
}
```
:::::
## [QOJ7178 Bishops](https://qoj.ac/problem/7178)
> 给定 $n,m$。你需要在 $n\times m$ 的棋盘中放置 $k$ 个互不攻击的象,象的攻击方式与国际象棋相同。最大化 $k$ 并输出构造。
>
> $n,m\le10^5+1$,2 秒,512 MB。
:::::success[题解]
不妨设 $n\le m$,若 $n>m$ 则将棋盘旋转 $90$ 度。特判 $n=1$,此时将棋盘放满即可。
考虑坐标变换 $(x,y)\to(x+y,x-y)$,记 $u=x+y,v=x-y$,则任意两个象的 $u,v$ 不同是合法的充要条件。
尝试分析上界。将棋盘黑白染色,显然黑白格独立,可以分别分析。记偶数格放置 $k_0$ 个象,奇数格放置 $k_1$ 个象,则 $k=k_0+k_1$。
注意到,$k_0$ 不能超过偶数格中可用的 $u,v$ 的数目,从而 $k_0\le\min(|u_0|,|v_0|)$,同理得 $k_1\le\min(|u_1|,|v_1|)$。只要统计 $u\in[2,n+m]$ 和 $v\in[1-m,n-1]$ 中的奇偶数目,区间长度均为 $n+m-1$。
我们需要研究端点的奇偶性,据此进行分类讨论:
- 若 $n,m$ 均为偶数:
- $2$ 和 $n+m$ 均为偶数,故偶数比奇数多 $1$,此时 $|u_0|=\frac{n+m}{2},|u_1|=\frac{n+m-2}{2}$。
- $1-m$ 和 $n-1$ 均为奇数,故偶数比奇数少 $1$,此时 $|v_0|=\frac{n+m-2}{2},|v_1|=\frac{n+m}{2}$。
- 综上 $k_0\le\frac{n+m-2}{2},k_1\le\frac{n+m-2}{2}$,因此 $k\le n+m-2$。
- 若 $n,m$ 奇偶性不同:
- $2$ 为偶数,$n+m$ 为奇数,奇偶相同,此时 $|u_0|=|u_1|=\frac{n+m-1}{2}$。
- 同理 $|v_0|=|v_1|=\frac{n+m-1}{2}$。
- 综上 $k_0\le\frac{n+m-1}{2},k_1\le\frac{n+m-1}{2}$,因此 $k\le n+m-1$。
- 若 $n,m$ 均为奇数:
- $2$ 和 $n+m$ 均为偶数,故偶数比奇数多 $1$,此时 $|u_0|=\frac{n+m}{2},|u_1|=\frac{n+m-2}{2}$。
- $1-m$ 和 $n-1$ 均为偶数,故偶数比奇数多 $1$,此时 $|v_0|=\frac{n+m}{2},|v_1|=\frac{n+m-2}{2}$。
- 综上 $k_0\le\frac{n+m}{2},k_1\le\frac{n+m-2}{2}$,因此 $k\le n+m-1$。
- **特别地**,若 $n=m$,理论上界 $k_{\max}=2n-1$。取满所有偶数 $2,4,\cdots,2n$ 时,
- $u=2$ 必须位于 $(1,1)$,从而 $v=0$。
- $u=2n$ 必须位于 $(n,n)$,从而 $v=0$。
由于 $v$ 互不相同,故上界无法取得,此种情形的上界为 $k=2n-2$。
对 $n=m$ 的情形,我们给出特殊构造方式:将第 $1$ 列和第 $n$ 列排满点,仅删去第一行的点,点数 $2n-2$。

下面考察 $n<m$ 的情形。受 $n=m$ 的构造启发,我们先将第 $1$ 列和第 $n$ 列排满 $2n$ 个点。
此时未被使用的 $u,v$ 构成连续区间 $u\in[n+2,m]$ 和 $v\in[n-m+1,-1]$。将 $u_i$ 升序排列,$v_i$ 降序排列,按奇偶性分组,并对奇偶性相同的 $(u_i,v_i)$ 生成坐标点 $(x_i,y_i)=\left(\dfrac{u_i+v_i}{2},\dfrac{u_i-v_i}{2}\right)$。
下证这个构造合法:
对特定奇偶性,序列 $u_i$ 是公差为 $2$ 的等差数列,$v_i$ 是公差为 $-2$ 的等差数列。从而 $u_i=u_1+2(i-1),v_i=v_1-2(i-1)$,因此
- $x_i=\dfrac{u_i+v_i}{2}=\dfrac{u_1-v_1}{2}$。且 $u_1\in\{n+2,n+3\},v_1\in\{-1,-2\}$,在 $n\ge2$ 时必有 $x_i\in[1,n]$。
- $y_i=\dfrac{u_i-v_i}{2}$,其上下界分析为:
- $y_{\min}=\dfrac{(n+2)-(-1)}{2}=\dfrac{n+3}{2}$。
- $y_{\max}=\dfrac{m-(n-m+1)}{2}=m-\dfrac{n-1}{2}<m$。
因此 $y_i\in(1,m)$,必然不与第一步放置的 $2n$ 个点冲突。
下证这个构造取到了上界:
- 若 $n,m$ 均为偶数,则 $u$ 的首尾均为偶数,$v$ 的首尾均为奇数,损失一个配对,达到理论上界 $2n+(m-n-2)=n+m-2$。
- 对其余情形,所有 $u,v$ 都能配对,达到理论上界 $2n+(m-n-1)=n+m-1$。
:::::
:::::info[代码]
```cpp line-numbers
int n, m; bool ex;
void corner() {
cout << n + m - 2 << '\n';
for (int i = 1; i < n; i++) cout << i << ' ' << 1 << '\n';
for (int i = 1; i < n; i++) cout << i << ' ' << n << '\n';
}
void _main() {
cin >> n >> m;
bool fl = false;
if (n > m) swap(n, m), fl = true;
auto out = [&](int x, int y) -> void {
if (fl) swap(x, y);
cout << x << ' ' << y << '\n';
};
if (n == 1) {
cout << m << '\n';
for (int i = 1; i <= m; i++) out(1, i);
return;
}
if (n == m) return corner(), void();
if (n % 2 == 0 && m % 2 == 0) cout << n + m - 2 << '\n';
else cout << n + m - 1 << '\n';
for (int i = 1; i <= n; i++) out(i, 1);
for (int i = 1; i <= n; i++) out(i, m);
vector<int> u0, u1, v0, v1;
for (int i = n+2; i <= m; i++)
if (i & 1) u1.emplace_back(i);
else u0.emplace_back(i);
for (int i = -1; i >= n-m+1; i--)
if (i & 1) v1.emplace_back(i);
else v0.emplace_back(i);
int k0 = min(u0.size(), v0.size()), k1 = min(u1.size(), v1.size());
for (int i = 0; i < k0; i++) out((u0[i] + v0[i]) / 2, (u0[i] - v0[i]) / 2);
for (int i = 0; i < k1; i++) out((u1[i] + v1[i]) / 2, (u1[i] - v1[i]) / 2);
}
```
:::::
## IMO 2022 T6
> 给出 $n$,构造一个 $n\times n$ 的矩阵,包含 $1\sim n^2$ 的数恰好一次。最小化满足以下条件的路径数:
>
> - 开头是**谷**,即开头小于四周的数字。
> - 路径上数字的大小递增。
>
> 输出构造。
>
> $n\le2\times10^3$,1 秒,512 MB。
:::::success[题解]
考虑 checker 的做法。我们建出网格图,并从小数向大数定向,形成一张 DAG。在 DAG 上按拓扑序 DP,即令 $f_u$ 为以 $u$ 结尾的路径数目,转移为 $f_u=\sum\limits_{(v,u)\in E}f_v$,零入度点的 $f$ 值为 $1$。
基于此估计答案的下界。首先有 $f_u\ge1$,故每个入度都会贡献至少一条路径。故答案不小于入度之和 $|E|=2n(n-1)$。
另一方面,全图至少存在一个零入度点,每个起点也会贡献至少一次,故答案的下界是 $2n(n-1)+1$。
我们断言这个下界可以取到。分析下界取得的条件:
- 全图有恰好 $1$ 个零入度点。
- 只要某点有出点,其 $f$ 值必须严格等于 $1$。
观察 $f_u=1$ 的实际意义:从唯一的起点到 $v$,有且仅有一条路径。如果将起点作为根,则有出度点形成了一棵叶向树。
将网格图按照有无出度划分为两个集合:有出度点集 $V_0$ 和零出度点集 $V_1$。考察两个集合的形态:
- $V_0$ 必须无环且连通。
- $V_1$ 必须是独立集,否则会与零出度的条件矛盾。
现在问题被转化成,构造一个 01 矩阵满足上述条件。给出如下构造方法:

当 $n\equiv0\pmod3$ 时最后一行可能被切断,需要特殊修正。
找到这个矩阵后,在 $V_0$ 构成的树上任意定根,从 $1$ 开始赋一组拓扑序,并在 $V_1$ 中随意填数即可。复杂度 $O(n^2)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2005;
int n, dn, a[N][N], b[N][N];
const int dirx[] = {1, -1, 0, 0};
const int diry[] = {0, 0, 1, -1};
void dfs(int x, int y, int fx, int fy) {
a[x][y] = ++dn;
for (int d = 0; d < 4; d++) {
int nx = x + dirx[d], ny = y + diry[d];
if (nx < 1 || ny < 1 || nx > n || ny > n) continue;
if (nx == fx && ny == fy) continue;
if (b[nx][ny] == 0) dfs(nx, ny, x, y);
}
}
void _main() {
cin >> n;
for (int j = 2; j <= n; j += 6) {
for (int i = 2; i <= n; i++) {
if (i & 1) b[i][j + 1] = 1;
else b[i][j] = 1;
}
if (j + 1 == n) {
for (int i = 5; i <= n; i += 4) b[i][n] = 0;
break;
}
b[1][j + 2] = 1;
for (int i = 2; i <= n; i++) {
if (i & 1) b[i][j + 3] = 1;
else b[i][j + 4] = 1;
}
if (j + 4 == n) {
for (int i = 4; i <= n; i += 4) b[i][n] = 0;
break;
}
}
dfs(1, 1, -1, -1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (!a[i][j]) a[i][j] = ++dn;
cout << a[i][j] << " \n"[j == n];
}
}
```
:::::
## [P6775 [NOI2020] 制作菜品](https://www.luogu.com.cn/problem/P6775)
> 给出 $n$ 个正整数 $a_i$,保证 $\sum\limits_{i=1}^n a_i=m\times k$,表示第 $i$ 种材料有 $a_i$ 单位。
>
> 你需要制作 $m$ 个物品,每种物品恰好使用 $k$ 单位材料,且至多使用 $2$ 种材料。要求所有材料恰好用完。
>
> 输出构造或报告无解。
>
> 多测,$T\le10$,$n\le500$,$k\le5\times10^3$,$\textcolor{red}{n-2\le m}\le5\times10^3$,2 秒,512 MB。
:::::success[题解]
我们先考虑 $m=n-1$ 的情形。
考虑归纳构造。可以将 $a_i$ 升序排序后,将 $a_1$ 用完,并用 $a_n$ 填补空缺,规约到 $(n-1,m-1)$ 的子问题。
这样归纳的正确性依赖于两个性质:$a_1\le k$ 且 $a_1+a_n\ge k$。容易用反证法证明。
再考虑 $m>n-1$ 的情形。同理得 $a_n\ge k$,直接用 $a_n$ 制作一个物品,就可以规约到 $(n,m-1)$ 的子问题。
递归边界为 $n=2$,此时 $m=1$,直接将 $a_1,a_2$ 合成一个物品即可。
至此可以解决 $m\ge n-1$ 的情形,复杂度 $O(nm\log n)$,获得 20pts。[submission](https://qoj.ac/submission/2613095)。
下面解决 $m=n-2$ 的情形,我们尝试将其规约到 $m=n-1$ 的情形。
我们从一种更本质的角度分析问题:考虑图论建模,对于物品 $i$ 使用的两种材料 $a_i,b_i$ 连边 $a_i\leftrightarrow b_i$,如果只使用一种则视为自环。在这个观点下,$m=n-1$ 的构造对应了剥叶子的过程,此时建立的图应当是一棵树。
自然地,$m=n-2$ 的情形应当是两棵树。观察一棵树满足的要求:
**性质** 对于点集 $S$,可以将 $S$ 中的点构造为一棵树,当且仅当 $\sum\limits_{u\in S}a_u=k(|S|-1)$。
充分性由 $m=n-1$ 的构造导出。必要性考虑树中有 $|S|-1$ 条边,每条边是一个物品,恰好消耗 $k$ 单位材料。
因此,我们只要将全集划分为两个点集 $S,T$,满足 $S\cap T=\varnothing\land S\cup T=U$,并且
- $\sum\limits_{i\in S}a_i=k(|S|-1)$。
- $\sum\limits_{i\in T}a_i=k(|T|-1)$。
暴力实现这个过程可以做到 $O(2^n)$。
更进一步,由 $\sum\limits_{i\in U}a_i=k(n-2)$,故两个条件是线性相关的。这意味着,我们只要找到非空集合 $S$ 满足 $\sum\limits_{i\in S}a_i=k(|S|-1)\iff\sum\limits_{i\in S}(a_i-k)=-k$ 即可。
这是一个 01 背包问题,bitset 优化即可找到一组 $S$。至此 $m=n-2$ 的情形可以做到 $O\left(\dfrac{nmk}{w}\right)$,足以通过本题。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 505, M = 5e6 + 5;
using node = pair<int, int>;
int n, m, k, a[N];
bitset<M> f[N];
void solve(vector<node> a, int m) {
int n = a.size();
sort(a.begin(), a.end());
if (n == 1) {
cout << a[0].se << ' ' << k << '\n';
return;
}
if (m > n - 1) {
cout << a[n-1].se << ' ' << k << '\n';
a[n-1].fi -= k;
if (a[n-1].fi == 0) a.pop_back();
return solve(a, m - 1), void();
}
if (n == 2) {
cout << a[0].se << ' ' << a[0].fi << ' ';
cout << a[1].se << ' ' << a[1].fi << '\n';
return;
}
if (a[0].fi == k) {
cout << a[0].se << ' ' << k << '\n';
a.erase(a.begin()), solve(a, m - 1);
} else {
cout << a[0].se << ' ' << a[0].fi << ' ';
cout << a[n-1].se << ' ' << k - a[0].fi << '\n';
a[n-1].fi -= k - a[0].fi;
if (a[n-1].fi == 0) a.pop_back();
a.erase(a.begin()), solve(a, m - 1);
}
}
void _main() {
cin >> n >> m >> k;
if (m == n - 2) {
for (int i = 1; i <= n; i++) cin >> a[i], a[i] -= k;
const int off = m * k;
f[0].reset(), f[0][off] = 1;
for (int i = 1; i <= n; i++) {
if (a[i] >= 0) f[i] = f[i - 1] | (f[i - 1] << a[i]);
else f[i] = f[i - 1] | (f[i - 1] >> (-a[i]));
}
if (!f[n][-k + off]) return cout << -1 << '\n', void();
vector<node> x, y;
auto dfs = [&](auto&& dfs, int u, int sum) -> void {
if (!u) return;
int pre = sum - a[u] + off;
if (0 <= pre && pre < M && f[u - 1][pre])
x.emplace_back(a[u]+k, u), dfs(dfs, u - 1, sum - a[u]);
else
y.emplace_back(a[u]+k, u), dfs(dfs, u - 1, sum);
};
dfs(dfs, n, -k);
solve(x, x.size()-1), solve(y, y.size()-1);
return;
}
vector<node> a;
for (int i = 1, x; i <= n; i++) cin >> x, a.emplace_back(x, i);
solve(a, m);
}
```
:::::
## [P7078 [CSP-S 2020] 贪吃蛇](https://www.luogu.com.cn/problem/P7078)
> 现有 $n$ 名玩家,每名玩家有生命值 $a_i$,保证 $a_i$ 单调不降。称 $i$ 强于 $j$ 当且仅当 $a_i>a_j\lor(a_i=a_j\land i>j)$。这些玩家需要进行一个游戏。
>
> 游戏进行若干轮,每轮中,最强玩家 $i$ 有如下两种选择:
>
> 1. 玩家 $i$ 击杀最弱玩家 $j$,然后令 $a_i\gets a_i-a_j$。此操作需有 $i\ne j$,之后游戏进入下一轮。
> 2. 玩家选择结束游戏。
>
> 假定每名玩家绝顶聪明。每名玩家的目标是在保证存活的前提下,最大化击杀数。
>
> 求出在此情况下,游戏结束后的存活人数。
>
> 多测,$T\le10$,$n\le10^6$,2 秒,256 MB。
:::::success[题解]
设最强玩家为 $n$,最弱玩家为 $1$。我们有一个显然的观察:若 $n$ 在击杀 $1$ 以后绝对安全,那么 $n$ 一定会选择击杀。
考虑 $n$ 在击杀 $1$ 后,如果 $n-1$ 成为最强者,由于 $n-1$ 的目标是存活,且他具有结束游戏的主动权,故 $n-1$ 一定不会死亡。
因为击杀后生命减少的规则,$n-1$ 如果击杀最弱者,那么他一定弱于原本的 $n$,因此 $n-1$ 不会死亡 $n$ 也就不会死亡。
此时 $n$ 的唯一死法就是成为了最弱者,并且被 $n-1$ 击杀。所以如果 $n$ 杀掉 $1$ 不是最弱的,他一定会选择击杀。
但是 $n$ 成为最弱者不代表一定死亡。我们可以用逆向归纳法,列出每名玩家的思考来说明这个观点:
- $n$ 的思考:如果自己成为最弱者,就会进入被 $n-1$ 击杀的危险圈。
- $n-1$ 的思考:如果自己成为最强者,则依然有两种选择:
- 如果自己击杀 $n$ 后不是最弱者,$n$ 必死无疑。
- 如果自己击杀 $n$ 后是最弱者,就会进入被 $n-2$ 击杀的危险圈。
- $n-2$ 的思考:……
这样推演的终点只有下列两种情况之一:
1. 玩家 $k$ 击杀最弱者后并不会垫底。
2. $n=2$ 时,$2$ 一定选择击杀 $1$。
一旦推演到终点,我们就反向归纳:
- 如果 $n-2$ 击杀最弱者后,属于上述两种情况,$n-2$ 一定选择击杀。
- 这样一来,$n-1$ 如果击杀 $n$ 后是最弱者,$n-1$ 也会同归于尽。由于生存是第一目的,$n-1$ 会选择结束游戏。
- 因此,$n$ 即使成为最弱者,游戏规则对 $n-1$ 形成了威慑,所以 $n$ 会直接击杀 $1$。
而当 $n-3$ 击杀最弱者后属于上述情况时,情况则相反。那么 $n-1$ 击杀 $n$ 后,$n-1$ 面临的情况和上述讨论相同,所以 $n-1$ 可以存活。因此 $n$ 不会冒险,选择结束游戏。
如此归纳,我们设这条死亡链的长为 $k$,则 $2\mid k$ 时 $n$ 会击杀 $1$,然后 $n-1$ 结束游戏;否则 $n$ 直接结束游戏。
根据上述分析,游戏会出现两个阶段:
- 安全阶段:在这一阶段,每个玩家击杀最弱者都不会变成最弱,故所有人都选择击杀;
- 危险阶段:此时最强者杀最弱会导致自己变成最弱,则选择与死亡链的奇偶性有关。
一旦游戏进入危险阶段,即会在 $O(1)$ 轮内结束。故我们主要需要维护安全阶段,以及在进入危险阶段时扫描出一条死亡链。
使用 std::set 存储 $(a_i,i)$ 对,可以模拟上述过程,复杂度 $O(Tn\log n)$,朴素实现可获得 70 分。我这里使用了一个我编写的平衡树板子,配合 fread 快读,获得了 [100 分](https://www.luogu.com.cn/record/268351762),最慢点 1.81s。给出[完整代码](https://www.luogu.me/paste/wlumsdxx)。
下面叙述正解。由于安全阶段中,最强不会变成最弱。由于最强在变弱,最弱在变强,新的生命值一定是一个单调不增的序列。
我们有一个队列模拟 set 的经典 trick。在本题中,维护两个双端队列 $Q_1,Q_2$:
- $Q_1$ 存放初始的玩家,按生命值升序排列。
- $Q_2$ 存放生命值变化后的玩家,其生命值必然降序排列。
- 这样一来,寻找最强者和最弱者,只需将比较队列的首尾。
危险阶段则直接模拟即可,复杂度 $O(Tn)$,可以通过本题。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e6 + 5;
int n, a[N];
using node = pair<int, int>;
struct box {
node q1[N], q2[N];
int sz, h1, t1, h2, t2;
void init() {
sz = n, h1 = 0, t1 = n - 1, h2 = 0, t2 = -1;
for (int i = 1; i <= n; i++) q1[i - 1] = {a[i], i};
}
node popmx() {
sz--;
if (h1 <= t1 && h2 <= t2) return q1[t1] > q2[h2] ? q1[t1--] : q2[h2++];
return h1 <= t1 ? q1[t1--] : q2[h2++];
}
node popmn() {
sz--;
if (h1 <= t1 && h2 <= t2) return q1[h1] < q2[t2] ? q1[h1++] : q2[t2--];
return h1 <= t1 ? q1[h1++] : q2[t2--];
}
node getmn() {
if (h1 <= t1 && h2 <= t2) return q1[h1] < q2[t2] ? q1[h1] : q2[t2];
return h1 <= t1 ? q1[h1] : q2[t2];
}
void push(const node& x) {q2[++t2] = x, sz++;}
int size() const {return sz;}
bool empty() const {return sz == 0;}
} q;
int work() {
q.init();
while (q.size() > 2) {
node mx = q.popmx(), mn = q.popmn();
node nxt = {mx.first - mn.first, mx.second};
if (q.empty()) break;
if (nxt > q.getmn()) {
q.push(nxt);
continue;
}
int res = q.size() + 2, cnt = 1;
while (!q.empty()) {
node u = q.popmx(), v = {u.first - nxt.first, u.second};
cnt++;
if (q.empty() || v > q.getmn()) break;
nxt = v;
}
if (cnt & 1) return res - 1;
return res;
}
return 1;
}
void _main() {
int T; read(T);
for (int i = 1, k, x, y; i <= T; i++) {
if (i == 1) read(n), read(a + 1, a + n + 1);
else for (read(k); k--; ) read(x, y), a[x] = y;
cout << work() << '\n';
}
}
```
:::::
## [AGC023D Go Home](https://www.luogu.com.cn/problem/AT_agc023_d)
> 数轴上有一辆公交车,初始位置为 $x$。现有 $n$ 组人,第 $i$ 组人有 $c_i$ 个并希望在 $p_i$ 位置下车,$p_i$ 可能为负。
>
> 在每个时刻,所有车上的人必须投票决定车的行进方向。车会向票数高的方向前进,平票则向负方向。直到车上无人时停止行进。
>
> 所有人绝顶聪明,且其目标是最小化到达时间。求公交车行驶的总时间。
>
> $n\le10^5$,$1\le x,p_i,c_i\le10^9$,2 秒,256 MB。
:::::success[题解]
考虑反向归纳。当车上有两组人 $(c_1,p_1)$ 和 $(c_2,p_2)$ 时,假定 $p_1\to x\to p_2$ 的位置关系如图:

不妨设 $c_1<c_2$,则公交车的行进顺序必然为 $x\to p_2\to p_1$。此时第 $1$ 组人的到达时间必然晚于第 $2$ 组人。
因此,第 $1$ 组人的目标变为最小化第 $2$ 组人的到达时间。这样,在这一局面之前的投票中,$1$ 组会无条件支持 $2$ 组,即 $c_2\gets c_2+c_1$。
这个结论容易推广到 $n$ 组人的情形,递归求解即可。递归终点为 $\forall i,x\le p_i$ 或 $\forall i,x\ge p_i$,此时公交车只会向一个方向移动并在 $p_i$ 的最值处停下。
复杂度 $O(n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define int long long
const int N = 1e5 + 5;
int n, x, a[N], c[N];
int solve(int l, int r, int p) {
if (x < a[l]) return a[r] - x;
if (x > a[r]) return x - a[l];
if (c[l] >= c[r]) return c[l] += c[r], solve(l, r - 1, a[l]) + p - a[l];
return c[r] += c[l], solve(l + 1, r, a[r]) + a[r] - p;
}
void _main() {
cin >> n >> x;
for (int i = 1; i <= n; i++) cin >> a[i] >> c[i];
cout << solve(1, n, c[1] < c[n] ? a[1] : a[n]);
}
```
:::::
## [P9969 [THUPC 2024 初赛] 分治乘法](https://www.luogu.com.cn/problem/P9969)
> 现有目标集合 $T\subseteq\{1,2,\cdots,n\}$,你需要通过如下操作得到这个集合:
>
> - 给出 $x$,新建集合 $S=\{x\}$;
> - 给出 $u,v$,新建集合 $S=S_u\cup S_v$;
> - 给出 $u,a$,新建集合 $S=\{x+a\mid x\in S_u\}$。
>
> 要求操作过程中集合始终为 $\{1,2,\cdots,n\}$ 的子集。记代价为所有集合的大小之和。
>
> $n\le5\times10^5$,要求代价 $\le5\times10^6$,操作次数 $\le10^6$,1 秒,512 MB。
:::::success[题解]
考虑一种朴素构造:对于每个 $x\in T$,先新建集合 $S_x=\{x\}$,然后将集合放进小根堆中,每次选择较小的两个集合合并。这个过程等价于建立 Huffman 树,代价是 $n\log n$ 级别的,无法通过。
引入操作 3。操作 3 的意义在于,我们可以利用一个已经得到的集合,快速平移得到另一个集合,不用在使用朴素策略构造。因此,两个集合之间的结构必须是相关的。
题目给出了一个长为 $n$ 的 01 串表示 $T$ 中各元素的分布。分块,将这个串每 $B$ 个分一块,这样至多有 $2^B$ 个本质不同的块。此时,对于 $x\in T$,可以用所属块起点 & 块内偏移量来记录 $x$。
对于所有本质不同的块 $m$,在整个串中找到其所有出现位置的集合,记为 $P_m$。可以使用朴素构造得到 $P_m$。注意 $\sum|P_m|=\frac{n}{B}$,则这一步的代价为 $O(\frac{n}{B}\log\frac{n}{B})=O(\frac{n\log n}{B})$。
得到 $P_m$ 以后,需要将起始点向后偏移。对于每个偏移量 $\delta$,将 $P_m$ 用操作 3 偏移 $\delta$ 以后得到 $P_m+\delta$,然后将所有平移结果使用朴素构造合并。这一步代价为 $\sum|P_m|B\log B=\frac{n}{B}B\log B=O(n\log B)$。
最终,我们得到了 $2^B$ 个集合,将这些集合用朴素构造合并,代价为 $n\log2^B=O(nB)$。
上面可能比较抽象,举一个例子。比如 $B=3$,第 $2,5,9$ 块均为 `101`,起始位置分别为 $x_2,x_5,x_9$。
通过朴素构造得到 $P=\{x_2,x_5,x_9\}$,根据 `101` 的规则,我们只需将 $P$ 平移 $0,2$ 以后合并,即得到 $\{x_2,x_2+2,x_5,x_5+2,x_9,x_9+2\}$。这就是构造的目标。
最后只需平衡复杂度。写出总代价式 $\frac{n\log n}{B}+n\log B+nB$。提取 $n$ 后 $\log B$ 可以作为低阶项忽略,则由均值不等式
$$
n\left(\dfrac{\log n}{B}+B\right)\le2n\sqrt{\frac{\log n}{B}\times B}=O\left(n\sqrt{\log n}\right)
$$
取等条件为 $B=\sqrt{\log n}$,在本题中可以取 $B=4$。
实现时维护每个集合的大小即可,可以通过。
**启示:用 $\log n$ 分块平衡复杂度。**
:::::
:::::info[代码]
```cpp line-numbers
const int N = 5e5 + 5, B = 4;
int cnt, sz[N];
vector<tuple<int, int, int>> op;
int X(int x) {
op.emplace_back(1, x, -1), sz[++cnt] = 1;
return cnt;
}
int Y(int x, int y) {
op.emplace_back(2, x, y), sz[++cnt] = sz[x] + sz[y];
return cnt;
}
int Z(int x, int y) {
if (y == 0) return x;
op.emplace_back(3, x, y), sz[++cnt] = sz[x];
return cnt;
}
int n;
char s[N];
vector<int> pos[1 << B];
int merge(vector<int> a) {
using node = pair<int, int>;
priority_queue<node, vector<node>, greater<node>> q;
for (int i : a) q.emplace(sz[i], i);
while (q.size() > 1) {
auto [s1, u] = q.top(); q.pop();
auto [s2, v] = q.top(); q.pop();
q.emplace(s1 + s2, Y(u, v));
} return q.top().second;
}
void _main() {
cin >> n >> (s + 1);
for (int i = 1; i <= n; i += B) {
int mask = 0;
for (int j = 0; j < B; j++) {
if (i + j <= n && s[i + j] == '1') mask |= 1 << j;
}
pos[mask].emplace_back(i);
}
vector<int> all;
for (int s = 1; s < (1 << B); s++) {
if (pos[s].empty()) continue;
vector<int> vec;
for (int i : pos[s]) vec.emplace_back(X(i));
int u = merge(vec);
vector<int> off;
for (int i = 0; i < B; i++) {
if (s >> i & 1) off.emplace_back(Z(u, i));
}
all.emplace_back(merge(off));
}
merge(all);
cout << op.size() << '\n';
for (auto [opt, x, y] : op) {
cout << opt << ' ' << x << ' ';
if (opt != 1) cout << y;
cout << '\n';
}
}
```
:::::
## [QOJ6545 Connect the Dots](https://qoj.ac/problem/6545)
> 在数轴上有 $n$ 个点,共有 $m$ 种颜色,在位置 $i$ 处点的颜色为 $a_i$。你需要构造若干条曲线,且满足端点颜色不同,任意曲线不相交,所有曲线在 $x$ 轴上方。最大化曲线数目并构造方案。
>
> 多测,$\sum n\le2\times10^5$,1 秒,1024 MB。
:::::success[题解]
考虑答案的上界。不妨记所有点对颜色不同,此时的曲线形成一种类似树的结构。
我们充分发扬人类智慧,注意到上述构造中,$1\to n$ 的曲线与 $1\to2,2\to3,\cdots$ 的曲线地位相等,于是将问题转化到环上。将问题重新表述为:给出一个 $n$ 个点的正多边形,顶点颜色不同,需要将颜色不同的顶点两两连边使得对角线不交。
这样也容易得到答案上界:当所有点对颜色不同时,答案为三角剖分加上边数,即 $2n-3$。
接下来考虑颜色重复的问题。先忽略对角线,关注多边形的边界。若同边端点颜色相同,则这条边是无法连接的。进一步,考虑在边界上找出若干颜色段,并且缩成一个点。
对于颜色段内每个点,一种简单的处理方式是将其连向颜色段一端的外端点。例如连续顶点 $A,B,C,D,E$ 中 $B,C,D$ 同色,则做如下连边:

这样显然不会冲突,并且将 $B,C,D$ 缩成一点 $F$ 后,可以在 $F$ 上方的连边等效到 $B$ 上,在 $F$ 下方的连边等效到 $D$ 上。这样,问题转化为相邻顶点不同色的情形。
转化到凸多边形以后,我们有一种重要的操作:考虑连续三个点 $A,B,C$,剖分得到 $\triangle ABC$ 后,将这个三角形割去,则问题就变成了一个 $n-1$ 条边的子问题,如图:

这个操作需要 $A,B,C$ 两两不同色,所以需要颜色种类数 $m\ge3$。
根据抽屉原理,当 $m\ge3$ 时多边形上必然存在这样的三个顶点 $A,B,C$。于是可以删去 $B$ 以后归纳构造。
不过这里有一个问题,就是如果 $B$ 是唯一单色点就倒闭了。因此我们特判一下这种情况,此时从 $B$ 出发连向所有点即可。
对于 $m\ge3$,上述构造可以取到上界 $2n-3$。
还需要讨论掉 $m=2$ 的情形。此时顶点颜色一定是交替的。特判 $n=2,3$ 以后可以发现最优构造的得分为 $\frac{n}{2}-2$。
::::success[证明]{open}
- 充分性:考虑从一个点出发连向所有异色点可以达到这个下界。
- 必要性:可以归纳法证明这是一个上界,
- 若 $n=4$ 则显然成立;
- 若 $n>4$,任意对角线将多边形分为规模为 $i$ 和 $n-i+2$ 的子问题,由归纳假设 $\frac{i}{2}-2+\frac{n-i+2}{2}-2+1=\frac{n}{2}-2$。
::::
用环形链表来维护多边形的顶点,较为精细的实现可以做到 $O(n)$ 复杂度。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, m, k, a[N], L[N], R[N], hd[N], nxt[N], cnt[N];
bool del[N];
vector<int> vec;
vector<pair<int, int>> e;
void A(int u, int v) {
if (u == v || a[u] == a[v]) return;
if (u > v) swap(u, v);
e.emplace_back(u, v);
}
void O() {
sort(e.begin(), e.end());
e.erase(unique(e.begin(), e.end()), e.end());
cout << e.size() << '\n';
for (auto& i : e) cout << i << '\n';
}
int find(int c) {
for (int u = hd[c]; u != -1; u = nxt[u]) {
if (!del[u]) return u;
} return -1;
}
void star(int v) {
for (int u = R[v]; u != v; u = R[u])
A(vec[v], vec[u]), A(vec[u], vec[R[u]]);
}
void _main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
e.clear(), vec.clear();
for (int r = 1; r <= n; ) {
int l = r;
while (r <= n && a[l] == a[r]) r++;
if (l > 1)
for (int i = l; i < r; i++) A(vec.back(), i);
else if (r <= n)
for (int i = l; i < r; i++) A(i, r);
vec.emplace_back(l == 1 ? 1 : r - 1);
}
k = vec.size();
if (k == 1) return O(), void();
fill(hd + 1, hd + n + 1, -1), fill(nxt, nxt + k + 1, -1);
fill(cnt + 1, cnt + n + 1, 0), fill(del, del + k + 1, 0);
for (int i = 0; i < k; i++) {
L[i] = ((i - 1) % k + k) % k, R[i] = (i + 1) % k;
cnt[a[vec[i]]]++;
}
for (int i = k - 1; i >= 0; i--) {
int& j = hd[a[vec[i]]];
nxt[i] = j, j = i;
}
int pos = find(cnt + 1, cnt + m + 1, 1) - cnt;
if (pos != m + 1) {
star(find(pos));
return O(), void();
}
queue<int> q;
auto push = [&](int i) -> void {
if (del[i]) return;
int x = a[vec[L[i]]], y = a[vec[i]], z = a[vec[R[i]]];
if (x != y && x != z && y != z) q.emplace(i);
};
for (int i = 0; i < k; i++) push(i);
bool fl = false;
while (!q.empty()) {
int y = q.front(); q.pop();
if (del[y]) continue;
int x = L[y], z = R[y];
if (a[vec[x]] == a[vec[y]] || a[vec[y]] == a[vec[z]] || a[vec[x]] == a[vec[z]]) continue;
A(vec[x], vec[y]), A(vec[y], vec[z]), A(vec[x], vec[z]);
del[y] = true, cnt[a[vec[y]]]--;
R[x] = z, L[z] = x;
if (cnt[a[vec[y]]] == 1) {
star(find(a[vec[y]]));
fl = true; break;
}
push(x), push(z);
}
if (!fl) {
int x = find(del, del + k, false) - del;
int c = a[vec[R[x]]];
for (int u = R[x]; u != x; u = R[u]) {
if (a[vec[u]] == c) A(vec[x], vec[u]);
A(vec[u], vec[R[u]]);
}
} O();
}
```
:::::
## [P9139 [THUPC 2023 初赛] 喵了个喵 II](https://www.luogu.com.cn/problem/P9139)
> 给定一个长为 $4n$ 的序列,其中 $1\sim n$ 各出现 $4$ 次。你需要将其划分为两个相等的子序列,输出构造或报告无解。
>
> $n\le5\times10^4$,4 秒,1024 MB。
:::::success[题解]
考虑问题的弱化,即 $1\sim n$ 各出现 $2$ 次。设数值 $i$ 两次出现的位置为 $l_i,r_i$,其中 $l_i<r_i$,则有
**结论** 无解当且仅当 $\exists i\ne j,[l_i,r_i]\subseteq[l_j,r_j]$。
`1221` 和 `1212` 是很好的例子。如果有解,则只要将 $l_i$ 分为一组,$r_i$ 分为一组。
受上述讨论启发,记数值 $i$ 四次出现的位置依次为 $p_{0,i},p_{1,i},p_{2,i},p_{3,i}$。讨论可行的划分方式:
- $[p_{0,i},p_{1,i}]$和$[p_{2,i},p_{3,i}]$。
- $[p_{0,i},p_{2,i}]$ 和 $[p_{1,i},p_{3,i}]$。
- $[p_{0,i},p_{3,i}]$ 和 $[p_{1,i},p_{2,i}]$。根据上面的结论,两个区间有包含关系不合法,舍去。
实际上,我们只要关注前两种划分方案。设布尔变量 $x_i$ 表示选择何种方案,将 $x_i=1$ 代表的方案写作 $[l_{i,1},r_{i,1}],[l_{i,2},r_{i,2}]$。根据无解条件,我们添加下列约束:
- $\forall i\ne j,\exists\alpha,\beta\in\{1,2\},[l_{i,\alpha},r_{i,\alpha}]\subseteq[l_{j,\beta},r_{j,\beta}],\neg(x_i\land x_j)$。
这个约束的实际意义是,对于两个导致包含关系的选择,禁止二者同选。其他情形同理。
这是一个 2-SAT 问题。对约束中的 $i,j$,连边 $x_i\to\neg x_j,x_j\to\neg x_i$ 后缩 SCC,从而 $x_i,\neg x_i$ 同属一个 SCC 无解,否则根据 $x_i$ 的取值构造方案。直接做可得到 $O(n^2)$ 复杂度。
转二维平面分析,则 $[l_1,r_1]\subseteq[l_2,r_2]$ 相当于 $(l_1,r_1)$ 落在一个 2-side 矩形内:

可以做主席树优化建图,或者 CDQ 分治套前缀优化建图,复杂度 $O(n\log n)$。[CDQ 代码](https://qoj.ac/submission/2696523)。
不过我们还有一种更聪明的手法,可以使用 Kosaraju 求 SCC,这样只要两次 DFS。考虑[这篇文章](https://www.luogu.com.cn/article/3wrdor73)中提及的技巧,假设节点 $u$ 代表区间 $A=[l_1,r_1]$,我们希望找到 $B=[l_2,r_2]$ 作为 $u$ 的后继节点 $v$,且 $v$ 未访问。
使用线段树维护左端点 $l$,节点维护区间内未访问的 $r$ 的最小 & 最大值。若 $B\subseteq A$ 则在 $[l_1,r_1]$ 上查 $r_{\min}$,若 $A\subseteq B$ 则在 $[1,l_1]$ 上查 $r_{\max}$。访问 $B$ 前将 $B$ 代表的区间删去。
注意两次 DFS 时正反图的对应关系。复杂度仍为 $O(n\log n)$ 但空间线性。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5, inf = 1e9;
int n, a[N], ans[N], l1[N], r1[N], l2[N], r2[N];
vector<int> pos[N];
int opp(int x) {return x <= n ? x+n : x-n;}
struct node {
int l, r, id;
bool operator< (const node& o) const {return r < o.r;}
};
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
node mx[16*N], mn[16*N];
void pushup(int rt) {
mx[rt] = max(mx[ls], mx[rs]), mn[rt] = min(mn[ls], mn[rs]);
}
void build(int l = 1, int r = 8*n, int rt = 1) {
if (l == r) return mx[rt] = {l, -inf, -1}, mn[rt] = {l, inf, -1}, void();
int mid = (l + r) >> 1;
build(l, mid, ls), build(mid + 1, r, rs), pushup(rt);
}
void insert(int x, node c, int l = 1, int r = 8*n, int rt = 1) {
if (l == r) return chkmax(mx[rt], c), chkmin(mn[rt], c), void();
int mid = (l + r) >> 1;
if (x <= mid) insert(x, c, l, mid, ls);
else insert(x, c, mid + 1, r, rs);
pushup(rt);
}
void remove(int x, int l = 1, int r = 8*n, int rt = 1) {
if (l == r) return mx[rt] = {l, -inf, -1}, mn[rt] = {l, inf, -1}, void();
int mid = (l + r) >> 1;
if (x <= mid) remove(x, l, mid, ls);
else remove(x, mid + 1, r, rs);
pushup(rt);
}
node qmax(int tl, int tr, int l = 1, int r = 8*n, int rt = 1) {
if (tl <= l && r <= tr) return mx[rt];
int mid = (l + r) >> 1; node res{-1, -inf, -1};
if (tl <= mid) chkmax(res, qmax(tl, tr, l, mid, ls));
if (tr > mid) chkmax(res, qmax(tl, tr, mid + 1, r, rs));
return res;
}
node qmin(int tl, int tr, int l = 1, int r = 8*n, int rt = 1) {
if (tl <= l && r <= tr) return mn[rt];
int mid = (l + r) >> 1; node res{-1, inf, -1};
if (tl <= mid) chkmin(res, qmin(tl, tr, l, mid, ls));
if (tr > mid) chkmin(res, qmin(tl, tr, mid + 1, r, rs));
return res;
}
} T;
void prework() {
T.build();
for (int i = 1; i <= n; i++) {
int p1 = pos[i][0], p2 = pos[i][1], p3 = pos[i][2], p4 = pos[i][3];
T.insert(2*p1, {2*p1, p2, i}), T.insert(2*p3, {2*p3, p4, i});
T.insert(2*p1+1, {2*p1+1, p3, i+n}), T.insert(2*p2, {2*p2, p4, i+n});
l1[i] = p1, r1[i] = p2, l2[i] = p3, r2[i] = p4;
l1[i+n] = p1, r1[i+n] = p3, l2[i+n] = p2, r2[i+n] = p4;
}
}
int cnt, bel[N], vis[N];
vector<int> s;
void out(int l, int r, auto&& f) {
while (true) {
auto [l2, r2, id] = T.qmin(2*l, 2*r+1);
if (r2 >= r) break;
T.remove(l2), f(id);
}
while (true) {
auto [l2, r2, id] = T.qmax(1, 2*l+1);
if (r2 <= r) break;
T.remove(l2), f(id);
}
}
void dfs1(int u) {
vis[u] = true;
out(l1[u], r1[u], [&](int v) -> void {
if (!vis[opp(v)]) dfs1(opp(v));
});
out(l2[u], r2[u], [&](int v) -> void {
if (!vis[opp(v)]) dfs1(opp(v));
});
s.emplace_back(u);
}
void dfs2(int u) {
bel[u] = cnt;
out(l1[opp(u)], r1[opp(u)], [&](int v) -> void {
if (!bel[v]) dfs2(v);
});
out(l2[opp(u)], r2[opp(u)], [&](int v) -> void {
if (!bel[v]) dfs2(v);
});
}
void kosaraju() {
prework();
for (int i = 1; i <= 2*n; i++) if (!vis[i]) dfs1(i);
reverse(s.begin(), s.end());
prework();
for (int i : s) if (!bel[i]) bel[i] = ++cnt, dfs2(i);
}
void _main() {
cin >> n;
for (int i = 1; i <= 4*n; i++) cin >> a[i], pos[a[i]].emplace_back(i);
kosaraju();
for (int i = 1; i <= n; i++) {
if (bel[i] == bel[i+n]) return cout << "No", void();
int p1 = pos[i][0], p2 = pos[i][1], p3 = pos[i][2];
if (bel[i] < bel[i+n]) ans[p1] = ans[p2] = 1;
else ans[p1] = ans[p3] = 1;
}
cout << "Yes\n";
for (int i = 1; i <= 4*n; i++) cout << ans[i];
}
```
:::::
## [CF715D Create a Maze](https://www.luogu.com.cn/problem/CF715D)
> 给出 $T$,要求构造一个 $n\times m$ 的迷宫,其中部分门被锁住。玩家可以在其中向右或向下移动,但不能通过被锁住的门。要求从 $(1,1)$ 走到 $(n,m)$ 的方案数恰为 $T$。
>
> $T\le10^{18}$,满分要求 $n,m\le50$,被锁住的门数目 $\le300$,2 秒,250 MB。
:::::success[题解]
注意到我们可以这样构造出一个 Fibonacci 数列:

设 $f_n$ 表示 Fibonacci 数列第 $n$ 项,有 $f_{88}>10^{18}$,于是网格大小在 $44$ 左右,这是符合要求的。
根据 Zeckendorf 定理,一个正整数总能被拆成若干不连续的 Fibonacci 数的和的形式。具体地,考虑贪心,降序扫描每个 $f_n$,能减即减即可。
考虑构造如下形式的网格:

除了蓝色的终点外,其余颜色交界处放墙。图中的颜色有如下含义:
- 黄色:Fibonacci 数列区。
- 绿色:答案路径区。
- 红色:我们钦定不能到达的区域。
保护出一条绿色路径,则对于每个整数的分解形式,打开对应的墙即可。例如 $133=2+8+13+21+89$,则打开红线标记的墙:

现在我们可以做到给任意目标找一个构造了。但这需要 $346$ 个墙,无法通过。
注意到红区与绿区之间其实并不需要全部堵上,只要保护出绿区即可。具体来说,我们可以只在紫色线的区域放墙:

这样墙的数目最多只有 $260$ 个,可以通过。
这个做法也可以通过 [Gym104337E](https://codeforces.com/gym/104337/problem/E) 和 [QOJ7979](https://qoj.ac/problem/7979)。
:::::
:::::info[代码]
```cpp
#define int long long
const int N = 100, n = 46, m = 47;
int x, f[N];
bool D[N][N], R[N][N];
void _main() {
f[1] = f[2] = 1;
for (int i = 3; i <= 88; i++) f[i] = f[i - 1] + f[i - 2];
cin >> x;
int cnt = 0;
memset(D, 1, sizeof(D)), memset(R, 1, sizeof(R));
for (int i = 3, j = 1; i <= n; (i & 1) == (j & 1) ? i++ : j++) {
if ((i & 1) == (j & 1)) D[i - 1][j] = 0, R[i][j] = 0;
else D[i][j] = 0, cnt++;
}
for (int i = 1, j = 4; j <= m; (i & 1) == (j & 1) ? i++ : j++) {
if ((i & 1) == (j & 1)) R[i][j] = 0, cnt++;
else R[i][j - 1] = 0, D[i][j] = 0;
}
D[n - 1][m - 2] = D[n - 1][m - 1] = 0, R[n - 1][m - 1] = 0;
for (int i = 88; i >= 1; i--) {
if (x < f[i]) continue;
x -= f[i];
if (i & 1) D[(i + 1) / 2 + 1][(i + 1) / 2] = 1;
else R[i / 2][i / 2 + 2] = 1;
}
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) cnt += D[i][j] ^ 1, cnt += R[i][j] ^ 1;
}
cout << n << ' ' << m << ' ' << cnt << '\n';
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
if (!D[i][j]) cout << i << ' ' << j << ' ' << i + 1 << ' ' << j << '\n';
if (!R[i][j]) cout << i << ' ' << j << ' ' << i << ' ' << j + 1 << '\n';
}
}
}
```
:::::
## [P3526 [POI 2011] OKR-Periodicity](https://www.luogu.com.cn/problem/P3526)
> 给出一个字符串 $S$,要求构造一个 01 串 $T$ 使得 $|S|=|T|$ 且 $\text{per}(S)=\text{per}(T)$。$\text{per}$ 表示字符串所有周期的集合。
>
> 最小化 $T$ 的字典序并输出,或报告无解。
>
> 多测,$T\le20$,$|S|\le2\times10^5$,字符集 $\tt{A}\sim\tt{Z}$,1 秒,512 MB。
::::::success[题解]
下文记 $|S|=n$。
**引理 1** $S$ 存在长为 $l$ 的 border,当且仅当 $S$ 存在 $n-l$ 的周期。
将周期性转化成 border 思考。
若 $S$ 不存在 border,我们只要构造一个不含 border 的 01 串。容易发现 $\tt{00\cdots01}$ 是最优的。
否则,取出 $S$ 的最长 border,设其长度为 $l$。我们对 border 是否覆盖原串分类讨论:
若 $2l\ge n$,两段前后缀覆盖整串。将问题规约到 $S[1:l]$ 的构造,对 $1\sim l$ 归纳构造后,将这段字符串的后缀直接复制到 $l+1\sim n$ 即可。如图:

:::::success[证明]
最优性显然。记 $\text{bd}(S)$ 为字符串 $S$ 所有 border 长度的集合,只要证 $\text{bd}(S)=\text{bd}(T)$。
**引理 2** 设 $S$ 的最长 border 长度为 $l$,则 $\text{bd}(S[1:l])=\text{bd}(S)\setminus\{l\}$。由 KMP 的正确性得到。
**引理 3** 若字符串 $S$ 具有两个不同周期 $p,q$ 且 $|S|\ge p+q$,则 $\gcd(p,q)$ 也是 $S$ 的周期。称为**弱周期引理**。
由策略得 $T[1:l]=T[n-l+1:n]$,从而 $l\in\text{bd}(T)$。故 $T$ 具有周期 $p=n-l$。
下证 $l$ 是 $T$ 的最长 border。
::::success[证明]{open}
假设 $l'\in\text{bd}(T)$ 且 $l'>l$,则 $T$ 同时存在周期 $p=n-l$ 和 $q=n-l'<n-l$。
此时 $p+q<2n-2l$,代入 $2l\ge n$ 得 $p+q<n$。由引理 3 得 $d=\gcd(p,q)$ 是 $T$ 的周期。
进而 $d$ 也是 $T[1:l]$ 的周期。由归纳假设 $S[1:l]=T[1:l]$ 得 $d$ 是 $S[1:l]$ 的周期。且 $d\mid p$,故 $d$ 是 $S$ 的周期,因此 $n-d\in\text{bd}(S)$。
由 $d<p$ 推知 $n-d<l$,与 $l$ 是 $S$ 的最长 border 矛盾。证毕。
::::
下证 $\text{bd}(S)=\text{bd}(T)$。
::::success[证明]{open}
由引理 2 得
$$
\text{bd}(S[1:l])=\text{bd}(S)\setminus\{l\}\\
\text{bd}(T[1:l])=\text{bd}(T)\setminus\{l\}
$$
代入归纳假设 $S[1:l]=T[1:l]$ 得 $\text{bd}(S)=\text{bd}(T)$。
::::
:::::
若 $2l<n$,仍对 $1\sim l$ 归纳构造,并将这段构造复制到 $n-l\sim n$ 的后缀上。但此时我们需要决策中间段的填法。

我们断言:中间段填入 $\tt{00\cdots00}$ 和 $\tt{00\cdots01}$ 至少有一个串 $T$ 合法。最优性显然。
笔者拼尽全力无法证明这个策略的正确性,所以只能给出感性理解了。
- 若填入 $\tt{00\cdots00}$ 不合法,必然 $\exists l'\in\text{bd}(T),l'>l$。原因是 $\tt{0}$ 将前后缀连接起来了。
- 于是我们将最后一个 $\tt{0}$ 改为 $\tt{1}$ 即可切断联系。
根据上述做法递归前缀即可。
使用 KMP 求前缀最长 border,注意到 $2l<n$ 时每层规模折半,$2l\ge n$ 时直接复制,由递归式 $T(n)=T\left(\dfrac{n}{2}\right)+O(n)$ 得复杂度 $O(n)$,注意精细实现。
::::::
::::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n, f[N], g[N];
char s[N], t[N];
void kmp(int n, char* s, int* pi) {
for (int i = 2; i <= n; i++) {
int j = pi[i - 1];
while (j > 0 && s[j + 1] != s[i]) j = pi[j];
if (s[j + 1] == s[i]) j++;
pi[i] = j;
}
}
void solve(int n) {
if (n == 0) return;
if (n == 1) return t[n] = '0', void();
int l = f[n];
if (l == 0) return fill(t + 1, t + n, '0'), t[n] = '1', void();
solve(l);
if (2 * l >= n) return copy(t + 2 * l - n + 1, t + l + 1, t + l + 1), void();
copy(t + 1, t + l + 1, t + n - l + 1);
fill(t + l + 1, t + n - l + 1, '0');
kmp(n, t, g);
auto chk = [&]() -> bool {
for (int i = l, j = g[n]; i > 0 && j > 0; i = f[i], j = g[j]) {
if (i != j) return false;
if (i == 0 || j == 0) return (i == 0) && (j == 0);
}
return true;
};
if (!chk()) t[n - l] = '1';
}
void _main() {
cin >> (s + 1); n = strlen(s + 1);
kmp(n, s, f), solve(n);
for (int i = 1; i <= n; i++) cout << t[i];
cout << '\n';
}
```
::::::
## [P9070 [CTS2023] 琪露诺的符卡交换](https://www.luogu.com.cn/problem/P9070)
> 给定一个 $n\times n$ 的矩阵 $a_{i,j}$,保证 $1\sim n$ 恰好出现 $n$ 次。每次操作可以重排一行,或者交换两个元素,要求同一个元素不能被交换两次。
>
> 目标为每一行都是 $1\sim n$ 的排列。输出方案或报告无解。
>
> 多测,$\sum n\le200$,1 秒,512 MB。
:::::success[题解]
考虑 Subtask 1。我们可以用下图所示的操作将矩阵转置:

上图中,同色的两个数进行交换。形象地说,相当于沿着主对角线对称地进行交换。
尝试将问题规约到平凡情形。
考虑二分图建模,左部点为 $1\sim n$ 行,右部点为 $1\sim n$ 的数值。令第 $i$ 行向 $a_{i,1},a_{i,2},\cdots,a_{i,n}$ 连边,注意这里不忽略重边。
找出一组完美匹配 $M$。我们将 $M$ 中的 $n$ 个数值,经过行内重排全部放到矩阵的第 $1$ 列,使得第 $1$ 列是一个 $1\sim n$ 的排列,通过逐列处理,我们可以让 $1\sim n$ 列都是一个 $ 1\sim n$ 的排列,然后用平凡构造将矩阵转置。
注意到这是一张 $n$ 正则二分图,只要将其分解成 $n$ 组不交完美匹配。最优复杂度 $O(n^2\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 205;
int n, x[N*N], y[N*N], mp[N][N];
using edges_t = vector<vector<pair<int, int>>>;
int mat[2][N], pos[N], col[N*N];
void GKK(int k, const edges_t& e) {
fill(pos, pos + n + 1, -1), fill(mat[0], mat[0] + n + 1, 0), fill(mat[1], mat[1] + n + 1, 0);
for (int s = 1; s <= n; s++) {
if (mat[0][s]) continue;
vector<int> px = {s}, py, pid;
pos[s] = 0;
while (true) {
int u = px.back(), v, id;
do tie(v, id) = e[u][rand32() % k]; while (id == mat[0][u]);
if (!mat[1][v]) {
py.emplace_back(v), pid.emplace_back(id);
for (int i = 0; i < (int)px.size(); i++) {
int x = px[i], y = py[i], id = pid[i];
mat[0][x] = id, mat[1][y] = id, pos[x] = -1;
} break;
}
int w = x[mat[1][v]];
if (pos[w] != -1)
while ((int)px.size() - 1 > pos[w])
pos[px.back()] = -1, px.pop_back(), py.pop_back(), pid.pop_back();
else
py.emplace_back(v), pid.emplace_back(id), pos[w] = px.size(), px.emplace_back(w);
}
}
}
int hd[2*N], vis[N*N], ans[N*N];
void solve(int k, const edges_t& e, int off) {
if (k == 0) return;
if (k == 1) {
for (int u = 1; u <= n; u++)
for (auto [v, id] : e[u]) col[id] = off;
return;
}
if (k & 1) {
GKK(k, e); edges_t ne(n + 5);
for (int u = 1; u <= n; u++)
for (auto [v, id] : e[u]) {
if (mat[0][u] == id) col[id] = off;
else ne[u].emplace_back(v, id);
}
solve(k - 1, ne, off + 1);
} else {
edges_t g(2*n + 5);
vector<int> eid;
for (int u = 1; u <= n; u++)
for (auto [v, id] : e[u]) {
g[u].emplace_back(v + n, id);
g[v + n].emplace_back(u, id);
eid.emplace_back(id);
}
fill(hd + 1, hd + 2*n + 1, 0);
for (int i : eid) vis[i] = false, ans[i] = -1;
auto dfs = [&](auto&& dfs, int u) -> void {
for (int& i = hd[u]; i < (int)g[u].size(); ) {
auto [v, id] = g[u][i++];
if (vis[id]) continue;
vis[id] = true, dfs(dfs, v), ans[id] = u > n;
}
};
for (int i = 1; i <= 2*n; i++) dfs(dfs, i);
edges_t e1(n + 5), e2(n + 5);
for (int u = 1; u <= n; u++)
for (auto [v, id] : e[u])
if (!ans[id]) e1[u].emplace_back(v, id);
else e2[u].emplace_back(v, id);
solve(k / 2, e1, off), solve(k / 2, e2, off + k / 2);
}
}
void _main() {
cin >> n; int tot = 0;
edges_t e(n + 5);
for (int i = 1; i <= n; i++)
for (int j = 1, v; j <= n; j++) {
cin >> v; tot++;
e[i].emplace_back(v, tot);
x[tot] = i, y[tot] = j;
}
solve(n, e, 1);
for (int i = 1; i <= tot; i++) mp[x[i]][col[i]] = y[i];
cout << n * (n - 1) / 2 << '\n';
for (int i = 1; i <= n; i++)
for (int j = 1; j < i; j++)
cout << i << ' ' << mp[i][j] << ' ' << j << ' ' << mp[j][i] << '\n';
}
```
:::::
## [QOJ17160 Multiset Variance](https://qoj.ac/problem/17160)
> 给出 $n$ 个可重集 $S_i$。初始有一个空多重集 $M$,你可以执行任意多次 $M\gets M\cup S_i$ 的操作,要求最终 $M$ 非空。分别最小化 / 最大化 $M$ 的方差并输出。
>
> 多测,$n\le10^5$,$1\le|S_i|\le10$,$\sum|S_i|\le10^6$,2 秒,1024 MB。
:::::success[题解]
设在最终的集合 $M$ 中,来自 $S_i$ 的元素占比为 $p_i$。显然,所有 $p_i$ 满足 $p_i\ge0$ 且 $\sum\limits_{i=1}^n p_i=1$。由于操作次数充分多,$p_i$ 可以取 $[0,1]$ 间的任意有理数。
另一方面,我们注意到方差定义式可以变形为
$$
\dfrac{1}{n}\sum_{i=1}^n(a_i-\overline a)^2=\left(\dfrac{1}{n}\sum_{i=1}^n a_i^2\right)-\left(\dfrac{1}{n}\sum_{i=1}^n a_i\right)^2
$$
故只要关心平均数和平方的平均数。
据此,考虑预处理每个集合 $S_i$ 的平均数 $b_i$ 和平方的平均数 $a_i$。代入变形式得到 $M$ 的方差
$$
V=\sum_{i=1}^n p_ia_i-\left(\sum_{i=1}^n p_i b_i\right)^2
$$
先考虑最小化 $V$。
注意到 $V$ 是由一个线性函数减去一个凸函数得到的,所以 $V$ 是一个关于 $p_i$ 的严格凹函数。想象一个高维抛物面,其最小值必然在顶点处取得,而顶点坐标必有 $p_i=1$。因此,最小方差就是单独取一个集合 $S_i$ 的方差。只要求得 $V_{\min}=\min\limits_{i=1}^n(a_i-b_i^2)$ 即可。
再考虑最大化 $V$。
将集合 $S_i$ 刻画为二维平面上的点 $(b_i,a_i)$。由于 $p_i$ 的约束,任意一种方案得到的混合均值 $(b,a)=\left(\sum\limits_{i=1}^n p_ib_i,\sum\limits_{i=1}^n p_ia_i\right)$ 都可以对应到这 $n$ 个点形成的**凸包**内部或边界上的有理点。
此时我们要最大化 $V=y-x^2$。对于恒定的 $x$,我们希望最大化 $y$,因此使方差最大化的点必定在上凸壳的边界上。
而上凸壳是由一系列连接两点的线段组成的。这表明,$V_{\max}$ 必定可以通过至多两个集合取到。因此,我们只要先求出上凸壳,再求出 $y-x^2=V$ 过某一点或与某条直线相切的最大值。
下面的讨论暂时忽略有理点的限制。
首先,若 $V$ 在顶点处取得最大值,这直接对应了选一个集合的情形,答案即为 $a_i-b_i^2$ 求 $\max$。显然点是有理点。
其次,若 $V$ 在切线处取得最大值,如图:

考虑使用解析几何的知识解决。设直线 $BC$ 的方程为 $y=kx+b$,联立抛物线方程 $y=x^2+V$ 得 $x^2-kx+V-b=0$。令 $\Delta=k^2-4(V-b)=0$ 得 $V=\frac{k^2}{4}+b$。
由点斜式可以算出 $k,b$ 均为有理数。切点的横坐标满足 $k=y'=2x$,故 $x$ 也是有理数,代入 $y=kx+b$ 知切点必为有理点。
最终,本题只需要求出凸包,按照上述情况讨论即可,复杂度 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
#define double long double
#define x first
#define y second
const int N = 1e5 + 5;
const double eps = 1e-12;
int n;
vector<int> a[N];
using node = pair<double, double>;
node p[N], st[N * 2];
double var(const vector<int>& a) {
double e = accumulate(a.begin(), a.end(), 0.0)/a.size(), v = 0;
for (int i : a) v += (i - e) * (i - e);
return v / a.size();
}
bool check(const node& a, const node& b, const node& p) {
node x = {b.x - a.x, b.y - a.y}, y = {p.x - a.x, p.y - a.y};
return x.x * y.y - x.y * y.x < 0;
}
int andrew() {
if (n == 1) return 0;
sort(p + 1, p + n + 1), n = unique(p + 1, p + n + 1) - p - 1;
int top = -1; st[++top] = p[1], st[++top] = p[2];
if (n == 2) return 1;
for (int i = 3; i <= n; i++) {
while (top && check(st[top-1], st[top], p[i])) top--;
st[++top] = p[i];
}
st[++top] = p[n-1];
for (int i = n-2; i >= 1; i--) {
while (top && check(st[top-1], st[top], p[i])) top--;
st[++top] = p[i];
} return top;
}
double solve(node u, node v) {
if (abs(u.x - v.x) < eps) return 0;
if (u.x > v.x) swap(u, v);
double k = (u.y - v.y) / (u.x - v.x), b = u.y - k * u.x;
if (k / 2 < u.x || k / 2 > v.x) return 0;
return k * k / 4 + b;
}
void _main() {
cin >> n;
double mn = 1e40, mx = 0;
for (int i = 1, k, x; i <= n; i++) {
a[i].clear();
i128 s = 0, t = 0;
for (cin >> k; k--; )
cin >> x, a[i].emplace_back(x), s += x, t += 1LL * x * x;
chkmin(mn, var(a[i]));
p[i] = {1.0*s/a[i].size(),1.0*t/a[i].size()};
chkmax(mx, p[i].y - p[i].x * p[i].x);
}
if (n == 1) return cout << mn << ' ' << mn << '\n', void();
int m = andrew();
for (int i = 1; i <= m; i++) chkmax(mx, solve(st[i-1], st[i]));
chkmax(mx, solve(st[0], st[m]));
cout << mn << ' ' << mx << '\n';
}
```
:::::
## [QOJ7578 Salty Fish](https://qoj.ac/problem/7578)
> 给出一棵 $n$ 个节点的有根树,根节点为 $1$。点有点权 $a_i$。
>
> 你可以选择若干节点,并获得点权之和的得分。
>
> 再给出 $m$ 条限制 $(x_i,k_i,c_i)$,表示节点 $x_i$ 的子树中与 $x_i$ 距离 $\le k_i$ 的点不可选择。距离定义为两点间路径的边数。
>
> 你可以扣除 $c_i$ 的得分解除第 $i$ 条限制。最大化得分并输出。
>
> $n,m\le3\times10^5$,$0\le k_i\le n$,3 秒,512 MB。
:::::success[题解]
考虑先选择所有节点,再放弃一部分,并且解除一些限制使得没有放弃的节点可以被选择。将代价定义为放弃节点的点权加上解除限制的代价,问题转化成最小化代价。
这可以用网络流的集合划分模型描述。考虑如下建边:
- $S\to i+n$,容量 $c_i$ 表示解除限制 $i$ 的代价。
- $u\to T$,容量 $a_u$ 表示放弃节点 $u$ 的代价。
- $i+n\to v$,其中 $v$ 为被限制 $i$ 控制的节点,容量 $+\infty$。
这样一组方案对应了 $S\to T$ 的一个割,答案即为最小割。
直接用 Dinic 可以做到 $O(n^3)$,对第三类边优化建图可以做到 $O(n^2\log n)$,都无法通过。
我们将最小割对偶成最大流,问题转化为:
- $m$ 个限制 $(x_i,k_i,c_i)$ 相当于源点,可以向 $x_i$ 子树内深度不超过 $d_{x_i}+k_i$ 的点最多提供 $c_i$ 的流量。
- $n$ 个节点 $u$ 相当于汇点,最多可以接受 $a_u$ 的流量。
只要求出最大总流量。这是一个匹配问题,考虑自底向上贪心匹配。
当我们位于节点 $u$ 并处理源点 $(u,k,c)$ 时,我们希望用它来优先匹配深度尽量大的可用汇点。这是因为,较浅的汇点可以被更浅的源点匹配,而较深的汇点无法被匹配,因此会丢失一部分流量,这是不优的。
实现时,我们用 std::map 来存储子树中的汇点信息,用启发式合并维护,复杂度是 2log 的。细节上,注意将同一节点上的限制按照 $k_i$ 升序排序。
最终复杂度 $O(n\log^2 n+m\log n)$。也存在使用长链剖分的单 $\log$做法。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 3e5 + 5;
int n, m, fa[N], a[N], dep[N];
vector<pair<int, i64>> op[N];
vector<int> e[N];
map<int, i64> mp[N];
i64 tot;
void dfs(int u) {
for (int v : e[u]) {
dep[v] = dep[u] + 1, dfs(v);
if (mp[v].size() > mp[u].size()) swap(mp[u], mp[v]);
for (auto& [d, c] : mp[v]) mp[u][d] += c;
}
mp[u][dep[u]] += a[u];
for (auto [k, c] : op[u]) {
while (!mp[u].empty() && c > 0) {
auto it = mp[u].upper_bound(dep[u] + k);
if (it == mp[u].begin()) break;
it--; i64 f = min(c, it->second);
c -= f, tot += f, it->second -= f;
if (it->second == 0) mp[u].erase(it);
}
}
}
void _main() {
cin >> n >> m, tot = 0;
for (int i = 1; i <= n; i++) e[i].clear(), op[i].clear(), mp[i].clear();
for (int i = 2; i <= n; i++) cin >> fa[i], e[fa[i]].emplace_back(i);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1, u, k, c; i <= m; i++) cin >> u >> k >> c, op[u].emplace_back(k, c);
for (int i = 1; i <= n; i++) sort(op[i].begin(), op[i].end());
dfs(1);
cout << accumulate(a + 1, a + n + 1, 0LL) - tot << '\n';
}
```
:::::
## [AGC004F Namori](https://www.luogu.com.cn/problem/AT_agc004_f)
> 给定一张 $n$ 个点 $m$ 条边的简单无向连通图,保证 $\textcolor{red}{m\in\{n-1,n\}}$。每个顶点写有 $0$ 和 $1$,初始全为 $0$。
>
> 一次操作选择一条边,满足两端点上数字相同,将两端点上的数字同时 flip。
>
> 目标为所有顶点上的数字均为 $1$。最小化操作次数并输出,或报告无解。
>
> $n \le 10^5$,2 秒,256 MB。
:::::success[题解]
首先判掉 $n$ 为奇数时无解,证明显然。
先来解决 $m=n-1$,即树的问题。
题意中 $00 \to 11, 11\to 00$ 的刻画不够自然。考虑 01 串邻位 trick。
我们将树黑白染色,将黑色点上的数字 flip 掉。操作被重新刻画为 $01 \to 10, 10 \to 01$,即交换相邻 $01$。目标为对调 $01$。
随意定根后,设 $u$ 子树中有 $c_0$ 个 $0$ 和 $c_1$ 个 $1$。则必有 $|c_0-c_1|$ 个数要跨越 $u \to \text{fa}_u$ 的边。记 $a_u=c_0-c_1$,从而 $\sum |a_u|$ 是答案下界。记 $C_0,C_1$ 为整棵树的 $0,1$ 数,则有解的必要条件是 $C_0=C_1$,否则无法对调。
这个下界可以用调整法取到。从而我们解决了树的情形,[submission](https://atcoder.jp/contests/agc004/submissions/78150864)。
考虑 $m=n$ 的基环树。我们对环边的端点颜色进行讨论:
**Case 1** 环边相邻端点异色,即存在奇环。
考虑如下刻画:将 $0$ 的权值记作 $1$,$1$ 的权值记作 $-1$,将 $a_u$ 定义为子树权值和。
可以发现,此时环边的作用仅有调整 $01$ 的数目。具体地,对环边操作一次,可以使得 $0$ 的数目 $+2$ 或 $1$ 的数目 $+2$,这与环边的端点颜色有关。
记 $d=\frac{C_0-C_1}{2}$,则 $d$ 即为环边的操作次数。令环边两端权值减去 $d$ 后求子树和即为答案。
**Case 2** 环边相邻端点同色,即存在偶环。
此时环边的操作次数 $d$ 无法直接算出,我们考虑 $d$ 的影响。
实际上,环边会在环上贡献一个循环流量 $d$,故答案形如 $|d|+\sum\limits_{ i\in C} |a_i+d|$。我们将 $0$ 和环点的 $-a_i$ 塞到一个序列里排序,取中位数作为 $d$ 即为最优。
复杂度 $O(n \log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e5 + 5;
int n, m;
vector<int> e[N];
int op, s, t, a[N], pa[N], val[N], col[N], dep[N], onc[N], cnt[2][N];
void dfs(int u, int fa) {
cnt[col[u]][u] = 1, pa[u] = fa;
for (int v : e[u]) {
if (v == fa) continue;
if (col[v] != -1) {
if (dep[v] < dep[u]) op = col[u] == col[v], s = u, t = v;
continue;
}
col[v] = col[u] ^ 1, dep[v] = dep[u] + 1, dfs(v, u);
cnt[0][u] += cnt[0][v], cnt[1][u] += cnt[1][v];
}
a[u] = cnt[0][u] - cnt[1][u];
}
void dfs2(int u, int fa) {
a[u] = val[u];
for (int v : e[u]) {
if (v == fa || (u == s && v == t) || (u == t && v == s)) continue;
dfs2(v, u), a[u] += a[v];
}
}
void _main() {
cin >> n >> m;
if (n & 1) return cout << -1, void();
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v;
e[u].emplace_back(v), e[v].emplace_back(u);
}
fill(col + 1, col + n + 1, -1);
col[1] = 0, dfs(1, -1);
int c0 = cnt[0][1], c1 = cnt[1][1];
if (m == n - 1) {
if (c0 != c1) return cout << -1, void();
i64 res = 0;
for (int i = 1; i <= n; i++) res += abs(a[i]);
return cout << res, void();
}
for (int i = 1; i <= n; i++) val[i] = col[i] == 0 ? 1 : -1;
if (op == 1) {
int d = c0 - c1;
if (d & 1) return cout << -1, void();
d /= 2, val[s] -= d, val[t] -= d;
dfs2(1, -1); i64 res = abs(d);
for (int i = 1; i <= n; i++) res += abs(a[i]);
return cout << res, void();
}
if (c0 != c1) return cout << -1, void();
vector<i64> p = {0};
for (int u = s; u != t; u = pa[u])
p.emplace_back(-a[u]), onc[u] = true;
sort(p.begin(), p.end());
i64 d = p[p.size() / 2], res = abs(d);
for (int u = s; u != t; u = pa[u]) res += abs(a[u] + d);
for (int i = 1; i <= n; i++) if (!onc[i]) res += abs(a[i]);
cout << res;
}
```
:::::
## [P9499 「RiOI-2」change](https://www.luogu.com.cn/problem/P9499)
>现有$n$ 类物品 $(v_i,c_i)$,第 $i$ 类物品有 $c_i$ 个,单价为 $v_i$。再给出 $n-1$ 个正整数 $x_i$,一次操作可以将 $x_i$ 个 $i$ 类物品换成 $1$ 个 $i+1$ 类物品。
>
> 形式化地,给出 $n$ 个二元组 $(v_i,c_i)$,定义得分为 $\sum\limits_{i=1}^n c_iv_i$。一次操作选择一个 $i$ 使得 $c_i\ge x_i$,令 $c_i\gets c_i-x_i,c_{i+1}\gets c_{i+1}+1$。
>
> 最大化得分并对 $998244353$ 取模后输出。
>
> 多测,$\sum n\le2\times10^5$,$0\le x_i,c_i,v_i\le10^9$,1 秒,128 MB。
:::::success[题解]
平凡贪心是能换就换。这个策略只有在 $v_i\ge v_{i-1}x_{i-1}$ 时正确。
引入反悔贪心,动态调整的思想。我们仍然沿用能换就换的贪心策略,但保留反悔机会,若发现当前状态不优,就把一个物品拆开再得到原本的价值。
先不管复杂度,尝试构造反悔信息。我们对每个物品记录一个属性 $w$ 表示合成它的成本。如果最终将这个物品反悔掉,$w$ 就是我们能获得的保底得分。
我们顺次扫描 $i=1,2,\cdots,n$ 类物品,对每类物品执行如下流程:
- 遍历当前物品,令 $w\gets\max(w,v_i)$。操作的意义是,如果 $i$ 类物品的价值高于合成某个物品的成本,反悔时只要拆到 $i$ 类物品,总收益会更高。
- 将当前物品按 $w$ 升序排序,每次取出 $x_i$ 个 $w$ 最小的物品,将其 $w$ 累加并合成一个 $i+1$ 类物品。
- 将凑不够 $x_i$ 个的物品反悔掉,直接加入答案得分中。上一步中,我们选取的是 $w$ 小的物品,保证了这一步的最优性。
综上,我们得到了一个有正确性的算法。只要设法维护这个过程。
考虑用小根堆维护 $(w,\text{cnt})$ 二元组,表示当前成本为 $w$ 的物品有 $\text{cnt}$ 个,每轮中模拟上述流程,复杂度会爆。
注意到 $x_i=1$ 时不需要任何修改,可以将堆直接滚动到下一轮。事实上,加上这个剪枝后我们的复杂度就是正确的了。
这是因为,当 $x_i\ge2$ 时物品的总数至少折半,故 $\text{cnt}$ 之和在 $O(\log V)$ 次操作内就会变成一个常数,而堆的大小不会大于这个数,这样均摊下来复杂度就是 $O(n\log V)$。
代码实现时注意使用 int128 存变量。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5;
int n;
i128 v[N], c[N], x[N];
using node = pair<i128, i128>; // {w, cnt}
using box = priority_queue<node, vector<node>, greater<node>>;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> v[i];
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 1; i < n; i++) cin >> x[i];
box q; i128 res = 0;
for (int i = 1; i <= n; i++) {
if (c[i] > 0) q.emplace(v[i], c[i]);
i128 uc = 0;
while (!q.empty() && q.top().fi < v[i]) uc += q.top().se, q.pop();
if (uc > 0) q.emplace(v[i], uc);
if (i == n) {
while (!q.empty()) {
auto [w, cnt] = q.top(); q.pop();
res += w * cnt;
} break;
}
if (x[i] == 1) continue;
box nq;
i128 rw = 0, rcnt = x[i];
while (!q.empty()) {
auto [w, cnt] = q.top(); q.pop();
if (cnt < rcnt) {
rw += w * cnt, rcnt -= cnt;
} else {
rw += w * rcnt, cnt -= rcnt, nq.emplace(rw, 1);
if (cnt >= x[i]) nq.emplace(w * x[i], cnt / x[i]);
rw = cnt % x[i] * w, rcnt = x[i] - cnt % x[i];
}
}
if (rcnt < x[i]) res += rw;
q.swap(nq);
}
cout << static_cast<i64>(res % 998244353) << '\n';
}
```
:::::
## [P14002 [eJOI 2025] Navigation](https://www.luogu.com.cn/problem/P14002)
> 现有未知无向简单连通仙人掌图,节点数为 $n$。有一个无记忆的机器人在图上游走,每次可以获取当前点和邻域的颜色,需要将当前点染色后,走向一个邻居。邻域颜色给出的顺序是确定的。
>
> 构造机器人的策略,使得机器人可以在 $L$ 步内走过所有点,并且可以判断何时终止。记使用的颜色数为 $D$。
>
> 采用通信方式提交。$n\le10^3$,满分要求 $L\le3\times10^3,D\le4$。
:::::success[题解]
考虑树的部分分。采用三染色 DFS 的做法,用 $0$ 表示未访问,$1$ 表示访问中,$2$ 表示访问完成。在某个节点上时,如果邻域有 $0$ 就走向它,并将原节点标记为 $1$。否则说明需要回溯,找到唯一的 $1$ 走向,并将原节点标记为 $2$。可以获得 38pts。
进一步,尝试走出仙人掌的 DFS 生成树。熟知无向图 DFS 树不存在横叉边,只需讨论返祖边对策略的干扰。

如上图,我们发现原策略会在这种情况下爆掉。当我们位于返祖边的一个端点时,其邻域没有 $0$ 且同时存在多个 $1$。如果错误地走了红色的路线,就会离开这棵子树,从而漏掉一些点。正确的遍历顺序是走绿色路线。
上面的做法里,我们有两个信息没有用到:颜色 $ 3$ 和当前点颜色。考虑使用这些额外信息区分环上的点。
假设出问题的点是 $u$,其 DFS 树上的父亲为 $p$,返祖边指向的祖先为 $v$。无法直接区分 $p$ 和 $v$,只能随意走向一个节点进行尝试。
我们将 $u$ 点的颜色记为 $3$,并且定义一个节点的活跃度为:当前节点邻域中颜色 $1$ 的数目。对 $p$ 和 $v$ 的活跃度进行观察:

可以发现,$p$ 点的活跃度只能是 $1$,而 $v$ 点的活跃度至少是 $2$,因为 $v$ 点有向环和向父亲的两个颜色 $1$。因此,通过数颜色 $1$ 的数目就可以区分 $p$ 和 $v$。
我们来描述这个试错的过程。当机器人位于点 $w$ 时,其邻域存在颜色 $3$,这说明 $w$ 是一个正在试错的点。通过数活跃度的方法,我们可以知道 $w$ 是 $p$ 还是 $v$。
现在的关键是,如果 $w$ 发现自己是 $v$,即尝试失败,那么 $w$ 需要修改颜色来告诉 $u$。于是我们将 $w$ 标记为 $3$ 并退回 $u$。此时 $u$ 点自身的颜色是 $3$,且 $u$ 可以看到 $w$ 点的颜色也是 $3$,这就说明 $w$ 不是 $p$,于是 $u$ 就会走向另一个邻居,也就找到了正确的 $p$。
找到 $p$ 以后,我们将 $u$ 点的颜色标记为 $2$,然后走向 $v$ 进行清理。在这些操作结束后,我们就可以正常回溯,并顺着 DFS 树继续遍历了。
至此我们已经能解决起点不在环上的情形,期望得分 65pts。下面我们说明,起点在环上的情形仍然可以使用这个做法。
考虑起点在环上为啥会爆。我们发现此时的活跃度处理问题,即 $v$ 点的活跃度有可能是 $1$,所以有可能会把 $v$ 当成 $p$。
我们要说明,把 $v$ 作为新的父亲,仍然可以得到正确的 DFS 生成树。

如图所示,我们期望的路径是绿色路径。但实际上,考虑 $u\to v$ 后将 $u$ 标记为 $2$,环上的节点会被顺次遍历,最终只会换一个方向走完这个环,而并不会漏掉某些节点,只会让步数变多。
朴素 DFS 的步数为 $2n$。考虑用上述策略遍历一个环时,步数会增加一个不超过 $2$ 的常数。感性理解一下环的数目不会很多,重复过两遍环也不会跑满,因此步数不会超过 $3n$。
:::::
:::::info[代码]
```cpp line-numbers
pair<int, int> navigate(int currColor, std::vector<int> adjColors) {
int cur = currColor;
vector<int>& e = adjColors;
int c0 = count(e.begin(), e.end(), 0), c1 = count(e.begin(), e.end(), 1),
c2 = count(e.begin(), e.end(), 2), c3 = count(e.begin(), e.end(), 3);
int p0 = -1, p1 = -1, p2 = -1, p3 = -1, p12 = -1;
for (int i = 0; i < (int)e.size(); i++) {
if (e[i] == 0 && p0 == -1) p0 = i;
if (e[i] == 1) {
if (p1 == -1) p1 = i;
else if (p12 == -1) p12 = i;
}
if (e[i] == 2 && p2 == -1) p2 = i;
if (e[i] == 3 && p3 == -1) p3 = i;
}
if (cur == 0) {
if (c0 != 0) return {1, p0};
if (c1 >= 2) return {3, p1};
if (c1 == 1) return {2, p1};
}
if (cur == 1) {
if (c3 != 0) {
if (c1 <= 1) return {3, p3}; // w=p
return {1, p3}; // w=v
}
if (c0 != 0) return {1, p0};
if (c1 >= 2) return {3, p1}; // ask v&p
if (c1 == 1) return {2, p1};
}
if (cur == 3) {
if (c3 != 0) return {2, p3};
if (c1 >= 2) return {2, p12}; // ask next
if (c0 != 0) return {1, p0};
if (c1 == 1) return {2, p1};
}
return {-1, -1};
}
```
:::::
## [ZR3318 划分](https://zhengruioi.com/problem/3318)
> 现有数列 $a=[1,2,\cdots,4n+2]$。称点对 $(i,j)$ 为好的,当且仅当 $1\le i<j\le4n+2$ 且在 $a$ 中删去 $i,j$ 后,剩余 $4n$ 个数可以划分为 $n$ 个长为 $4$ 的等差数列。
>
> 输出所有的好点对,并分别构造划分方案。
>
> 部分分:记 $k=\binom{4n+2}{2}$,点对数量超过 $\frac{k}{16}$ 获得 $20\%$ 分数;点对数量超过 $\frac{k}{8}$ 获得 $60\%$ 分数。
>
> 多测,$\sum n\le200$,3 秒,512 MB。
:::::success[题解]
显然 $n=1$ 时有 $3$ 个好点对 $(1,6),(1,2),(5,6)$。
通过手玩 $n=2$,可以找到至少 $6$ 个好点对 $(1,2),(9,10),(1,10),(1,6),(5,6),(5,10)$。这些点对的共同特点是:删去 $i,j$ 后,形成的连续段长度均为 $4$ 的倍数,可以直接划分为公差为 $1$ 的等差数列。
观察下标,我们可以发现 $i\bmod4,j\bmod4$ 均为定值。记 $i=4a+1,j=4b+2$,则 $0\le a\le b\le n$ 的 $(i,j)$ 均合法,记为一类点。
一类点的数目共有 $\binom{n+1}{2}$ 个,达到了 $\frac{k}{16}$,可以获得 20pts。
观察 $n=3$,我们发现 $(2,13)$ 是好点对,存在划分 $[1,4,7,10],[3,6,9,12],[5,8,11,14]$。考虑能否推广这个发现:
- $n=4$ 时 $(2,17)$ 是好点对,存在划分 $[1,5,9,13],[3,7,11,15],[4,8,12,16],[6,10,14,18]$,公差均为 $4$;
- $n=5$ 时 $(2,21)$ 是好点对,存在划分 $[1,6,11,16],[3,8,13,18],[4,9,14,19],[5,10,15,20],[7,12,17,22]$,公差均为 $5$;
- $(2,4n+1)$ 是好点对,存在划分且公差均为 $n$。
如果你注意力不好,你也可以使用下文的 DFS 来得到这个观察。
上述发现的意义在于,如果我们钦定了两个位置 $i=4a+2,j=4b+1$,则 $[i-1,j+1]$ 可以用上述方式划分,而 $[1,i-2]$ 和 $[j+2,4n+2]$ 长度均为 $4$ 的倍数,方案是平凡的。

如图所示,橙色部分可以等价于 $n=3$ 的构造,而两边的绿色部分直接划成若干公差为 $1$ 的等差数列。
因此 $0\le a,b\le n\land b-a\ge2$ 的 $(i,j)$ 均合法,称之为二类点。二类点的总数为 $\binom{n-1}{2}$。
此时点对数目 $k'=\binom{n+1}{2}+\binom{n-1}{2}>\frac{k}{16}$,可以通过 24 年新一卷 T19。提交后获得了 64pts。
::::info[代码]
```cpp line-numbers
int n;
using node = pair<int, int>;
vector<node> A, B;
void _main() {
cin >> n;
A.clear(), B.clear();
for (int a = 0; a <= n; a++) {
for (int b = a; b <= n; b++) A.emplace_back(4 * a + 1, 4 * b + 2);
}
for (int a = 0; a <= n; a++) {
for (int b = a + 2; b <= n; b++) B.emplace_back(4 * a + 2, 4 * b + 1);
}
cout << A.size() + B.size() << '\n';
for (auto [x, y] : A) {
printf("( %d , %d )", x, y);
for (int i = 1; i <= n; i++) printf(" %d %d %d %d", i, i, i, i);
cout << '\n';
}
for (auto [x, y] : B) {
printf("( %d , %d )", x, y);
int c = 0, len = (y - x + 3) / 4;
for (int i = 1; i <= x - 2; i += 4) c++, printf(" %d %d %d %d", c, c, c, c);
for (int i = x - 1; i <= y + 1; i++) {
if (i == x || i == y) continue;
printf(" %d", c + i % len + 1);
}
c += len;
for (int i = y + 2; i <= 4 * n + 2; i += 4) c++, printf(" %d %d %d %d", c, c, c, c);
cout << '\n';
}
}
```
::::
思考问题出现在哪里。我们写一个 DFS,在 $n\le5$ 时上述做法达到了上确界。但是根据搜索结果,$n=6$ 时有 $45$ 个点对,而我们的做法只能找到 $43$ 个点对,剩余两个如下:
- $(10,13)$ 有划分 $[1,9,17,25],[2,4,6,8],[3,7,11,15],[5,12,19,26],[14,16,18,20],[21,22,23,24]$;
- $(14,17)$ 由对称性同理。
进一步对 $n=7,8,9,10$ 的搜索结果表明,当 $n=8$ 时 $b-a=1$ 的 $i=4a+2,j=4b+1$ 全部存在解,称这类点对为三类点。$n=9,10$ 时的解有且仅有一二三类点。
对于 $n=6,7,8$ 的情形,强行跑搜索即可。对于 $n>8$ 的情形,考虑归纳构造。
观察 $n=8$ 时的所有解:
```plain line-numbers
( 2 , 5 ) 1 2 1 3 1 4 3 1 4 3 2 4 3 5 4 6 6 6 6 5 2 7 7 7 7 5 8 8 8 8 2 5
( 6 , 9 ) 1 2 1 3 1 1 2 3 4 5 4 2 4 3 4 5 6 2 6 3 6 5 6 7 7 7 7 5 8 8 8 8
( 10 , 13 ) 1 1 1 1 2 3 2 4 2 2 3 4 5 6 5 3 5 4 5 6 7 3 7 4 7 6 7 8 8 8 8 6
( 14 , 17 ) 1 1 1 1 2 3 4 3 5 3 4 3 2 4 5 6 4 6 2 6 5 6 7 7 7 7 2 5 8 8 8 8
( 18 , 21 ) 1 1 1 1 2 2 2 2 3 4 5 4 6 4 5 4 3 5 6 7 5 7 3 7 6 7 8 8 8 8 3 6
( 22 , 25 ) 1 1 1 1 2 2 2 2 3 4 5 5 5 5 6 3 6 4 6 7 6 3 7 4 8 7 8 3 8 7 8 4
( 26 , 29 ) 1 1 1 1 2 3 2 4 2 4 2 4 5 4 3 6 5 6 7 6 5 6 7 3 5 7 8 8 7 8 3 8
( 30 , 33 ) 1 2 3 3 3 3 1 4 4 4 4 2 1 5 5 5 5 6 1 7 6 2 7 6 8 7 6 8 7 8 2 8
```
排除公差为 $1$ 的平凡划分后,可以发现,所有三类点只会来源于如下三种结构:
- $a=0$,长度 $34$,缺失相对位置 $2,5$;
- $a=1$,长度 $30$,缺失相对位置 $6,9$;
- $a=2,3,4$,长度 $26$,缺失相对位置 $10,13$。
根据对称性,$a=5,6,7$ 同理。观察上面的结构,我们发现前两种属于边界情况,最后一种是通用构造。
对于长为 $34$ 的构造,在 $n$ 较小时无法实现,这也解释了为什么 $n<8$ 时三类点不全成立。
将三种构造方法打表到代码中,并根据 $a$ 分类讨论进行构造。多余的段直接划分为公差为 $1$ 的块,做归纳构造,可以得到合法的解。
提交后发现上述做法达到了精确上界,可以通过。
:::::
:::::info[代码]
```cpp line-numbers
int n;
using node = pair<int, int>;
vector<node> A, B, C;
using vecw = vector<array<int, 4>>;
vecw way;
bool dfs(vector<int> vec) {
auto lb = [&](int x) -> vector<int>::iterator {
auto it = lower_bound(vec.begin(), vec.end(), x);
return it == vec.end() ? it : (*it == x ? it : vec.end());
};
if (vec.size() == 4) {
if (vec[1] - vec[0] != vec[2] - vec[1]) return false;
if (vec[2] - vec[1] != vec[3] - vec[2]) return false;
way.push_back({vec[0], vec[1], vec[2], vec[3]});
return true;
}
vector<int> pre(vec.begin(), vec.end());
for (int d = 1; d <= 4 * n; d++) {
int v1 = vec[0], v2 = vec[0] + d, v3 = vec[0] + 2 * d, v4 = vec[0] + 3 * d;
if (lb(v2) == vec.end() || lb(v3) == vec.end() || lb(v4) == vec.end()) continue;
vec.erase(vec.begin()), vec.erase(lb(v2)), vec.erase(lb(v3)), vec.erase(lb(v4));
way.push_back({v1, v2, v3, v4});
if (dfs(vec)) return true;
vec = pre, way.pop_back();
}
return false;
}
void bf() {
vector<pair<node, vecw>> ans;
for (int i = 1; i <= 4 * n + 2; i++) {
for (int j = i + 1; j <= 4 * n + 2; j++) {
vector<int> vec;
for (int k = 1; k <= 4 * n + 2; k++) {
if (k != i && k != j) vec.emplace_back(k);
}
way.clear();
if (!dfs(vec)) continue;
ans.emplace_back(node(i, j), way);
}
}
cout << ans.size() << '\n';
for (auto [pir, way] : ans) {
auto [x, y] = pir;
// if (y - x == 3) puts("Point 3: ");
printf("( %d , %d )", x, y);
vector<int> bel(4 * n + 3);
for (int i = 0; i < (int)way.size(); i++) {
for (int u : way[i]) bel[u] = i + 1;
}
for (int i = 1; i <= 4 * n + 2; i++) {
if (i == x || i == y) continue;
printf(" %d", bel[i]);
}
cout << '\n';
}
}
void outAB() {
for (auto [x, y] : A) {
printf("( %d , %d )", x, y);
for (int i = 1; i <= n; i++) printf(" %d %d %d %d", i, i, i, i);
cout << '\n';
}
for (auto [x, y] : B) {
printf("( %d , %d )", x, y);
int c = 0, len = (y - x + 3) / 4;
for (int i = 1; i <= x - 2; i += 4) c++, printf(" %d %d %d %d", c, c, c, c);
for (int i = x - 1; i <= y + 1; i++) {
if (i == x || i == y) continue;
printf(" %d", c + i % len + 1);
}
c += len;
for (int i = y + 2; i <= 4 * n + 2; i += 4) c++, printf(" %d %d %d %d", c, c, c, c);
cout << '\n';
}
}
const int X[] = {0, 1, 0, 2, 1, 0, 3, 1, 4, 3, 1, 4, 3, 2, 4, 3, 5, 4,
6, 6, 6, 6, 5, 2, 7, 7, 7, 7, 5, 8, 8, 8, 8, 2, 5};
const int Y[] = {0, 1, 2, 1, 3, 1, 0, 1, 2, 0, 3, 4, 5, 4, 2, 4, 3, 4,
5, 6, 2, 6, 3, 6, 5, 6, 7, 7, 7, 7, 5};
const int Z[] = {0, 1, 2, 3, 2, 4, 2, 3, 2, 1, 0, 3, 4, 0, 5, 3, 5, 1,
5, 4, 5, 6, 6, 6, 6, 1, 4};
void outC() {
for (auto [x, y] : C) {
printf("( %d , %d )", x, y);
int a = (x - 2) / 4, c = 0;
vector<int> bel(4 * n + 10);
auto norm = [&](int l, int r) -> void {
for (int i = l; i <= r; i += 4) fill(bel.begin() + i, bel.begin() + i + 4, c), c++;
};
if (a == 0) {
copy(X, X + 35, bel.begin());
c = 9, norm(35, 4 * n + 2);
} else if (a == 1) {
copy(Y, Y + 31, bel.begin());
c = 8, norm(31, 4 * n + 2);
} else if (a == n - 1) {
int st = 4 * n - 31;
c = 1, norm(1, st - 1);
for (int i = 1; i <= 34; i++) bel[st + i - 1] = c - 1 + X[35 - i];
} else if (a == n - 2) {
int st = 4 * n - 27;
c = 1, norm(1, st - 1);
for (int i = 1; i <= 30; i++) bel[st + i - 1] = c - 1 + Y[31 - i];
} else if (a == n - 3) {
int st = 4 * n - 23;
c = 1, norm(1, st - 1);
for (int i = 1; i <= 26; i++) bel[st + i - 1] = c - 1 + Z[27 - i];
} else {
int st = 4 * a - 7;
c = 1, norm(1, st - 1);
for (int i = 1; i <= 26; i++) bel[st + i - 1] = c - 1 + Z[i];
c += 6, norm(st + 26, 4 * n + 2);
}
for (int i = 1; i <= 4 * n + 2; i++) {
if (i == x || i == y) continue;
printf(" %d", bel[i]);
}
cout << '\n';
}
}
void _main() {
cin >> n;
if (n == 6 || n == 7 || n == 8) return bf(), void();
A.clear(), B.clear(), C.clear();
for (int a = 0; a <= n; a++) {
for (int b = a; b <= n; b++) A.emplace_back(4 * a + 1, 4 * b + 2);
}
for (int a = 0; a <= n; a++) {
for (int b = a + 2; b <= n; b++) B.emplace_back(4 * a + 2, 4 * b + 1);
}
for (int a = 0; a < n; a++) C.emplace_back(4 * a + 2, 4 * a + 5);
if (n <= 5) {
cout << A.size() + B.size() << '\n';
outAB();
} else {
cout << A.size() + B.size() + C.size() << '\n';
outAB(), outC();
}
}
```
:::::
## [P9841 [ICPC 2021 Nanjing R] Puzzle in Inazuma](https://www.luogu.com.cn/problem/P9841)
> 给出两个节点数为 $n$ 的无向完全图 $G$ 和 $G'$。一次操作选择四个不同顶点 $a,b,c,d$ 和整数 $x$,然后将 $G_{a,b},G_{a,c},G_{a,d}$ 加上 $x$,将 $G_{b,c},G_{b,d},G_{c,d}$ 减去 $x$。目标为将 $G$ 变为 $G'$。构造方案或报告无解。
>
> $4\le n\le100$,要求操作次数 $\le10^5$,1 秒,256 MB。
::::::success[题解]
先进行第一步转化:令 $G_{i,j}\gets G_{i,j}-G'_{i,j}$,则目标变为 $G$ 全为 $0$。显然当 $G$ 中数字的和不为 $0$ 时无解。
下文只对 $+1,-1$ 的情形考虑。容易推广到任选数的情况。
记题目里的操作为 $A(a,b,c,d)$,手玩得


如图所示,依次执行操作 $A(1,3,4,5)$ 和 $A(4,5,1,3)$ 的效果为:

因此,我们可以实现将一条边 $+2$,一条边 $-2$ 的操作,记为 $B(a,b,c,d)$。$B$ 操作可以在 $K_4$ 上实现,代价为 $2$。
$B$ 操作的缺陷在于,$(a,b),(c,d)$ 边不能共顶点。通过引入一条辅助边,我们可以将这个操作转移到共顶点的情况:



通过 $B(1,4,5,6)$ 和 $B(5,6,1,2)$ 的操作,我们将 $G_{1,4}\gets G_{1,4}+2,G_{1,2}\gets G_{1,2}-2$。记操作为 $C(1,2,4)$。$C$ 操作可以在 $K_5$ 上进行,代价为 $4$。
只要每条边权均为偶数,直接贪心进行 $B,C$ 操作,这题就做完了。接下来,我们需要一种仅调整两条边奇偶性的方法。
这里我做了 2h 拼尽全力无法构造。但是我们是学 OI 的,不是学 MO 的,因此考虑直接搜索。
注意到,在奇偶性的意义下,$a,b,c,d$ 可以任意置换,因此可以钦定 $a<b<c<d$,将合法操作缩减为 $\binom{n}{2}$ 个。搜出方案后二进制枚举,状态数为 $2^{n\choose4}$。可以解决 $n\le6$ 的情形。
::::info[搜索代码]
```cpp line-numbers
const int N = 105;
int n, x[N][N];
using node = tuple<int, int, int, int>;
vector<node> vec;
void dfs(int a, int b, int c, int d) {
if (d != -1) return vec.emplace_back(a, b, c, d), void();
if (a == -1) {
for (int i = 1; i <= n; i++) dfs(i, -1, -1, -1);
} else if (b == -1) {
for (int i = a + 1; i <= n; i++) dfs(a, i, -1, -1);
} else if (c == -1) {
for (int i = b + 1; i <= n; i++) dfs(a, b, i, -1);
} else {
for (int i = c + 1; i <= n; i++) dfs(a, b, c, i);
}
}
void _main() {
cin >> n;
dfs(-1, -1, -1, -1);
int m = vec.size();
for (int s = 0; s < (1 << m); s++) {
memset(x, 0, sizeof(x));
for (int i = 0; i < m; i++) {
if (!(s >> i & 1)) continue;
auto [a, b, c, d] = vec[i];
x[a][b] ^= 1, x[a][c] ^= 1, x[a][d] ^= 1;
x[b][c] ^= 1, x[b][d] ^= 1, x[c][d] ^= 1;
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cnt += x[i][j];
}
if (cnt == 2) {
cout << "-----------\n";
for (int i = 0; i < m; i++) {
if (!(s >> i & 1)) continue;
auto [a, b, c, d] = vec[i];
printf("%d, %d, %d, %d\n", a, b, c, d);
}
}
}
}
```
::::
对 $n=5,6$ 的搜索结果表明,在 $n=5$ 时无解,而 $n=6$ 时有 $210$ 种调整奇偶的方法。
这里给出其中一组构造为:
```plain line-numbers
1, 2, 3, 5
1, 2, 3, 6
1, 2, 4, 5
1, 2, 4, 6
1, 3, 4, 5
1, 3, 4, 6
```
执行完成的结果为:

操作改变了 $G_{1,5},G_{1,6}$ 的奇偶性,记操作为 $D(1,5,6)$。$D$ 操作适用于 $K_6$,代价为 $6$。
对于 $n\ge6$ 的情形,我们得到了通解。具体来说,我们将所有边权为奇数的边找出,若为奇数个则无解。否则两两配对进行 $D$ 操作。这一步的最坏代价为 $6\binom{n}{2}$。
奇偶性调整完成后,每次找到一组正负边权配对,并且根据有无共顶点选择 $B$ 或 $C$ 操作。这一步的最坏代价为 $\frac{1}{2}\binom{n}{2}\times4$。
综上,操作次数最坏仅为 $8\binom{n}{2}\approx4n^2$,符合题目要求。
注意一些 corner case,即 $n=4,5$ 的情形。
::::success[$n=4$]{open}
$K_4$ 只有 $6$ 条边,本质不同的操作只有 $4$ 种。记 $4$ 种操作执行的次数为 $x_1,x_2,x_3,x_4$,可以列出方程组。方程组存在自由元,钦定 $x_4$ 即可直接解。
注意一些必要条件,不成立则无解。
::::
::::success[$n=5$]{open}
考虑使用上文提及的搜索调整奇偶性。此时的合法操作有 $\binom{5}{4}=5$ 个,二进制枚举 $2^5$ 种状态即可。
::::
分类讨论即可。这样我们就终于做完了这个黑题。
::::::
:::::info[代码]
```cpp line-numbers
const int N = 105;
int n, G[N][N], G0[N][N];
using node = tuple<int, int, int, int, int>;
vector<node> vec;
void A(int a, int b, int c, int d, int x) {
if (x == 0) return;
vec.emplace_back(a, b, c, d, x);
G[a][b] += x, G[b][a] += x, G[a][c] += x, G[c][a] += x, G[a][d] += x, G[d][a] += x;
G[b][c] -= x, G[c][b] -= x, G[b][d] -= x, G[d][b] -= x, G[c][d] -= x, G[d][c] -= x;
}
void B(int a, int b, int c, int d, int x) {A(a, b, c, d, x), A(b, d, a, c, x);}
void C(int a, int b, int c, int x) {
vector<int> vec;
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c) vec.emplace_back(i);
}
int z1 = vec[0], z2 = vec[1];
B(a, b, z1, z2, x), B(z1, z2, a, c, x);
}
void D(int a, int b, int c) {
if (a == b || a == c || b == c) return;
vector<int> vec;
for (int i = 1; i <= n; i++) {
if (i != a && i != b && i != c) vec.emplace_back(i);
}
int z1 = vec[0], z2 = vec[1], z3 = vec[2];
A(a, z1, z2, b, 1), A(a, z1, z2, c, 1);
A(a, z1, z3, b, 1), A(a, z1, z3, c, 1);
A(a, z2, z3, b, 1), A(a, z2, z3, c, 1);
}
void E() {
cout << vec.size() << '\n';
for (auto [a, b, c, d, x] : vec) cout << a << ' ' << b << ' ' << c << ' ' << d << ' ' << x << '\n';
}
void F() {cout << -1, exit(0);}
void sub4() {
if (G[1][2] + G[3][4] || G[1][3] + G[2][4] || G[1][4] + G[2][3]) F();
if ((G[1][2] & 1) != (G[1][3] & 1)) F();
if ((G[1][3] & 1) != (G[1][4] & 1)) F();
int x1 = (G[1][2] + G[1][3]) / 2, x2 = (G[1][2] - G[1][4]) / 2, x3 = (G[1][3] - G[1][4]) / 2;
A(1, 2, 3, 4, -x1), A(2, 1, 3, 4, -x2), A(3, 1, 2, 4, -x3), E();
}
void sub5() {
vector<node> vec = {{1, 2, 3, 4, -1}, {1, 2, 3, 5, -1}, {1, 2, 4, 5, -1},
{1, 3, 4, 5, -1}, {2, 3, 4, 5, -1}};
int mask = -1;
for (int s = 0; s < 32; s++) {
int h[6][6];
for (int i = 1; i <= n; i++) for (int j = 1; j <= n; j++) h[i][j] = G[i][j] & 1;
for (int i = 0; i < 5; i++) {
if (!(s >> i & 1)) continue;
auto [a, b, c, d, _] = vec[i];
vector<int> tmp = {a, b, c, d};
for (int x : tmp) for (int y : tmp) if (x != y) h[x][y] ^= 1;
}
bool ok = true;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (h[i][j]) ok = false;
if (ok) {mask = s; break;}
}
if (mask == -1) F();
for (int i = 0; i < 5; i++) {
if (!(mask >> i & 1)) continue;
auto [a, b, c, d, _] = vec[i];
A(a, b, c, d, 1);
}
}
void sub6() {
vector<pair<int, int>> e;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (G[i][j] & 1) e.emplace_back(i, j);
if (e.size() & 1) F();
for (int i = 0; i+1 < (int)e.size(); i += 2) {
auto [u1, v1] = e[i]; auto [u2, v2] = e[i + 1];
if (u1 == u2) D(u1, v1, v2);
else if (u1 == v2) D(u1, v1, u2);
else if (v1 == u2) D(v1, u1, v2);
else if (v1 == v2) D(v1, u1, u2);
else D(u1, v1, u2), D(u2, u1, v2);
}
}
void work() {
while (true) {
int pu = -1, pv = -1, nu = -1, nv = -1;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (G[i][j] > 0) pu = i, pv = j;
if (G[i][j] < 0) nu = i, nv = j;
}
}
if (pu == -1 || nu == -1) break;
int s = -1, x = min(G[pu][pv], -G[nu][nv]) / 2;
if (pu == nu || pu == nv) s = pu;
if (pv == nu || pv == nv) s = pv;
if (s == -1) B(nu, nv, pu, pv, x);
else C(s, nu == s ? nv : nu, pu == s ? pv : pu, x);
}
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) cin >> G[i][j];
for (int i = 1; i <= n; i++)
for (int j = i + 1, x; j <= n; j++) cin >> x, G[i][j] -= x;
int sum = 0;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) G[j][i] = G[i][j], sum += G[i][j];
if (sum != 0) F();
if (n == 4) return sub4(), void();
n == 5 ? sub5() : sub6(), work(), E();
}
```
:::::
## [LOJ6267 生成随机数](https://loj.ac/p/6267)
> 有无限台机器,调用一台机器有 $\frac{1}{2}$ 的概率返回 $1$,$\frac{1}{2}$ 的概率返回 $0$。
>
> 给出长为 $n$ 的序列 $a_1\sim a_n$,记 $m=\sum\limits_{i=1}^n a_i$。你需要构造一个程序 $A$,使得调用 $A$ 后输出数字 $i$ 的概率恰为 $p_i=\dfrac{a_i}{m}$。
>
> 一个程序 $A$ 的行为以下两种之一:
>
> - 输出 $1\sim n$ 中有某个指定数字。
> - 调用一台机器,若返回 $0$ 则运行程序 $B$,否则运行程序 $C$。要求 $B\ne C$。
>
> 最小化调用机器次数的期望并输出,对 $998244353$ 取模。
>
> $ n \le 10^6$,$ m \le 10^7$,2 秒,512 MB。
:::::success[题解]
考虑刻画这个调用关系。连边$A\to B,A\to C$,形成一张出度恰为 $2$ 的有向图。将递归调用展开,则会形成一棵节点数无限大的叶向二叉树,第一类程序是树的叶子。
将输出数字 $i$ 的叶子染成第 $i$ 种颜色,在二叉树上考虑。对于一个深度为 $d$ 的叶子,其有 $2^{-d}$ 的概率被选到,且它对期望的贡献为 $d\times2^{-d}$。对于颜色为 $i$ 的所有叶子,我们要求 $\sum\limits_d 2^{-d}=p_i$。
这个形式可以想到 $p_i$ 的二进制分解。例如
$$
\dfrac{1}{3}=(0.010101\cdots)_2=\dfrac{1}{2^2}+\dfrac{1}{2^4}+\dfrac{1}{2^6}+\cdots=\sum_{i\ge1}\dfrac{1}{2^{2i}}
$$
故 $\frac{1}{3}$ 的概率在二叉树上对应了深度为 $2,4,6,\cdots$ 的叶子。
**性质** 同一深度内同一颜色的叶子至多有一个。
证明:考虑调整法。假设深度 $d$ 内有两个颜色为 $i$ 的叶子,其对概率的贡献为 $2\times2^{-d}=2^{-d+1}$,对期望的贡献为 $2\times d\times2^{-d}=d\times2^{-d+1}$。
我们将两个叶子缩成一个深度为 $d-1$ 的叶子,其对概率的贡献 $2^{-d+1}$ 不变,但期望值减少为 $(d-1)\times2^{-d+1}$,故调整更优。
贪心地,最优构造就是 $p_i$ 的二进制小数展开。记展开为 $p_i=(\overline{0.b_1b_2b_3\cdots})_2=\sum\limits_{i\ge1}b_i 2^{-i}$,其对期望的总贡献即为
$$
f(a_i)=\sum_{d\ge1}\dfrac{d}{2^d}\times b_d
$$
答案即为 $\sum\limits_{i=1}^n f(a_i)$。直接暴力,展开二进制找循环节可以做到 $O(n^2)$。
事实上,$f$ 可以用递推算出。考虑
$$
\begin{aligned}
\dfrac{x}{m}&=(\overline{0.b_1b_2b_3\cdots})_2=\sum\limits_{i\ge1}b_i 2^{-i}\\
f(x)&=\sum_{d\ge1}\dfrac{d}{2^d}\times b_d\\
\end{aligned}
$$
将 $\frac{x}{m}$ 的最高位删去
$$
\begin{aligned}
\dfrac{2x\bmod m}{m}&=(\overline{0.b_2b_3b_4\cdots})_2=\sum\limits_{i\ge1}b_{i+1}2^{-i}\\
f(2x\bmod m)&=\sum_{d\ge1}\dfrac{d}{2^d}\times b_{d+1}\\
\end{aligned}
$$
展开后对比系数得
$$
f(x)=\dfrac{f(2x\bmod m)}{2}+\dfrac{x}{m}
$$
考虑这个 DP 的转移图 $2x\bmod m\to x$,这是一个外向基环树森林。我们用记忆化搜索实现,只需要处理环的情况。
考虑环 $u_0\to u_1\to\cdots u_k\to u_0$。递推式 $f(u_i)=\dfrac{f(u_{i+1})}{2}+\dfrac{u_i}{m}$。将递推式不断代入并累加
$$
\begin{aligned}
f(u_0)&=\dfrac{u_0}{m}+\dfrac{1}{2}\times\dfrac{u_1}{m}+\cdots+\dfrac{1}{2^{k-1}}\times\dfrac{u_{k-1}}{m}+\dfrac{1}{2^k}f(u_0)\\
f(u_0)&=\dfrac{1}{1-2^{-k}}\sum_{i=0}^{k-1}\dfrac{u_i}{m2^i}
\end{aligned}
$$
求出 $f(u_0)$ 后顺着推一圈即可求得所有环上的 $f$ 值。
预处理逆元后复杂度 $O(m)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 1e6 + 5, M = 1e7 + 5;
int n, m, a[N];
bool vis[M];
mint im, i2[M], dp[M];
int pre(int x) {return 2 * x % m;}
mint f(int x) {
if (x == 0) return 0;
if (dp[x] != 0) return dp[x];
if (vis[x]) {
dp[x] = x * im;
int c = 1;
for (int y = pre(x); y != x; y = pre(y), c++)
dp[x] += y * im * i2[c];
return dp[x] /= (1 - i2[c]);
}
vis[x] = true;
return dp[x] = f(2 * x % m) * i2[1] + x * im;
}
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], m += a[i];
im = ~mint(m), i2[0] = 1, i2[1] = ~mint(2);
for (int i = 2; i <= m; i++) i2[i] = i2[i - 1] * i2[1];
mint res = 0;
for (int i = 1; i <= n; i++) res += f(a[i]);
cout << res;
}
```
:::::
## [P8293 [省选联考 2022] 序列变换](https://www.luogu.com.cn/problem/P8293)
> 下记 $\tt{A},\tt{B}$ 为合法括号串,$\tt{p},\tt{q}$ 为任意串。
>
> 给定一个长为 $2n$ 的合法括号串 $S$,$S$ 中每个 $\tt{(}$ 带权 $a_i$。再给出代价系数 $x,y\in\{0,1\}$。你可以执行如下两种操作:
>
> - 将 $\tt{p(A)(B)q}$ 变换为 $\tt{p(A()B)q}$,代价为 $x$ 乘 $\tt{(A)}$ 中第一个左括号的权值,加上 $y$ 乘 $\tt{(B)}$ 中第一个左括号的权值。
> - 将 $\tt{pABq}$ 变换为 $\tt{pBAq}$,不需要代价。
>
> 注意,交换时所有左括号的权值跟随括号一同交换。
>
> 目标为 $S$ 中只含有 $\tt{A()B}$ 结构,不含有 $\tt{(A)(B)}$ 结构。最小化操作代价并输出。
>
> $n\le4\times10^5$,1 秒,512 MB。
:::::success[题解]
考虑对 ${\tt{(}}S{\tt{)}}$ 建立括号树,在树上刻画操作的性质。
可以发现,操作二允许我们无代价地交换两个子树,故下文不区分儿子的顺序。
考虑操作一对树形态的改变,如图所示:

形式化地,我们对操作一进行如下描述:
- 选择一对兄弟节点 $u,v$。
- 将 $v$ 的子树全部挂在 $u$ 下方,并将 $v$ 作为单点挂在 $u$ 下方。
- 操作的代价为 $x\times a_u+y\times a_v$。
同时设法刻画题目要求的目标串形态。不难发现目标串必然形如 $\tt{((\cdots))}$,建成括号串就是一条链。因此本题被转化为,在儿子顺序无区分的情形下,使用操作一将树变成一条链。
自然地,对 $x,y$ 的取值分类讨论:
**Case 1** 当 $x=0,y=0$ 时,答案为 $0$。
对于非平凡的情形,我们需要确定贪心顺序。由于操作的特殊性,本题中我们选择自顶向下贪心。
**Case 2** 当 $x=0,y=1$ 时,操作的代价为 $a_v$。给出如下贪心策略:
- 自顶向下考虑,设当前层有 $m$ 个节点。
- 将 $m$ 个节点按 $a_v$ 升序排序,选择较小的 $m-1$ 个点作为 $v$,与点权最大的点 $u$ 进行操作。
- 操作结束后,将 $u$ 作为当前深度的链节点,递归考虑下一层。
由于挂单点破坏均摊,直接模拟的复杂度会爆炸。考虑维护补集,给出如下流程:
- 维护一个大根堆和堆内元素和。
- 自顶向下考虑,将当前层的节点入堆。
- 将 $a_u$ 最大的节点弹出,作为当前深度的链节点。堆内元素作为 $v$ 与 $u$ 进行操作,故答案加上堆内节点权值和。
至此,Case 2 在 $O(n\log n)$内解决,获得[16 分](https://qoj.ac/submission/2627232)。
**Case 3**当$x=1,y=1$ 时,操作的代价为 $a_u+a_v$。类比 Case 2,我们先考察一层的节点。
设当前层有 $m$ 个节点,升序排序后形成序列 $b_1\sim b_m$。我们钦定 $x$ 为当前深度的链节点。贪心地用 $b_1$ 消耗其他节点,并在最后做操作 $(x,b_1)$。这样做的代价是
$$
\begin{aligned}
f(x)&=(m-2)b_1+\sum_{i\ne1\land i\ne x}b_i+b_1+b_x\\
&=(m-1)b_1+\sum_{i=2}^m b_i
\end{aligned}
$$
**性质 3.1** 同一层的 $f$ 值是一个常数 $C=(m-1)b_1+\sum\limits_{i=2}^m b_i$。
这立即导出一个重要结论:在本层选择任意节点不会影响代价。这样,我们只要考虑选取 $x$ 使得下一层的 $C$ 最小。
容易说明,在本层选取 $x$ 的策略仍然是选择权值最大的节点。考虑用 multiset 维护并记录全局和,每层时计算代价只要知道最小值。
至此,Case 3 做到 $O(n\log n)$,获得 [32 分](https://qoj.ac/submission/2627548)。
**Case 4** 当 $x=1,y=0$ 时,操作的代价为 $a_u$。
仍考察同一层的节点。若钦定 $x$ 为当前深度的链节点,该层的代价即 $(m-1)a_x$,除 $x$ 以外的节点落入下一层。
直观的贪心策略是取最小的 $a_x$,但这不能取到最优,原因是如果下一层有大量待合并节点,保留最小的 $a_x$ 到下一层可能更优。
精细分析当前层钦定点 $x$ 的代价
$$
f(x)=(m-2)b_1+b_x
$$
我们要最小化 $\sum f$。系数 $m-2$ 被树的结构客观决定,我们只要关注 $b_1$ 和 $b_x$,进而感性理解如下两个性质:
**性质 4.1** 整个序列的 $\min$ 不应被轻易钦定,它必须一路落到底层,在每一层中充当 $b_1$。
**性质 4.2** 整个序列的 $\max$ 必须一路落到底层。
性质 4.2 的动机是,除链底节点外,其余链节点必然会支付自己的权值。因此,我们希望将最大值送到底端,免除其代价。
由上述两个性质可以导出更强的结论,这也直接导出了每层的贪心策略:
- 若 $m=1$,直接将其下放并跳过。
- 若 $m>2$,任意钦定一个中间元素作为 $x$,剩余节点下放。
- 若 $m=2$,我们分类讨论此时下放最小值还是最大值。这里的意思是,对于 $m>2$ 出现的一段 $m=2$ 需要进行讨论,且一段的策略是相同的。
比较严格的证明参见[这篇题解](https://www.luogu.com.cn/article/54li55t3)。
因此,我们需要分两种策略进行求解,答案取代价的较小值。仍然可以 multiset 维护做到 1log。
这样整个问题在 $O(n\log n)$ 内解决。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 8e5 + 5;
int n, x, y, a[N], dep[N];
char s[N];
vector<int> ch[N], lev[N];
void dfs(int u) {
lev[dep[u]].emplace_back(u);
for (int v : ch[u]) dep[v] = dep[u] + 1, dfs(v);
}
void work01() {
priority_queue<int> q;
i64 res = 0, sum = 0;
for (int d = 1; d <= n; d++) {
for (int u : lev[d]) q.emplace(a[u]), sum += a[u];
if (q.empty()) break;
sum -= q.top(), res += sum, q.pop();
} cout << res;
}
void work11() {
multiset<int> q;
i64 res = 0, sum = 0;
for (int d = 1; d <= n; d++) {
for (int u : lev[d]) q.emplace(a[u]), sum += a[u];
if (q.empty()) break;
i64 x = *q.begin(), y = *q.rbegin();
res += x * ((int)q.size() - 2) + sum;
sum -= y, q.erase(q.find(y));
} cout << res;
}
void work10() {
auto solve = [&](int op) -> i64 {
multiset<int> q;
i64 res = 0, fl = 0;
for (int d = 1; d <= n; d++) {
for (int u : lev[d]) q.emplace(a[u]);
if (q.empty()) break;
int m = q.size();
if (m == 1) {
q.clear(); continue;
}
if (m >= 3) fl = 1;
multiset<int>::iterator it;
if (fl) {
if (m == 2) it = q.begin();
else it = next(q.begin());
} else {
if (op) it = q.begin();
else it = prev(q.end());
}
res += 1LL * *q.begin() * (m-2) + *it;
q.erase(it);
} return res;
};
cout << min(solve(0), solve(1));
}
void _main() {
cin >> n >> x >> y >> (s + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
stack<int> st; st.emplace(0);
for (int i = 1, cnt = 0; i <= 2 * n; i++) {
if (s[i] == '(') ch[st.top()].emplace_back(++cnt), st.emplace(cnt);
else st.pop();
}
dfs(0);
if (x == 0 && y == 0) return cout << 0, void();
if (x == 0 && y == 1) return work01(), void();
if (x == 1 && y == 1) return work11(), void();
if (x == 1 && y == 0) return work10(), void();
}
```
:::::
## [P10787 [NOI2024] 树的定向](https://www.luogu.com.cn/problem/P10787)
> 给定一棵 $n$ 个节点的树,边有标号,再给定 $m$ 条限制 $(a_i,b_i)$。
>
> 你需要构造一组定向方案,满足 $\forall i\in[1,m],a_i\to b_i$ 不可达。再此基础上,最小化定向方案的字典序,并输出构造。数据保证有解。
>
> $n,m\le5\times10^5$,3 秒,2048 MB。
::::::success[题解]
从 B 性质入手思考,容易得到 2-SAT 字典序最小解的转化,进而得到一般情形 k-SAT 的转化,从而问题不可做。
这启示我们从 A 性质入手思考。经过推演,可以发现有且仅有以下两种定向方案合法:
- 奇数层向下,偶数层向上。
- 奇数层向上,偶数层向上。
从而 A 性质的解法为,从两种方案中取出字典序较小的方案。
对于一般情形,相邻点对的限制相当于钦定了某些边的定向。显然,我们需要先对这些边定向。一部分边定向后,又会产生新的必须定向的边,这样得到一个迭代过程。同时,对于路径上已经存在反向边的限制,我们可以将其忽略。
现在的问题是,不存在必须定向的边时,如何进行定向。根据 A 性质的构造,我们得到本题的关键结论:
**性质** 若对剩余所有限制 $(a_i,b_i)$,$a_i\to b_i$ 至少存在 $2$ 条未定向边,则必然存在合法方案。
这是有解的充分不必要条件。这告诉我们,不存在必须定向的边时,可以直接钦定标号最小边的方向,重复这个流程。
下面复述一遍算法流程:
> - 维护队列 $Q$,存放仅剩 $1$ 条未定向边的所有限制。
> - 重复如下操作直到所有边被定向:
> - 取出队首限制。若其有效,则将路径上唯一未定向边定向。直到 $Q$ 为空。
> - 将标号最小边定向,并将新的限制加入 $Q$。
至此转化为数据结构问题。列出需要维护的操作:
> 1. 给定 $m$ 个报警器 $(a_i,b_i)$,当 $a_i\to b_i$ 路径上未定向边数 $\textcolor{red}{=1}$ 时报警。
> 2. 在树上维护以下操作:
> - 给定 $a_i,b_i$,判定 $a_i\to b_i$ 是否存在反向边。
> - 给定 $a_i,b_i$,找出 $a_i\to b_i$ 未定向边的标号。
> - 给定 $i$,将第 $i$ 条边定向。
这两部分都存在 1log 做法,下面介绍思维难度较小的 2log 做法。
树剖拍到序列上。对于第一部分,可以使用[清零警报器](https://www.luogu.com.cn/article/12j8cfca)维护。具体地,我们对序列建立线段树,将警报器挂在 $\log^2 n$ 个节点上。每次修改时,对于需要更新的线段树节点,当且仅当区间和 $\le1$ 时扫描挂载的警报器,判定其是否报警。由于每个警报器只会被 $O(\log^2 n)$ 个节点检查 $O(1)$ 次,总复杂度 $O(m\log^2 n)$。
对于第二部分,仍转化到序列上。用一棵线段树维护 01 序列,区间查询存在性是简单的。求标号可以在线段树上二分,复杂度也是 2log。
视 $n,m$ 同阶复杂度 $O(n\log^2 n)$,实现优秀的话跑的飞快。具体实现细节见代码。
::::::
::::::info[代码]
```cpp line-numbers
const int N = 5e5 + 5;
int n, m, s[N], t[N], low[N], a[N], b[N], ans[N];
vector<pair<int, int>> e[N];
int dn, sz[N], fa[N], dep[N], son[N], dfn[N], top[N], seq[N], eid[N];
void dfs1(int u) {
sz[u] = 1;
for (auto [v, id] : e[u]) {
if (v == fa[u]) continue;
eid[v] = id, low[id] = v;
fa[v] = u, dep[v] = dep[u] + 1, dfs1(v), sz[u] += sz[v];
if (sz[v] > sz[son[u]]) son[u] = v;
}
}
void dfs2(int u, int t) {
dfn[u] = ++dn, top[u] = t, seq[dn] = u;
if (son[u]) dfs2(son[u], t);
for (auto [v, id] : e[u])
if (v != fa[u] && v != son[u]) dfs2(v, v);
}
int lca(int u, int v) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
u = fa[top[u]];
} return dep[u] < dep[v] ? u : v;
}
void check(int x, int c);
// -1: undirected 0: up 1: down
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
int cnt[N << 2];
u8 has[N << 2];
vector<int> to[N << 2];
void pushup(int rt) {
cnt[rt] = cnt[ls] + cnt[rs];
has[rt] = has[ls] | has[rs];
}
void build(int l = 1, int r = n, int rt = 1) {
if (l == r) return cnt[rt] = 1, void();
int mid = (l + r) >> 1;
build(l, mid, ls), build(mid + 1, r, rs), pushup(rt);
}
bool exist(int tl, int tr, int c, int l = 1, int r = n, int rt = 1) {
if (tl <= l && r <= tr) return has[rt] >> c & 1;
int mid = (l + r) >> 1;
if (tl <= mid && exist(tl, tr, c, l, mid, ls)) return true;
if (tr > mid && exist(tl, tr, c, mid + 1, r, rs)) return true;
return false;
}
int search(int tl, int tr, int l = 1, int r = n, int rt = 1) {
if (!cnt[rt]) return -1;
if (r < tl || l > tr) return -1;
if (l == r) return l;
int mid = (l + r) >> 1, tmp = -1;
tmp = search(tl, tr, l, mid, ls);
if (tmp != -1) return tmp;
return search(tl, tr, mid + 1, r, rs);
}
void update(int x, int c, int l = 1, int r = n, int rt = 1) {
if (l == r) {
cnt[rt]--;
for (int x : to[rt]) check(x, 1);
return has[rt] |= 1 << c, void();
}
int mid = (l + r) >> 1;
if (x <= mid) update(x, c, l, mid, ls);
else update(x, c, mid + 1, r, rs);
pushup(rt);
if (cnt[rt] == 1)
for (int x : to[rt]) check(x, r - l);
if (cnt[rt] == 0)
for (int x : to[rt]) check(x, 1);
}
void modify(int tl, int tr, int c, int l = 1, int r = n, int rt = 1) {
if (tl <= l && r <= tr) return to[rt].emplace_back(c), void();
int mid = (l + r) >> 1;
if (tl <= mid) modify(tl, tr, c, l, mid, ls);
if (tr > mid) modify(tl, tr, c, mid + 1, r, rs);
}
} T;
int hd=1, tl=0, q[40*N], cnt[N];
bool del[N];
void push(int u, int v, int to) {
cnt[to] = dep[u] + dep[v] - 2 * dep[lca(u, v)];
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
T.modify(dfn[top[u]], dfn[u], to);
u = fa[top[u]];
}
if (dfn[u] > dfn[v]) swap(u, v);
if (dfn[u] < dfn[v]) T.modify(dfn[u]+1, dfn[v], to);
}
bool removed(int id) {
if (del[id]) return true;
int u = a[id], v = b[id], x = lca(u, v);
while (top[u] != top[x]) {
if (T.exist(dfn[top[u]], dfn[u], 1)) return del[id] = true;
u = fa[top[u]];
}
if (u != x && T.exist(dfn[x]+1, dfn[u], 1)) return del[id] = true;
while (top[v] != top[x]) {
if (T.exist(dfn[top[v]], dfn[v], 0)) return del[id] = true;
v = fa[top[v]];
}
if (v != x && T.exist(dfn[x]+1, dfn[v], 0)) return del[id] = true;
return false;
}
void check(int x, int c) {
cnt[x] -= c;
if (cnt[x] == 1 && !removed(x)) q[++tl] = x;
}
void direct(int i, int st) {
ans[i] = low[i] == s[i] ? st : (st ^ 1);
T.update(dfn[low[i]], st);
}
pair<int, int> search(int id) {
int u = a[id], v = b[id], x = lca(u, v);
while (top[u] != top[x]) {
int r = T.search(dfn[top[u]], dfn[u]);
if (r != -1) return {eid[seq[r]], 1};
u = fa[top[u]];
}
if (u != x) {
int r = T.search(dfn[x]+1, dfn[u]);
if (r != -1) return {eid[seq[r]], 1};
}
while (top[v] != top[x]) {
int r = T.search(dfn[top[v]], dfn[v]);
if (r != -1) return {eid[seq[r]], 0};
v = fa[top[v]];
}
if (v != x) {
int r = T.search(dfn[x]+1, dfn[v]);
if (r != -1) return {eid[seq[r]], 0};
}
return {-1, -1};
}
void _main() {
read(n, n, m);
for (int i = 1; i < n; i++) {
read(s[i], t[i]);
e[s[i]].emplace_back(t[i], i);
e[t[i]].emplace_back(s[i], i);
}
dfs1(1), dfs2(1, 1), T.build();
for (int i = 1; i <= m; i++) read(a[i], b[i]), push(a[i], b[i], i);
for (int i = 1; i <= m; i++) check(i, 0);
fill(ans + 1, ans + n, -1);
for (int i = 1; i < n; ) {
while (hd <= tl) {
int x = q[hd++];
if (removed(x)) continue;
auto [i, st] = search(x);
del[x] = true, direct(i, st);
}
while (i < n && ans[i] != -1) i++;
if (i >= n) break;
direct(i, low[i] == t[i]);
}
for (int i = 1; i < n; i++) write(ans[i]);
}
```
::::::
## [QOJ11544 Colored Blocks](http://qoj.ac/problem/11544)
> 给出长为 $n$ 的序列 $a_i$。你需要将其不重不漏地划分为 $k$ 个子序列,满足每个子序列内相邻元素不相等。最小化 $k$ 并输出构造。
>
> 多测,$\sum n\le2\times10^5$,$1\le a_i\le10^9$,1 秒,256 MB。
:::::success[题解]
考虑图论建模,若 $i<j\land a_i\ne a_j$ 则连边 $i\to j$,表示 $a_j$ 可以接在 $a_i$ 后面,这会形成一个 DAG。一组合法的划分方案构成了图的一个链覆盖,所求即为 DAG 最小链覆盖。
按照经典做法拆点,拆出出点 $i_0$ 和入点 $i_1$。若 $i<j\land a_i\ne a_j$ 则连边 $i_0\to j_1$。选中 $(i_0,j_1)$ 被刻画为将 $a_j$ 接在 $a_i$ 后面。在合法方案中,一个节点的入度和出度至多为 $1$,因此 DAG 路径覆盖被刻画为二分图的一组匹配。
如果我们找到了一个大小为 $|M|$ 的匹配,说明有 $|M|$ 个元素有前驱,即剩余 $n-|M|$ 个元素是子序列的开头。我们要最小化 $k=n-k'$,只要最大化 $k'$,即求解二分图最大匹配。
根据 Hall 定理的推论,二分图 $G=(X,Y,E)$ 的最大匹配
$$
|M|=|Y|-\max_{W\subseteq Y}(|W|-|N(W)|)
$$
其中 $|Y|=n$,代入 $k=n-k'$ 知 $k_{\min}=\max\limits_{W\subseteq Y}(|W|-|N(W)|)$。
套路地考察 $|W|-|N(W)|$ 取得 $\max$ 的 $W$ 的形态。考虑原序列的一段区间 $[l,r]$,我们将所有值为 $x$ 的元素选入 $W$,这样值为 $x$ 的左部点必然不属于 $N(W)$。这样有
$$
|W|-|N(W)|=\sum_{i=l}^r[a_i=x]-\sum_{i=l}^r[a_i\ne x]
$$
可以用调整法说明正确性。记 $f(l,r,x)=\sum\limits_{i=l}^r[a_i=x]-\sum\limits_{i=l}^r[a_i\ne x]$,这样 $k=\max\limits_{l,r,x}f(l,r,x)$。
维护序列 $b_i=(-1)^{[a_i\ne x]}$,于是 $\max\limits_{[l,r]}f(l,r,x)$ 即为序列 $b_i$ 的最大子段和。枚举 $x$ 并将 $a_i=x$ 的 $b_i\gets1$,求出最大子段和再撤销,容易线段树维护。至此,求答案可以做到 $O(n\log n)$。
下面解决构造方案的问题。考虑顺次扫描每个 $i$ 并决策 $a_i$ 的归属。
想象将 $a_i$ 分配到某个子序列后,如果剩余状态仍然合法,我们就接受这个决策。新状态的合法性仍然可以用 Hall 定理论证。
我们对后缀 $(i,n]$ 建 DAG 并转化到二分图匹配。记 $c_x$ 为当前以 $x$ 结尾的子序列数目,由朴素 Hall 定理知合法的充要条件
$$
2\sum_{j=i+1}^r[a_j=x]-(r-i)+c_x\le k
$$
代入 $f$ 的变形式 $f(l,r,x)=2\sum\limits_{i=l}^r[a_i=x]-(r-l+1)$ 得
$$
\forall x\land r>i,f(i+1,r,x)+c_x\le k\\
\forall x,c_x+\max_{r>i}f(i+1,r,x)\le k
$$
考虑枚举分配方案,并对 $c_x$ 产生变化的 $x$ 验证上述条件是否成立。直接做可以做到 $O(n^2\log n)$。
观察 $f$ 的定义式 $f(l,r,x)=\sum\limits_{i=l}^r[a_i=x]-\sum\limits_{i=l}^r[a_i\ne x]$,注意到 $f<0$ 时可以忽略 $f$,而 $f\ge0$ 时必有 $x$ 是 $[l,r]$ 的绝对众数。
我们的判定条件是 $c_x+\max\limits_{r>i}f(i+1,r,x)\le k$,暴力算法需要对每个 $x$ 都 check 一次。事实上,后缀 $(i,n]$ 中绝对众数每变化一次,区间长度至少翻倍,故满足 $\exists r,f\ge0$ 的 $x$ 只有 $O(\log n)$ 个。
综上,我们预处理每个后缀的 $f$ 值,并求出这 $O(\log n)$ 个需要检查的 $x$。如果 $\exists x,c_x+f_x=k$ 则必须将 $a_i$ 接在 $x$ 后面,否则任取一个子序列即可。
两部分复杂度都是 $O(n\log n)$。
:::::
:::::info[代码]
```cpp line-numbers
const int N = 2e5 + 5, inf = 1e9;
int n, m, a[N], d[N];
struct node {int sum, pre, suf, val;};
node operator+ (const node& a, const node& b) {
return node{
a.sum + b.sum, max(a.pre, a.sum + b.pre), max(b.suf, b.sum + a.suf),
max({a.val, b.val, a.suf + b.pre})
};
}
struct segtree {
#define ls (rt << 1)
#define rs (rt << 1 | 1)
node val[N << 2];
void pushup(int rt) {val[rt] = val[ls] + val[rs];}
void build(int l = 1, int r = n, int rt = 1) {
if (l == r) return val[rt] = node{-1, -1, -1, -1}, void();
int mid = (l + r) >> 1;
build(l, mid, ls), build(mid + 1, r, rs), pushup(rt);
}
void modify(int x, int c, int l = 1, int r = n, int rt = 1) {
if (l == r) return val[rt] = node{c, c, c, c}, void();
int mid = (l + r) >> 1;
if (x <= mid) modify(x, c, l, mid, ls);
else modify(x, c, mid + 1, r, rs);
pushup(rt);
}
node all() const {return val[1];}
} T;
vector<int> pos[N], suf[N], id[N];
int fir[N], c[N];
int F(int x, int i, int j) {
if (j >= (int)suf[x].size()) return -inf;
return suf[x][j] - 2 * j + i + 1;
}
vector<int> row[N], ed[N];
set<int> q;
void _main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], d[i] = a[i];
sort(d + 1, d + n + 1), m = unique(d + 1, d + n + 1) - d - 1;
for (int i = 1; i <= m; i++) pos[i].clear(), suf[i].clear();
for (int i = 1; i <= n + 2; i++) id[i].clear(), row[i].clear(), ed[i].clear();
for (int i = 1; i <= n; i++) {
a[i] = lower_bound(d + 1, d + m + 1, a[i]) - d;
pos[a[i]].emplace_back(i);
}
T.build(); int k = 1;
for (int x = 1; x <= m; x++) {
for (int i : pos[x]) T.modify(i, 1);
chkmax(k, T.all().val);
for (int i : pos[x]) T.modify(i, -1);
}
cout << k << '\n';
for (int x = 1; x <= m; x++) {
int len = pos[x].size();
suf[x].resize(len, 0);
int mx = -inf;
for (int i = len - 1; i >= 0; i--) {
chkmax(mx, 2 * i - pos[x][i]);
suf[x][i] = mx;
}
}
for (int x = 1; x <= m; x++) fir[x] = pos[x].size();
for (int i = n; i >= 1; i--) {
vector<int> vec = id[i + 1];
fir[a[i]]--;
if (find(vec.begin(), vec.end(), a[i]) == vec.end())
vec.emplace_back(a[i]);
for (int x : vec) if (F(x, i, fir[x]) >= 0)
id[i].emplace_back(x);
}
for (int i = 1; i <= k; i++) ed[m + 1].emplace_back(i);
q.clear(), q.emplace(m + 1);
fill(fir + 1, fir + m + 1, 0), fill(c + 1, c + m + 1, 0);
for (int i = 1; i <= n; i++) {
fir[a[i]]++;
int d = -1;
for (int x : id[i + 1]) {
if (x == a[i]) continue;
if (c[x] + F(x, i + 1, fir[x]) == k + 1) {
d = x; break;
}
}
if (d == -1) d = *q.begin() != a[i] ? *q.begin() : *q.rbegin();
int r = ed[d].back(); ed[d].pop_back();
if (ed[d].empty()) q.erase(d);
if (d != m + 1) c[d]--;
c[a[i]]++, ed[a[i]].emplace_back(r), q.emplace(a[i]);
row[r].emplace_back(i);
}
for (int i = 1; i <= k; i++) {
cout << row[i].size() << ' ';
for (int x : row[i]) cout << x << ' ';
cout << '\n';
}
}
```
:::::
## [P15653 [省选联考 2026] 星图](https://www.luogu.com.cn/problem/P15653)
> 给出一张 $n$ 个点 $m$ 条边的无向图。一次操作选择一个大小为 $k$ 的点集 $u_1\sim u_k$,对于 $1\le i<j\le k$,若 $(u_i,u_j)$ 无边则增加这条边,否则将 $(u_i,u_j)$ 边删去。操作至多进行 $p$ 次。
>
> 最大化图的边数,并给出操作方案。
>
> 多测,$T\le10$,$n\le500$,$\sum n\le3\times10^3$,$m\le\binom{n-1}{2}$,$2\le k\le n-2$,满分要求 $p=\binom{n-1}{2}$。1.5 秒,960 MB。
::::::success[题解]
很多部分是 QOJ 题解的人话翻译。
分析操作性质,一次操作中:
- 边数的奇偶性变化量为 $\binom{k-1}{2}\bmod2$。
- 操作节点度数的奇偶性变化量为 $(k-1)\bmod2$。
因此,对于一个可以得到的图,边数的奇偶性和节点度数的奇偶性给出了两个必要条件。
我们猜测这个条件是充分的。也即,只要考虑边数的奇偶性和节点度数的奇偶性,即可构造出所有可能的图。
:::::success[证明]{open}
从线性代数观点给出的非构造式证明。
考虑的邻接矩阵 $x_{i,j}$ 表示 $(i,j)$ 边是否存在,取矩阵 $x$ 的上三角,拍平为 $\binom{n-1}{2}$ 维向量 $\vec{x}$ 用于表示一个图。记:
- 所有可达图对应的 $\vec{x}$ 构成集合 $U$。
- 只考虑边数的奇偶性和节点度数的奇偶性,合法图对应的 $\vec{x}$ 构成集合 $R$。
由必要性易得 $U\subseteq R$。我们将 $U$ 和 $R$ 都视为合法向量 $\vec{x}$ 张成的线性空间,只要说明 $\dim U=\dim R$。这是因为,设空间 $U$ 的基底为 $e_1\sim e_d$,由 $U\subseteq R$ 且 $\dim R=d$ 导出 $e_1\sim e_d$ 也是空间 $R$ 的基底,从而 $U=R$ 的充分性得证。
值得说明的是,此处考虑的向量运算在 $\mathbb{F}_2$ 域中进行,也就是数集为 $\{0,1\}$,且加法等价于异或。两个向量的内积定义为
$$
\vec{x}\cdot\vec{y}=\sum_{i<j}x_{i,j}y_{i,j}
$$
再此提醒,请注意 $\sum$ 和 $+$ 等价于异或 $\bigoplus$。
首先计算 $\dim R$。这只需要一些简单的组合数学技巧:
- 无限制时,图中共有 $\binom{n}{2}$ 条边,自由度 $\dim R=\binom{n}{2}$。
- 仅边数奇偶性限制:$\dim R=\binom{n}{2}-1$。
- 仅节点度数奇偶性限制:此时加入了 $n$ 条约束方程。
根据握手定理,所有节点的度数和为偶数,这说明这 $n$ 条方程是线性相关的,有效的限制只有 $n-1$ 个。
因此自由度 $\dim R=\binom{n}{2}-n+1=\binom{n-1}{2}$。
- 同时带两个限制:$\dim R=\binom{n-1}{2}-1$。
下面计算 $\dim U$。正难则反,对偶到正交补空间 $U^{\perp}$ 中。此时
$$
\dim U=\binom{n}{2}-\dim U^{\perp}
$$
对互异四元组 $(a,b,c,d)$,我们发现如下性质:
**性质 1** $\forall\vec{y}\in U^{\perp},\forall(a,b,c,d),y_{a,b}+y_{c,d}+y_{a,c}+y_{b,d}=0$。
::::success[证明]
任取 $a,b,c,d$ 以外的 $k-2$ 个点作为点集 $S$。构造 $4$ 个大小为 $k$ 的合法点集:
- $S_1=S\cup\{a,b\}$。
- $S_2=S\cup\{c,d\}$。
- $S_3=S\cup\{a,c\}$。
- $S_4=S\cup\{b,d\}$。
由正交补空间的定义,必有 $\forall i,\vec{y}\cdot S_i=0$。
将这 $4$ 次内积的结构全部加起来,结果依然为 $0$。观察这次运算:
- $S$ 内部的边:共出现 $4$ 次,直接抵消。
- $S$ 与 $\{a,b,c,d\}$ 之间的边:以 $S\leftrightarrow a$ 为例,在 $S_1,S_3$ 中共出现 $2$ 次,抵消。
- $\{a,b,c,d\}$ 内部的边:各出现 $1$ 次,被保留。
因此,这 $4$ 条被保留的边加和必然为 $0$,原命题得证。
::::
**性质 2** $\forall\vec{y}\in U^{\perp},\forall(a,b,c,d),y_{a,b}+y_{a,c}=y_{b,d}+y_{c,d}$。
::::success[证明]
对性质 1 移项得证。
::::
观察性质 2 的实际意义:左右两边的起点分别为 $a,d$,终点都是 $b,c$,边权和相等。这直接表明,改变边的终点带来的变化,与边的起点无关。
**性质 3** $\exists p_1,p_2,\cdots,p_n,c\in\{0,1\},\forall1\le i<j\le n,y_{i,j}=p_i+p_j+C$。
::::success[证明]
对互异四元组 $(1,2,i,j)$ 应用性质 2 并记
$$
y_{i,1}+y_{i,2}=y_{1,j}+y_{2,j}=C_0
$$
取 $p_i=y_{i,1},q_i=y_{i,2}$ 代入上式
$$
p_i+q_i=C_0\implies p_i=q_i+C_0
$$
对互异四元组 $(i,j,1,2)$ 应用性质 1 得
$$
\begin{aligned}
&y_{i,j}+y_{1,2}+y_{i,1}+y_{j,2}=0\\
\implies&y_{i,j}=p_i+q_j+y_{1,2}\\
\implies& y_{i,j}=p_i+p_j+C_0+y_{1,2}
\end{aligned}
$$
取 $C=C_0+y_{1,2}$ 得到构造。原命题证毕。
::::
将通式代入正交定义进行分析,即对于任意大小为 $k$ 的团 $S$,$\vec{y}$ 与团的内积为 $0$。
$$
\sum_{i,j\in S\land i<j}(p_i+p_j+C)=0
$$
对于所有点对 $(i,j)$,分别观察 $p_i$ 和 $C$ 被计算的次数:
- 点权 $p_i$ 的贡献:在团 $S$ 内部,点 $i$ 连出 $k-1$ 条边,故 $p_i$ 被计算 $k-1$ 次。
- 常数 $C$ 的贡献:团 $S$ 内部共有 $\binom{k}{2}$ 条边,故 $C$ 被计算 $\binom{k}{2}$ 次。
$(k-1)\bmod2$ 和 $\binom{k}{2}\bmod2$ 引出了对 $k\bmod4$ 分类讨论的想法。
::::info[$k\equiv2\pmod4$]
- 由于 $k-1\equiv1\pmod2$,每个 $p_i$ 都剩余 $1$ 份。
- 由于 $\binom{k}{2}\equiv1\pmod2$,故 $C$ 也会被剩余 $1$ 份。
方程化简为
$$
C+\sum_{i\in S}p_i=0
$$
这对任意大小为 $k$ 的团 $S$ 都成立。
我们将 $S$ 中的一个点 $u$ 替换为 $v$,方程仍然成立。将两个方程相加得
$$
p_u+p_v=0\implies p_u=p_v
$$
这表明,所有点权 $p_i$ 全相等。且此时 $k$ 是偶数,故 $\sum\limits_{i\in S}p_i=0$,代入方程得 $C=0$。
代回通式得 $y_{i,j}=p_i+p_j+C$ 得 $y_{i,j}=0$。因此,唯一合法的向量 $\vec{y}$ 即为零向量 $\vec{0}$。
所以,正交补空间 $U^{\perp}$ 没有任何自由度,$\dim U^{\perp}=0$。
我们直接得到 $\dim U=\binom{n}{2}-0=\binom{n}{2}$。此时对应奇偶性无限制的情况,$\dim R=\binom{n}{2}$,二者相等,证毕。
::::
::::info[$k\equiv0\pmod4$]
- 由于 $k-1\equiv1\pmod2$,每个 $p_i$ 都剩余 $1$ 份。
- 由于 $\binom{k}{2}\equiv0\pmod2$,故 $C$ 被消掉。
方程化简为 $\sum\limits_{i\in S}p_i=0$。
由 $k\equiv2\pmod4$ 的论证,同理可得所有点权 $p_i$ 全相等。
代回通式得 $y_{i,j}=p_i+p_j+C=C$。取 $C=0$ 得零向量 $\vec{0}$,取 $C=1$ 得全 $1$ 向量 $\vec{j}$。
所以 $\dim U^{\perp}=\log_2(2)=1$。
因此 $\dim U=\binom{n}{2}-1$。此时对应仅边数奇偶性限制的情况,$\dim R=\binom{n}{2}-1$,二者相等,证毕。
::::
::::info[$k\equiv3\pmod4$]
- 由于 $k-1\equiv0\pmod2$,所有 $p_i$ 被消掉。
- 由于 $\binom{k}{2}\equiv1\pmod2$,故 $C$ 剩余 $1$ 份。
方程化简为 $C=0$。代回通式得 $y_{i,j}=p_i+p_j$。
分析 $p_1\sim p_n$ 的自由度。注意到,如果将所有 $p_i$ 同时翻转,$y_{i,j}$ 不会改变,故有 $1$ 个自由度冗余,所以独立的自由度是 $n-1$ 个。
所以 $\dim U^{\perp}=n-1$。
因此 $\dim U=\binom{n}{2}-(n-1)=\binom{n-1}{2}$。此时对应仅节点度数奇偶性限制的情况,$\dim R=\binom{n-1}{2}$,二者相等,证毕。
::::
::::info[$k\equiv1\pmod4$]
- 由于 $k-1\equiv0\pmod2$,所有 $p_i$ 被消掉。
- 由于 $\binom{k}{2}\equiv0\pmod2$,故 $C$ 被消掉。
方程无任何约束。根据 $k\equiv3\pmod4$ 的分析,$p_1\sim p_n$ 有 $n-1$ 个自由度,加上 $C$ 的自由度,所有 $n$ 个自由度全被保留。
所以 $\dim U^{\perp}=n$。
因此 $\dim U=\binom{n}{2}-n$。此时对应两个限制同时作用的情况,$\dim R=\binom{n}{2}$,二者相等,证毕。
::::
综上所述,边数奇偶性 & 节点度数奇偶性构成了合法图的充要条件。
:::::
我们猜想 $p$ 是充分大的,即使用 $\le p$ 次操作必能达到精确界。
根据已证的结论,只要考虑边数的奇偶性和节点度数的奇偶性,就能算出答案的精确界。
为了方便,不妨取补图变为最小化边数,并将 $m$ 重记为补图边数。仍须按 $k\bmod4$ 分类讨论:
- 若 $k\equiv2\pmod4$:无限制。图可以删空,精确下界为 $0$。
- 若 $k\equiv0\pmod4$:仅边数奇偶性限制。精确下界为 $m\bmod2$。
- 若 $k\equiv3\pmod4$:仅节点度数奇偶性限制。记奇度数点的数目为 $c$,只要配对删边即可,精确下界为 $\frac{c}{2}$。
- 若 $k\equiv1\pmod4$:同时带两个限制。记突破度数限制的点数为 $c$,配对删边后,继续精细讨论:
- 若 $c\equiv m\pmod2$:边数奇偶性满足限制,精确下界为 $\frac{c}{2}$。否则仍须调整。
- 若 $c>0$:考虑将删去的边 $(u,v)$ 改为 $(u,w)$ 和 $(w,v)$,其中 $w$ 满足度数限制。精确下界 $\frac{c}{2}+1$。
- 若 $c=0$:所有点都是偶度数点,必须取出一个三元环,精确下界 $3$。
在 $p$ 充分大的假设下,我们已经严谨证明了答案的正确性。至此 25pts。[submission](https://qoj.ac/submission/2554168)。
下面叙述构造部分的正解。首先取补图,根据第一问的结论,我们对原图进行微调,使得它边数的奇偶性和节点度数的奇偶性与目标状态一致。问题被转化为,通过 $\le p$ 次操作将图消成空图。
然后,我们尽量消去所有点的出边。这一步使用了归纳构造的思想,顺次考虑 $u=1,2,\cdots,n$,从左到右消去点的出边,规约到 $n-1$ 的情形。
- 若 $u$ 点的度数为偶数:考虑配对法,设 $u$ 此时还与右部 $a,b$ 点有边。取一个在 $u$ 右侧大小为 $k-2$ 的点集 $T$。对 $T\cup\{u,a\}$ 和 $T\cup\{u,b\}$ 操作。
此时,$T$ 内部的边和 $T$ 到 $u$ 的边都被翻转 $2$ 次抵消。$(u,a),(u,b)$ 被翻转一次消去。$T$ 到 $a,b$ 的边被翻转一次。
这样操作后,我们成功消去了 $u$ 到 $a,b$ 的边。配对构造直到出边全部消去即可。
- 若 $u$ 点的度数为奇数:考虑归纳。我们对 $u$ 和它的若干邻居进行一次操作,将 $u$ 的度数变为偶数,规约为偶度数情形。
最终,问题被规约到 $n=k+2$ 的残余图中。
观察每次操作取 $k$ 个点,此时必有 $2$ 个点空余。将操作转换为选择两个点 $i,j$,翻转所有不接触节点 $i,j$ 的边。设 $f_{i,j}$ 表示操作 $(i,j)$ 进行的次数。
记 $m$ 为当前总边数,$x_{i,j}$ 为当前图的邻接矩阵,$\text{deg}_i$ 为点 $i$ 的度数。在 $\mathbb{F}_2$ 域中,以下方程给出了合法构造:
$$
f_{i,j}=m+\text{deg}_i+\text{deg}_j+x_{i,j}
$$
::::success[证明]{open}
边 $(a,b)$ 的翻转次数为
$$
F(a,b)=\sum_{i,j\notin\{a,b\}}f_{i,j}=\sum_{i,j\notin\{a,b\}}(m+\text{deg}_i+\text{deg}_j+x_{i,j})
$$
只要证 $\mathbb{F}_2$ 域下 $F(a,b)=x_{i,j}$。
将求和拆掉,对括号内的三类贡献分别求和:
- 常数 $m$ 的贡献:外部点对数为 $\binom{k}{2}$,故其被计算 $\binom{k}{2}$ 次。
- 点权 $\text{deg}_i+\text{deg}_j$ 的贡献:对于外部点 $i$,它与其余 $k-1$ 个点配对,每个 $\text{deg}_i$ 会被计算 $k-1$ 次。
由握手定理得 $\sum\text{deg}_i=0$ 进而 $\sum\limits_{i\notin\{a,b\}}\text{deg}_i=\text{deg}_a+\text{deg}_b$。故 $\text{deg}_i+\text{deg}_j$ 被计算 $k-1$ 次。
- 边权 $x_{i,j}$ 的贡献:由容斥原理 $|A\cup B|=|U|-|A|-|B|+|A\cap B|$,只要求 $m-\text{deg}_a-\text{deg}_b+x_{a,b}$ 即可。在 $\mathbb{F}_2$ 域下等价于 $m+\text{deg}_a+\text{deg}_b+x_{a,b}$。
综上所述
$$
\begin{aligned}
F(a,b)&=\binom{k}{2}m+(k-1)(\text{deg}_a+\text{deg}_b)+m+\text{deg}_a+\text{deg}_b+x_{a,b}\\
&=\left(\binom{k}{2}+1\right)m+k(\text{deg}_a+\text{deg}_b)+x_{a,b}
\end{aligned}
$$
按照 $k\bmod4$ 分类讨论:
- 若 $k\equiv2\pmod4$:此时 $\binom{k}{2}$ 为奇数,$k$ 为偶数,$m$ 和 $\text{deg}$ 前的系数均为 $0$,得证。
- 若 $k\equiv0\pmod4$:此时 $k$ 为偶数,且 $m$ 恒为 $0$,得证。
- 若 $k\equiv3\pmod4$:此时 $\binom{k}{2}$ 为奇数,且 $\text{deg}$ 恒为 $0$,得证。
- 若 $k\equiv1\pmod4$:此时 $m$ 和 $\text{deg}$ 恒为 $0$,得证。
至此完成证明,上述构造合法。
::::
::::info[一种本质]{open}
下面从更本质的视角来看待最后的构造。
最终构造本质上是在一个形如 $A\vec{f}=\vec{x}$ 的线性方程组。
根据第一部分的计算,除 $k\equiv2\pmod4$ 的情形外,其余情形 $\dim U^{\perp}>0$。由对偶原理,操作空间中必然存在线性相关的操作。
因此,我们需要建立操作空间的线性基,去除那些线性相关的操作,最后只保留一个基底集合。在这个基上,方程 $A\vec{f}=\vec{x}$ 有唯一解,确认了构造的可行性。
实际上,对 $k\le70$ 的部分可以用 bitset 优化线性基做到 $O\left(\dfrac{k^6}{w}\right)$,跳过最终构造。而我们给出的 $f$ 就是,把线性基在消元过程中所有自由变量设为一个常数后,所得到的一组唯一特解。
::::
代码实现就是大模拟,想清楚后并不难写。
单组数据复杂度 $O(n^2 k)$,需要精细实现防止被卡常。
::::::
::::::info[代码]
```cpp line-numbers
void starmap(int n, int m, int k, int p, std::vector<int> u, std::vector<int> v) {
vector<vector<int>> e(n + 5, vector<int>(n + 5, 1));
vector<int> deg(n + 5, 0);
for (int i = 0; i < m; i++) e[u[i]][v[i]] = 0, e[v[i]][u[i]] = 0;
m = 0;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (e[i][j]) deg[i]++, deg[j]++, m++;
vector<pair<int, int>> keep;
vector<int> odd;
for (int i = 1; i <= n; i++)
if (deg[i] & 1) odd.emplace_back(i);
int t = n * (n - 1) / 2, d = 0;
switch (k % 4) {
case 2: d = 0; break;
case 0: {
if (m & 1) keep.emplace_back(1, 2), d = 1;
break;
}
case 3: {
for (int i = 0; i < (int)odd.size(); i += 2) keep.emplace_back(odd[i], odd[i+1]);
d = odd.size() / 2;
break;
}
case 1: {
int c = odd.size();
if (c / 2 % 2 == m % 2) {
for (int i = 0; i < (int)odd.size(); i += 2) keep.emplace_back(odd[i], odd[i+1]);
d = c / 2;
} else if (c > 0) {
int u = odd[0], v = odd[1], w = 1;
while (w == u || w == v) w++;
keep.emplace_back(u, w), keep.emplace_back(w, v);
for (int i = 2; i < (int)odd.size(); i += 2) keep.emplace_back(odd[i], odd[i+1]);
d = c / 2 + 1;
} else {
keep = {{1, 2}, {2, 3}, {3, 1}}, d = 3;
}
break;
}
}
report(t - d);
for (auto [u, v] : keep) e[u][v] ^= 1, e[v][u] ^= 1;
vector<vector<int>> vec;
auto OP = [&](vector<int> s) -> void {
assert((int)s.size() == k);
invert(s);
for (int i = 0; i < k; i++)
for (int j = i + 1; j < k; j++)
e[s[i]][s[j]] ^= 1, e[s[j]][s[i]] ^= 1;
};
// 1. --> n=k+2
for (int u = 1; u + k + 2 <= n; u++) {
vector<int> nei;
for (int v = u + 1; v <= n; v++)
if (e[u][v]) nei.emplace_back(v);
if (nei.size() & 1) {
int a = nei.back();
vector<int> s = {u, a};
for (int v = u + 1; v <= n; v++)
if (v != a && (int)s.size() < k) s.emplace_back(v);
OP(s);
nei.clear();
for (int v = u + 1; v <= n; v++)
if (e[u][v]) nei.emplace_back(v);
}
for (int i = 0; i < (int)nei.size(); i += 2) {
int a = nei[i], b = nei[i+1];
vector<int> s;
for (int v = u + 1; v <= n; v++)
if (v != a && v != b && (int)s.size() < k - 2) s.emplace_back(v);
vector<int> t1 = {u, a}, t2 = {u, b};
t1.insert(t1.end(), s.begin(), s.end());
t2.insert(t2.end(), s.begin(), s.end());
OP(t1), OP(t2);
}
}
// 2. f_{i,j} = m + deg_i+deg_j + x_{i,j}
fill(deg.begin(), deg.end(), 0), m = 0;
int bg = n - k - 1;
for (int i = bg; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (e[i][j]) m++, deg[i]++, deg[j]++;
vector<pair<int, int>> h;
for (int i = bg; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if ((m + deg[i] + deg[j] + e[i][j]) & 1)
h.emplace_back(i, j);
for (auto [a, b] : h) {
vector<int> s;
for (int i = bg; i <= n; i++)
if (i != a && i != b) s.emplace_back(i);
invert(s);
}
}
```
::::::