「做题记录」贪心构造选做

· · 算法·理论

先写一些贪心的基本理论,然后做题。

调整法

记 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 上的严格全序,需同时满足以下四个性质:

事实上,由反自反性和传递性可以推出非对称性。

举例:小于 < 是 \mathbb{R} 上的严格全序,但是小于等于 \le 不是,因为其不满足反自反性和非对称性。

:::::info[练习 1]{open} 记字符串 A,B 首尾拼接的结果为 AB,< 表示字典序比较。定义二元关系 \prec 为:A\prec B\iff AB<BA。

问:\prec 是否是字符串集合上的严格全序?

::::success[答案] 是。

传递性证明中,涉及到了无穷次幂比较字典序的问题,欢迎查看作者的另一篇文章。
:::::

:::::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。

反悔贪心

贪心选择的是局部最优解。如果策略不优,在某个时刻会发现全局最优不能由此策略得到,或者继续按照此策略执行会违反题目限制,需要调整。

反悔贪心中,调整的方法有两种:

反悔贪心的题目常常可以被建模为费用流,然后使用模拟费用流解决。从费用流的角度来看,每一次反悔就相当于在残量网络中建立反向边。

模拟费用流

模拟费用流主要有关键点、单 / 双向链两种类型。关键点型的模拟费用流一般也可以用反悔贪心理解。

考察费用流的 SSP 算法,也就是将 EK 或 Dinic 中寻找增广路的算法,替换为用于寻找费用最小路径的最短路算法。

在模拟费用流中,我们通常考察的是 EK 算法。下面复述一遍 EK 求解最小费用最大流的算法流程:

在网络图的形态比较特殊时,我们可以用数据结构维护这些过程,这也就是模拟费用流的观点。

上面给出了最小费用最大流的算法。我们再给出如下扩展:

关于费用流的一些经典结论:

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 定理的一些推论:

另一个与二分图有关的重要结论:

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}

:::::

可以证明,GKK 算法的期望复杂度是 O(nk+n\log n) 的。模板题的 submission。

问题 2 将 G 分解为 k 组不交完美匹配,求一组方案。

直接进行归纳构造,每轮用 GKK 求出完美匹配,删去后递归求解,重复 k 轮,复杂度 O(nk^2+nk\log n)。

还有更优秀的归纳构造手法。对 k 分奇偶讨论:

这样分治的复杂度是 O(nk\log k+n\log n\log k) 的。代码可以参考 submission。

Dilworth 定理

称 \preceq 是 S 上的偏序,需同时满足以下三个性质:

请读者注意区分偏序 & 全序。

对于有限偏序集,我们可以用 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:

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 最小链覆盖问题常见的处理手法:

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}

:::::

算法 1 等价于在 DAG 上进行 Dijkstra。

注意到算法 1 并不需要显式建出 G。观察算法 1 的复杂度瓶颈:

  1. 枚举 (x,y)\in E 的所有的 y。
  2. 判定 x\in S 是否成立,修改 S\gets S\cup\{x\}。

一般地,认为可以在 O(1) 内解决问题一。若问题二存在 O(\log|S|) 的高效算法,算法 1 的复杂度即为 O(k\log k)。

更一般地,认定问题二不存在高效算法。注意到 G 的形态是以 x_1 为根的外向树时,有如下算法成立:

:::::info[算法 2]{open}

:::::

这是 Shopping Plans Trick 的一般性算法。易知复杂度 O(k\log k)。

我们考察算法 2 的本质。形式化地,我们对全体 x\in\Omega 构造了转移集合 \text{trans}(x),且转移满足下列性质:

两种算法都需要满足最优性和覆盖性,算法 2 需要满足唯一性。

进一步,对覆盖性进行扩展:

若 \text{trans} 仍满足最优性和唯一性,有如下算法成立:

:::::info[算法 3]{open}

:::::

若 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)。

显见最优性成立,下证覆盖性和唯一性成立:

使用算法 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。

:::::

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}

注意到不等式的右侧正是原函数 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 其实就是根据上述性质,维护凸函数的一类技巧。通常有两组维护方式,一种是维护拐点,即斜率的突变点,另一种则是直接维护斜率段,即差分数组。

上面的说法比较抽象,读者可能需要借助例题来理解。

构造技巧

写一点基本的做题角度:

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) 得到当前数字。最后特判是否需要整体翻转。

复杂度 O(n)。

:::::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 为去左边、去右边、留在原点的人数。

进行三次扫描:

  1. 从右向左确定每个位置 y_i 的上限 f_i。由于 i,i+1 共享一条边,这里的 y_i 受到右侧约束。可以通过递推算出。
  2. 从左向右检查可行性。考虑左侧节点输送了一些人,当前节点的一些人被迫向右走,如果向右的人数超过了 f_i,则无解。贪心地,我们希望向右人数最小。
  3. 从左向右开始分配。此时假定左侧已经安排完成,优先将人向左分配填 x_i。由于我们希望最小化 z_i,接下来确定 y_i 并尽量达到 f_i 的上界。

正确性比较显然,如果当前不用完代价也不会消失,而用完并不会改变后续代价。

复杂度 O(n)。

:::::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 游戏,具体地,你持有一个多重集,每次选择如下两种操作之一:

  1. 加入一个 2 或 4。
  2. 选择两个相同数 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 的得分上下界,可以如下分析:

只要通过把两次加入的 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。

理清上述思路后贪心即可,求出当前情况所能得到的最大得分,将最大幂次加入答案集合,然后继续求解。

复杂度 O(T k^2)。

:::::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:

作差得

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 是一个严格全序。

复杂度 O(Tnm)。

:::::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 进行转移:

复杂度 O(n\log n+nk)。

:::::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 的元素。

复杂度 O(n\log n)。

:::::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,故修改连边。

上述过程复杂度 O(n)。

:::::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[题解] 我们有如下两个观察:

根据上述结论模拟即可。这里我的实现使用了一个大根堆,设目标位置为 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。

复杂度 O(n^2)。

:::::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 分成若干同余类,由于返祖边的性质,这些同余类一定都是独立集。感性理解一下,所有集合中必然存在至少一个满足要求的集合,于是做完了。

复杂度 O(n+m)。

:::::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 的情形。

复杂度 O(Tn\log n)。

:::::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。

复杂度 O(n\log n)。

:::::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[题解] 观察性质:每辆车有且仅有一段超速区间。

考虑把这段区间处理出来,根据物理知识,我们分类讨论:

将坐标离散化,第一问差分一下即可解决。

下面解决第二问:将所有区间按右端点降序排序,并顺次扫描每个区间。若当前区间内还未添加监控,就加入最右侧的监控。模拟即可。

复杂度 O(Tn\log n)。

:::::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$。 ![](https://cdn.luogu.com.cn/upload/image_hosting/ppuv3fs6.png) 将 $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$ 变为其前缀和。 接下来,我们分类讨论新线与原线是否有交。下文以向右平移为例,向左同理。 - 当新线与原线无交时:此时两侧贡献独立: ![](https://cdn.luogu.com.cn/upload/image_hosting/6kuatzgs.png) 红线的代价为 $g_i=a_{l_i+L}-a_{l_i}$,绿线的代价为 $f_j=b_{l_j+L}-b_{l_j}$。对 $f$ 做一个后缀 $\max$ 即可得到答案。 - 当新线与原线有交时:此时贡献被分为三段: ![](https://cdn.luogu.com.cn/upload/image_hosting/df1us1sn.png) 两侧各有 $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。考虑一个下图所示的结构,箭头表示“卖出—买入”关系: ![](https://cdn.luogu.com.cn/upload/image_hosting/isma4kgy.png) 在中间点,我们再把 $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$ 只有一个则不合法。 考察直径的形态: ![](https://cdn.luogu.com.cn/upload/image_hosting/vv3ds1m8.png) 可以发现直径从 $\max$ 到 $\min$ 展开,由对称性,每个值至少出现两次。 对于直径外的节点,考虑将这些点挂在直径上,成菊花状。容易发现这是合法的。 ![](https://cdn.luogu.com.cn/upload/image_hosting/sjdx8dds.png) 这就是我们的构造。考虑判定,我们的原则是用一堆必要条件拼出充分条件。 特判 $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$ 分类,如图所示: ![](https://cdn.luogu.com.cn/upload/image_hosting/2v8p7zsf.png) 可以发现格子被划分为 $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$,即在首尾反复横跳,如下图: ![](https://cdn.luogu.com.cn/upload/image_hosting/sojw4jy2.png) 于是我们考虑二维时,在左上角和右下角反复横跳。具体地,给出如下构造流程: - 行配对:将行 $(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$ 是有解的第二个必要条件。 判掉两个无解条件后断言有解,下面给出构造式证明。 注意到下面这种走法: ![](https://cdn.luogu.com.cn/upload/image_hosting/1q1fswxz.png) 通过走一个折线,可以删去上面两行,从而把问题规约为 $(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$ 升序排序后,最优解一定形如: ![](https://cdn.luogu.com.cn/upload/image_hosting/ig2luh75.png) 我们可以对前缀做一个 $(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]$ 即可。如图所示: ![](https://cdn.luogu.com.cn/upload/image_hosting/le46k7xy.png) 找到 $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$ 相同。如图: ![](https://cdn.luogu.com.cn/upload/image_hosting/b7wc40yd.png) 对于蓝色的二类数,其列数已经确定(即图中蓝线),此时将其行钦定为与 $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$ 倒着扫,每次遇到一个后缀最大值时,水会被划分开形成若干段,形状是一个矩形。 下图展示了我们的两个观察: ![](https://cdn.luogu.com.cn/upload/image_hosting/00xh4vun.png) 第二张图中,水形成了三个矩形,这些区域是被后缀最大值分开的;第三 & 四张图中,绿色圆圈代表着我们找到的漏水终点。 直接模拟,将两种去向相加,即可做到 $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$。容易说明,其余左兄弟的子树一定被这些子树包含,从而不会成为答案。 ![](https://cdn.luogu.com.cn/upload/image_hosting/nx7w3z40.png) 类比笛卡尔树地,使用单调栈维护右链,对新叶子的位置分类讨论: - 若新叶子属于右链,则弹栈直到 $f_i$ 在栈顶,并将新节点入栈。对于原右链节点,可以暴力合并子树并更新答案,均摊复杂度线性。 ![](https://cdn.luogu.com.cn/upload/image_hosting/9y7xf90l.png) - 若新叶子不属于右链,则找到其贡献的右链节点并更新答案。使用并查集维护代表元。 ![](https://cdn.luogu.com.cn/upload/image_hosting/efd7qwpw.png) 总复杂度 $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$。下面给出一个示例: ![](https://cdn.luogu.com.cn/upload/image_hosting/muqwd71u.png) 上图中,橙色边为源汇点向普通点连的边,紫色边为 $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$ 轴围成的面积。 不难发现选择一个凸包是最优的: ![](https://cdn.luogu.com.cn/upload/image_hosting/lwenhr8v.png) 单调栈求出一个凸包即可,复杂度 $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)$ 画到二维平面上,则关键点之间的点两两共线: ![](https://cdn.luogu.com.cn/upload/image_hosting/7vc9zcdi.png) 上图中,红点为关键点,蓝点为非关键点。 贪心地,红点应当形成一个凸包。于是单调栈求出一个 $(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$ 邻域: ![](https://cdn.luogu.com.cn/upload/image_hosting/rftcdcji.png) ![](https://cdn.luogu.com.cn/upload/image_hosting/hlglnkea.png) 还可以依次验证 $1\sim6$,得到如下构造:节点 $i$ 恰有 $n-i+1$ 一个点不可达。正确性容易说明。 考虑如何实现这个情况。以 $n=8$ 为例,构造一个二分图,左部点为 $1,3,5,7$,右部点为 $2,4,6,8$。除钦定不可达的点对外,左右部点都要连边。这样右部点除不可达点外,是左部点的 $1$ 邻域,所有左部点都是其 $2$ 邻域。 ![](https://cdn.luogu.com.cn/upload/image_hosting/ezts1tca.png) 发现 $n$ 为偶数时可以套用这一构造。下面考虑 $n$ 为奇数的情况。 可以在上述基础上调整。观察搜出来的 $n=7$ 构造,可以得到这样一种调整: ![](https://cdn.luogu.com.cn/upload/image_hosting/8s1bi4ht.png) 首先,加入 $9$ 不会破坏 $f(1)\sim f(8)$ 全相等。 ![](https://cdn.luogu.com.cn/upload/image_hosting/8slfq6nu.png) 同时,所有右部点为 $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$ 个格子,现在从最后一层开始,按照如下规则填写数字:每个格子上的数字是其左下、正下、右下三个格子上数字的中位数。例如: > > ![](https://cdn.luogu.com.cn/upload/vjudge_pic/AT_agc006_d/545e109d7af3caf92b1a8f9ac80715efa6c3d3db.png) > > 设第一行的数字为 $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$ 的网格。你需要在其上防止若干半皇后,使得所有格子都被攻击。一个半皇后能攻击的范围是同行同列、同主对角线上的格子。如图所示: > > ![](https://cdn.luogu.com.cn/upload/vjudge_pic/CF1667C/7bd42db06039264b9144129e45c89b4a8730a512.png) > > 最小化半皇后的数目 $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$ 为奇数且较小的情况,可以找到这样的构造: ![](https://cdn.luogu.com.cn/upload/image_hosting/zfbblhsf.png) 也就是构造两条骑士形的路线。 当 $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),进行讨论:

遍历结束后,将被保留的 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| 则判定无解。复杂度 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) 对式子的影响:

因此题目就转化成:在数轴上有若干区间,你需要选出若干个区间,且每段区间有一个容量上限,最大化选点的数目。

将所有区间按右端点升序排序后能选即选,容易说明正确性。线段树维护这个过程即可,复杂度 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 的标记,并同时存正反串,非常好写。

复杂度 O(nk\log n)。

:::::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。

注意上述推导省略了倍增的 \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(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。从右侧开始倒推,可以发现:

因此,倒数第 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。

全部扫完后,按照推出的公式计算即可。视 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 的取值进行讨论:

这表明策略关于距离单调:

性质 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 即可。

总复杂度 O(n\log n+q)。

:::::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。上述做法都是从一个节点开始扩展,是正向思考,难以做到优秀的复杂度。那么我们正难则反,从反向思考,这基于以下观察:

结合上述做法中的拓扑预处理,我们得到一种交错拓扑的逆向转移:

  1. 首先,将所有边按 a 降序排序并扫描。

  2. 对反图做一轮拓扑,对于拓扑中相关的边 (u,v,a,b),执行转移 f_v\gets\max(a,f_u-b),然后删去这条边。

  3. 若当前扫描到的边 (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 然后仿照上面的做法跑欧拉回路即可。

复杂度 O(n2^n)。

:::::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,分类讨论:

因此,得分的理论上界是

\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 进行三染色。

详细证明可以看这篇题解,这里只给结论。

复杂度 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 插入环中。分类讨论:

::::

我们把这些定理应用到这个问题上。

利用 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=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://cdn.luogu.com.cn/upload/image_hosting/tc1ql7fz.png) (图源:[官方题解](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$。此时行列分离。 ![](https://cdn.luogu.com.cn/upload/image_hosting/ctzowlfv.png) 考虑求出 $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$ 的所有儿子按出边权值升序排序,并将出边形态改为左儿子右兄弟表示法,出边权值变为邻项差分,如图: ![](https://cdn.luogu.com.cn/upload/image_hosting/m49pth1z.png) 这里将儿子按出边权值排序的目的是,保证上述变换后边权非负,导出最优性成立。 我们所有节点同时做上述操作,转移图变为外向二叉树,节点出度为 $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 的移动策略] 初始局面: ![](https://cdn.luogu.com.cn/upload/image_hosting/m5iczt89.png) 我们的原则是,先将栈 $1$ 中的两种颜色分离,再将栈 $2$ 中的元素逐次加入。 为此,我们考虑将栈 $2$ 中的 $7$ 个元素先移动到栈 $3$。这样,栈 $1$ 中的 $7$ 个 $1$ 就能被放到栈 $2$,剩下的 $2$ 就被放到栈 $3$。 ![](https://cdn.luogu.com.cn/upload/image_hosting/zsmmwcq4.png) ![](https://cdn.luogu.com.cn/upload/image_hosting/kmdf4w66.png) 此时,来自栈 $1$ 的两种颜色已经在栈顶形成了两个颜色段。我们将两个颜色段放回栈 $1$,并将栈 $2,3$ 留出一个空栈。 ![](https://cdn.luogu.com.cn/upload/image_hosting/67gjtqhh.png) ![](https://cdn.luogu.com.cn/upload/image_hosting/i5kaoh33.png) 这样,我们就可以将栈 $1$ 顶部的颜色段移动到空栈中: ![](https://cdn.luogu.com.cn/upload/image_hosting/88uwolz7.png) 如此操作后,我们成功分离了原本栈 $1$ 中的两种颜色。对于栈 $2$,只要顺次扫描一遍,放到对应的栈顶即可。 ![](https://cdn.luogu.com.cn/upload/image_hosting/nccwfcaf.png) 操作次数为 $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 的消除策略] 初始局面: ![](https://cdn.luogu.com.cn/upload/image_hosting/9b8y85h3.png) 我们需要一个机械性的策略。 在这里,我们用栈 $1$ 来存放卡牌 $1,2$,用栈 $2$ 存放卡牌 $3,4$。当新加入一张牌时: - 如果这张牌与某个栈的栈顶相同,执行操作一并消去; - 如果这张牌与某个栈的栈底相同,将其加入栈 $3$ 后执行操作二并消去; - 否则,直接加入对应栈。 例如下面这种情况,我们将 $2$ 加入栈 $1$,执行操作一: ![](https://cdn.luogu.com.cn/upload/image_hosting/w9bwtz4l.png) 完成这个操作以后,我们面临下图所示的局面。此时将 $3$ 加入栈 $3$,并对栈 $2,3$ 做操作二。 ![](https://cdn.luogu.com.cn/upload/image_hosting/epncq6w7.png) 重复上述流程,至牌堆为空。 ::::: 根据上述消除策略,我们得到了 $k=2n-2$ 的做法,留一个空栈,剩余的 $n-1$ 个栈内只放两张牌,模拟即可。可以获得 [15 分](https://www.luogu.com.cn/record/268858946)。 考虑 $k=2n-1$。当所有普通栈都塞满,而此时发来的又是一张没有匹配的新牌时,套用上述讨论很可能陷入死局。 注意到本题中我们并不需要在线决策,而是可以看到牌堆的全貌。那么记第一个将会出现的栈底牌为 $x$,压在它上面的牌为 $y$。为了解决这种局面,我们希望消去 $x$,那么就需要讨论是先消去 $y$,还是直接绕过 $y$。 :::::info[样例 3 的消除策略] 初始局面: ![](https://cdn.luogu.com.cn/upload/image_hosting/7b6eu5zp.png) 按照平凡策略得到的局面: ![](https://cdn.luogu.com.cn/upload/image_hosting/ko6rq215.png) 此时我们有 $x=1,y=2$。观察牌堆,在 $1$ 出现之前,$2$ 只出现了一次。于是我们有如下操作: - 将 $5$ 放入栈 $3$; - 用发下来的 $2$ 消去栈 $1$ 顶部的 $2$; - 用发下来的 $1$ 消去栈 $1$ 顶部的 $1$。 操作结束后的局面为: ![](https://cdn.luogu.com.cn/upload/image_hosting/a4utzcgy.png) 此时我们制造了一个空栈,可以继续用平凡策略消除了。 ::::: :::::info[样例 4 的消除策略] 初始局面不放了,按照平凡策略消去后的局面为: ![](https://cdn.luogu.com.cn/upload/image_hosting/auu67nk6.png) 此时仍有 $x=1,y=2$。但是再按样例 3 的做法是错误的。如果将 $5$ 放入栈 $3$,两个 $2$ 下来消除后,还会剩下一个 $2$: ![](https://cdn.luogu.com.cn/upload/image_hosting/oncg1h5v.png) 这个局面已经无解。 考虑问题出现在哪里,发现这里 $2$ 出现了**偶数次**!这里的正解是: - 将 $5$ 直接放入栈 $1$; - 偶数个 $2$ 任选一个栈消掉 - 然后将 $1$ 放入栈 $3$,对栈 $1,3$ 执行操作二。 示例图: ![](https://cdn.luogu.com.cn/upload/image_hosting/r7jl4ods.png) ::::: 观察样例 $3,4$ 消除策略的异同点,我们发现: - 当 $y$ 出现奇数次时,多出来的牌可以直接放入辅助栈,被堵住的栈可以用 $y$ 来打通; - 当 $y$ 出现偶数次时,新牌要叠在 $y$ 上面,然后利用空栈消除栈底。 上述策略可能存在一个问题,就是 $x,y$ 之间混入其他牌。让我们来看一下样例 5: :::::info[样例 5 的消除策略] 快进到这个局面: ![](https://cdn.luogu.com.cn/upload/image_hosting/897ns368.png) 此时 $x=1,y=2$,但是我们发现 $5\to1$ 的过程中有一堆 $4$ 的干扰。 仔细思考一下,如果 $4$ 出现奇数次,放入栈 $2$ 消除以后,栈 $2$ 中只有一个 $3$,不会影响。 而如果出现偶数次,我们仍然可以在栈 $2$ 中消除,消除后的局面: (这里由于 $y$ 出现偶数次,将 $5$ 放入栈 $1$) ![](https://cdn.luogu.com.cn/upload/image_hosting/mcb9qjuv.png) 此时我们再使用样例 $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[题解] 考察合法的树的形态。我们注意到,下图所示的树是无效的: ![](https://cdn.luogu.com.cn/upload/image_hosting/ero75ukx.png?x-oss-process=image/resize,m_lfit,w_200) 原因是,这种树无法生成下面这种形态的树: ![](https://cdn.luogu.com.cn/upload/image_hosting/mi1g6hj8.png?x-oss-process=image/resize,m_lfit,w_200) 其中 $T$ 可以是任意树。 我们将所有无效树丢掉,有用的树其实只会有四种形态: ![](https://cdn.luogu.com.cn/upload/image_hosting/wy6tbxph.png) 如果这四种形态的树都存在,那么这一层的树可以被生成。 考虑递归判定。我们将四种情形对应的子树抽取出来,作为新的集合 $\mathscr{T}$ 判断。如果四种情况都合法,那么原集合就是合法的。 递归的终止条件是 $\mathscr{T}=\varnothing$ 或者 $\mathscr{T}$ 包含单点。 分析一下复杂度,四种情形几乎无交,唯一有交的是 ![](https://cdn.luogu.com.cn/upload/image_hosting/13qk9evb.png?x-oss-process=image/resize,m_lfit,w_100) 这种形态的树,可以忽略掉。那么每层递归的总代价是 $|\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$。 ![](https://cdn.luogu.com.cn/upload/image_hosting/pzu6vy4c.png) 下面考察 $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 矩阵满足上述条件。给出如下构造方法: ![](https://cdn.luogu.com.cn/upload/image_hosting/estm5qro.png) 当 $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$ 的位置关系如图: ![](https://cdn.luogu.com.cn/upload/image_hosting/wl4fq1l5.png) 不妨设 $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$ 同色,则做如下连边: ![](https://cdn.luogu.com.cn/upload/image_hosting/z68grwrz.png?x-oss-process=image/resize,m_lfit,w_360) 这样显然不会冲突,并且将 $B,C,D$ 缩成一点 $F$ 后,可以在 $F$ 上方的连边等效到 $B$ 上,在 $F$ 下方的连边等效到 $D$ 上。这样,问题转化为相邻顶点不同色的情形。 转化到凸多边形以后,我们有一种重要的操作:考虑连续三个点 $A,B,C$,剖分得到 $\triangle ABC$ 后,将这个三角形割去,则问题就变成了一个 $n-1$ 条边的子问题,如图: ![](https://cdn.luogu.com.cn/upload/image_hosting/8i7n8et7.png?x-oss-process=image/resize,m_lfit,w_360) 这个操作需要 $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 矩形内: ![](https://cdn.luogu.com.cn/upload/image_hosting/mq4fpelj.png?x-oss-process=image/resize,m_lfit,w_400) 可以做主席树优化建图,或者 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 数列: ![](https://cdn.luogu.com.cn/upload/image_hosting/49ncb5gi.png) 设 $f_n$ 表示 Fibonacci 数列第 $n$ 项,有 $f_{88}>10^{18}$,于是网格大小在 $44$ 左右,这是符合要求的。 根据 Zeckendorf 定理,一个正整数总能被拆成若干不连续的 Fibonacci 数的和的形式。具体地,考虑贪心,降序扫描每个 $f_n$,能减即减即可。 考虑构造如下形式的网格: ![](https://cdn.luogu.com.cn/upload/image_hosting/fsvp729p.png) 除了蓝色的终点外,其余颜色交界处放墙。图中的颜色有如下含义: - 黄色:Fibonacci 数列区。 - 绿色:答案路径区。 - 红色:我们钦定不能到达的区域。 保护出一条绿色路径,则对于每个整数的分解形式,打开对应的墙即可。例如 $133=2+8+13+21+89$,则打开红线标记的墙: ![](https://cdn.luogu.com.cn/upload/image_hosting/j8829ybt.png) 现在我们可以做到给任意目标找一个构造了。但这需要 $346$ 个墙,无法通过。 注意到红区与绿区之间其实并不需要全部堵上,只要保护出绿区即可。具体来说,我们可以只在紫色线的区域放墙: ![](https://cdn.luogu.com.cn/upload/image_hosting/2wm27ntf.png) 这样墙的数目最多只有 $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$ 即可。如图: ![](https://cdn.luogu.com.cn/upload/image_hosting/pcalmqqm.png) :::::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$ 的后缀上。但此时我们需要决策中间段的填法。 ![](https://cdn.luogu.com.cn/upload/image_hosting/mwplhczh.png) 我们断言:中间段填入 $\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。我们可以用下图所示的操作将矩阵转置: ![](https://cdn.luogu.com.cn/upload/image_hosting/o164k8gj.png?x-oss-process=image/resize,m_lfit,w_240) 上图中,同色的两个数进行交换。形象地说,相当于沿着主对角线对称地进行交换。 尝试将问题规约到平凡情形。 考虑二分图建模,左部点为 $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$ 在切线处取得最大值,如图: ![](https://cdn.luogu.com.cn/upload/image_hosting/egcgohze.png) 考虑使用解析几何的知识解决。设直线 $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 树不存在横叉边,只需讨论返祖边对策略的干扰。 ![](https://cdn.luogu.com.cn/upload/image_hosting/nfkzaihg.png) 如上图,我们发现原策略会在这种情况下爆掉。当我们位于返祖边的一个端点时,其邻域没有 $0$ 且同时存在多个 $1$。如果错误地走了红色的路线,就会离开这棵子树,从而漏掉一些点。正确的遍历顺序是走绿色路线。 上面的做法里,我们有两个信息没有用到:颜色 $ 3$ 和当前点颜色。考虑使用这些额外信息区分环上的点。 假设出问题的点是 $u$,其 DFS 树上的父亲为 $p$,返祖边指向的祖先为 $v$。无法直接区分 $p$ 和 $v$,只能随意走向一个节点进行尝试。 我们将 $u$ 点的颜色记为 $3$,并且定义一个节点的活跃度为:当前节点邻域中颜色 $1$ 的数目。对 $p$ 和 $v$ 的活跃度进行观察: ![](https://cdn.luogu.com.cn/upload/image_hosting/rh5p2vdf.png) 可以发现,$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 生成树。 ![](https://cdn.luogu.com.cn/upload/image_hosting/3126rasm.png) 如图所示,我们期望的路径是绿色路径。但实际上,考虑 $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$ 的倍数,方案是平凡的。 ![](https://cdn.luogu.com.cn/upload/image_hosting/qi8d6mwx.png) 如图所示,橙色部分可以等价于 $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)$,手玩得 ![](https://cdn.luogu.com.cn/upload/image_hosting/zfvlyllr.png) ![](https://cdn.luogu.com.cn/upload/image_hosting/xmngkylf.png) 如图所示,依次执行操作 $A(1,3,4,5)$ 和 $A(4,5,1,3)$ 的效果为: ![](https://cdn.luogu.com.cn/upload/image_hosting/52gauew9.png) 因此,我们可以实现将一条边 $+2$,一条边 $-2$ 的操作,记为 $B(a,b,c,d)$。$B$ 操作可以在 $K_4$ 上实现,代价为 $2$。 $B$ 操作的缺陷在于,$(a,b),(c,d)$ 边不能共顶点。通过引入一条辅助边,我们可以将这个操作转移到共顶点的情况: ![](https://cdn.luogu.com.cn/upload/image_hosting/euec7793.png) ![](https://cdn.luogu.com.cn/upload/image_hosting/vy2q0sfi.png) ![](https://cdn.luogu.com.cn/upload/image_hosting/9cqgc8sw.png) 通过 $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 ``` 执行完成的结果为: ![](https://cdn.luogu.com.cn/upload/image_hosting/3lbulnq6.png) 操作改变了 $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{)}}$ 建立括号树,在树上刻画操作的性质。 可以发现,操作二允许我们无代价地交换两个子树,故下文不区分儿子的顺序。 考虑操作一对树形态的改变,如图所示: ![](https://cdn.luogu.com.cn/upload/image_hosting/yjry5wpk.png) 形式化地,我们对操作一进行如下描述: - 选择一对兄弟节点 $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); } } ``` ::::::