分而治之

CSP 2025 游记

Sun, 21 Sep 2025 19:06:00 +0800

CSP-S 2025 初赛

Day -x

一年一度的 CSP，我回来啦！

由于去年已经拿到了普及组一等奖，所以这次没有报名 J 组。1+3 来到了北朝未，因此接下来四年的报名所在学校都将是北大附中。今年是第一次在北大附中考，想想还有些小激动。

今年是我 OI 生涯的第 5 年，所以在初赛前我完全没有一丁点压力。

Day 0

看了下准考证，发现居然是下午两点半才开始，于是在家里休息，好好睡个懒觉。

上午十一点半出发，由于北大附中附近没停车场，我只好坐地铁去。出门就发现身上一个能刷地铁的东西都没有，还好有我亲爱的爸爸帮我买单程票。

十二点半到达了附近的商场，吃个午饭，结果找了半天都找不到没有满座的店，最后选择了一家只剩一个空座的卤肉饭店。

午饭吃完，可是这时才刚到下午一点半，前往考场未免有些太早了，犹豫一番后决定还是进去考场吧，反正在外面也没啥想干的事情。

进了考场，我震惊了！考场就是一个大体育馆和一个大体育馆组成的！我所在的体育馆里共有 26 列 25 行座位，一眼望去全是考生。

发卷，一共 14 页，看到第 1 题是个组合数学的题，我很惊讶，居然单选没有送分题？上来就出一道大难题。不过因为我在赛前复习过，所以第 1 题对我轻轻松松。

接着往后做，做到了阅读第 2 题，发现居然是前些年特别知名的大厂面试题（可能是吧，没印象了），程序都没读就直接开始做题（考后才发现有一道判断题大意了做错了）。

两道完善程序都没读懂，就和大家说的一样：完蛋程序。

考试结束，出来之后感觉天都塌了，估分 81.5。

Loftya 的题单题解 (1)

Sun, 14 Sep 2025 14:35:00 +0800

U609517 异或跳

提示

$x \oplus x = 0$

题解

容易发现，无论怎么跳，成本的异或和均为 $a_1 \oplus a_n$，直接输出即可。

U609469 构造回文串

提示1

区间 DP

提示2

状态表示：$f[i][j]$ 表示令 $i$ 到 $j$ 的范围内为回文串的最小插入次数。

题解

区间 DP，状态表示：$f[i][j]$ 表示令 $i$ 到 $j$ 的范围内为回文串的最小插入次数。

状态转移：人人为我思路。

$f[i + 1][j - 1]$ 可以转移到 $f[i][j]$ 当且仅当 $s[i] = s[j]$；
$f[i + 1][j] + 1$ 可以转移到 $f[i][j]$ 无论何时；
同理 $f[i][j - 1] + 1$ 可以转移。

U606373 油量问题

提示

贪心

题解

将位置 $0$ 视为加油站，在每个加油站选择最远能到达的加油站。

CF-2134 (Codeforces Round 1045, Div. 2) 题解

Wed, 27 Aug 2025 17:50:00 +0800

2134A. Painting With Two Colors

题意

给定三个正整数 $n, a, b$。

有一排 $n$ 个格子，每个格子初始颜色为白色。你需要进行以下两步操作：

选择 $a$ 个连续的格子，将这些格子涂成红色；
选择 $b$ 个连续的格子，将这些格子涂成蓝色。

蓝色会覆盖红色。

请问是否存在一种涂色方案使得这一排格子是左右对称的？

题解

考虑更简单的版本：只需要涂 $b$ 个格子为蓝色，那么涂成蓝色的部分必须处于正中间。

什么情况下可以处于正中间呢？$1$ 号格子到蓝色区域左端的距离等于蓝色区域右端到 $n$ 号格子的距离，即 $n = b + 2 \cdot k$，$k$ 表示 $1$ 号格子到蓝色区域左端的距离。稍加分析即可得出结论：$n$ 和 $b$ 的奇偶性必须一样。

回到原来的问题，存在两种可能：

$a \leq b$，此时把红色涂到能被蓝色覆盖的地方就可以了；
$a > b$，这时红色也需要是左右对称的，与蓝色同理，$n$ 和 $a$ 的奇偶性也必须一样。

参考代码

Code (C++)

qwe

CF-2133 (Codeforces Round 1044, Div. 2) 题解

Mon, 25 Aug 2025 21:51:00 +0800

2133A. Redstone?

题意

有 $n$ 个齿轮，第 $i$ 个齿轮有 $a_i$ 个齿。

现在将齿轮排成一横排，以每秒 $1$ 圈的速度转动最左侧的齿轮；对于其他齿轮，设该齿轮有 $a_i$ 个齿，它左侧的齿轮有 $a_{i - 1}$ 个齿，左侧齿轮转速为 $rev_{i - 1}$，则该齿轮的转速为 $\frac{a_{i - 1}}{a_i} \cdot rev_{i - 1}$ 圈每秒。

请问存不存在一种排列方式使得最右侧的齿轮每秒转 $1$ 圈？

题解

设第 $i$ 个齿轮的齿的线速度为 $v_i$，则 $v_i = a_i \cdot rev_i$。

根据题中齿轮转速公式，可得：$v_{i + 1} = a_{i + 1} \cdot \frac{a_i}{a_{i + 1}} \cdot rev_i = a_i \cdot rev_i = v_i (i < n)$，即 $v_1 = v_2 = v_3 = \dots = v_n$。

什么时候有 $rev_1 = 1 = rev_n$ 呢？容易证明，当且仅当 $a_1 = a_n$ 时两齿轮转速相等。

那么排列方式就是把任意一对齿数相等的齿轮放在两端，剩余的齿轮在中间任意放置。若没有齿数相等的齿轮，则没有排列方式。

答案显而易见，判断是否有齿数相等的齿轮。

参考代码

O(n^2) 做法

Submission #335515090

O(n log n) 做法

在 C++ 中，unique() 函数会返回一个迭代器，指向去重后的数组末尾，我们通过这个迭代器可以计算出新数组的长度，进一步我们可以判断数组长度是否有减少，若有减少，则说明有齿数相等的齿轮。

Submission #335402522

O(n) 做法 1

由于数据范围足够小，所以完全不会产生哈希碰撞，set 的单次操作复杂度为 $O(1)$。

Submission #335440738

O(n) 做法 2

由于数据范围足够小，所以我们可以记录每个齿数出现的次数。

Submission #335516343

2133B. Villagers

题意

无向图 $G$ 中有 $n$ 个点，每个点有点权 $g_i$，初始状态下图中没有边。

可以进行以下操作任意次：

选取两个点 $i$ 和 $j$；
支付操作成本 $max(g_i, g_j)$；
使两个点的点权降低 $min(g_i, g_j)$；
添加一条边连接 $i$ 和 $j$。

输出使 $G$ 成为连通图所需的最小成本。

题解

发现每次操作后，两个点中点权较小的点的点权会变为 $0$，而连接两个点权为 $0$ 的节点是没有成本的。因此，我们只需要记录所有的点都经过一次操作所需成本，而后续合并是无成本的。

排序 $g$ 数组，可以证明一种最优方案为连接 $n$ 与 $n - 1$、$n - 2$ 与 $n - 3$……

证明：考虑在 $n \geq 4$ 情况下连接 $n$ 与 $x$、$n - 1$ 与 $y$（$x, y \in [1, n - 2]$）：

这两组连接的操作成本为 $g_n + g_{n - 1}$；
如果换为连接 $n$ 与 $n - 1$、$x$ 与 $y$，操作成本为 $g_n + max(g_x, g_y)$；
由于 $max(g_x, g_y) \leq g_{n - 1}$，后者的操作成本小于前者，应当使用后者的连接方式；
问题可以无后效性地转移到 $n - 2$。

特别地：

$n = 3$ 时，连接 $2$ 与 $3$、$1$ 与 $2$，操作成本为 $g_1 + g_3$，为最小值。
$n = 2$ 时，连接 $1$ 与 $2$，操作成本为 $g_2$，为最小值。
转移不到 $n = 1$ 的情况。

最优方案的总成本为 $g_n + g_{n - 2} + g_{n - 4} + \dots$。

参考代码

Submission #335433243

2133C. The Nether

题意

交互题。

一个未知的有向图有 $n$ 个点，请在至多 $2 \cdot n$ 次查询中，找出图中最长路径。

每次操作时，你需要输出一个点 $x$ 与一个包含任意多点的集合 $S$，满足 $x \in S$，评测机将返回从 $x$ 出发只经过 $S$ 中的点的路径的最大长度。

题解

首先，我们需要找出最长路径的起点，可以通过遍历所有点，查询从该点 $i$ 出发的最长路径长度（记作 $f_i$），记 $f_i$ 最大的 $i$ 为 $ans_1$，最大的 $f_i$ 记作 $len$。

接着，我们要找出最长路径中第 $2$ 个点，这个点显然必须满足 $f_i = len - 1$，而且 $ans_1$ 到 $i$ 必须有连边。所以我们需要遍历所有满足条件的点，并查询从 $ans_1$ 出发只经过 $i$ 的最长路径长度，若是 $2$，则表明 $ans_1$ 到 $i$ 有连边，可以选作 $ans_2$。

循环地找出最长路径中其他的点，最后输出 $ans$ 即可。

因为每个节点至多满足一次 $f_i = len - i + 1$，所以第二部分至多执行 $n - 1$ 次查询。总共至多执行 $2n - 1$ 次查询，满足题目要求。

参考代码

Submission #335435769

2133D. Chicken Jockey

题意

有 $n$ 个怪物，这些怪物上下叠在一起，其中怪物 $1$ 在最底部，怪物 $n$ 在最顶部，每个怪物有 $h_i$ 的初始生命值。

Steve 可以攻击任意怪物造成 $1$ 点伤害。如果一个怪物的剩余生命值小于等于 $0$，它将会死亡，然后它上方的所有怪物将会摔落成为新的一叠，新的一叠中的最底部的怪物会受到摔落伤害，摔落伤害是可以致命的，因此可能触发连锁反应。

摔落伤害：等同于其在摔落前压着的怪物数（被击杀的那个也算）。

请问最少需要多少次攻击，使得所有怪物都死亡？

题解

发现：

一个怪物至多受到一次摔落伤害，因为受到摔落伤害说明它是一叠的最底部，不可能再摔落了；
怪物 $i$ 有两种方式死亡：直接击杀或者摔落受到 $i - 1$ 点伤害。

使用 DP 解决：f[i] 表示击杀前 $i$ 个怪物需要多少次攻击。

根据发现的规律，可以得到状态转移方程：

让前 $i - 1$ 个怪物全部死亡，然后受到 $1$ 点摔落伤害，最后攻击 $h_i - 1$ 次击杀，f[i] = f[i - 1] + h[i] - 1；
击杀第 $i - 1$ 个怪物，然后受到 $i - 1$ 点摔落伤害，并攻击直至击杀，最后让前 $i - 2$ 个怪物死亡，f[i] = f[i - 2] + h[i - 1] + max(0, h[i] - (i - 1))。

参考代码

Submission #335402193

CF-2132 (Codeforces Round 1043, Div. 3) 题解

Sun, 24 Aug 2025 13:34:00 +0800

2132A. Homework

题意

有 Vlad 和 Dima 两个人，他们需要依次将字符串 $b$ 中的每个字母放到字符串 $a$ 的头或尾。其中 Vlad 会将字母放到 $a$ 的开头，Dima 会将字母放到 $a$ 的末尾。

已知三个字符串，$a, b, c$，其中 $c$ 代表两人操作顺序。若 $c_i$ 为 V，则第 $i$ 个字母由 Vlad 放置；若 $c_i$ 为 D，则由 Dima 放置。

输出 $a$ 的最终状态。

题解

模拟即可。

考虑简单的实现方式，由于添加到开头（左侧）不太方便，所以我们将添加到左侧的字符保存到另一字符串中，在所有操作结束后逆序输出。

参考代码

Submission #334976874

2132B. The Secret Number

题意

对于数字 $x$，可以进行一次操作：

在 $x$ 的末尾添加至少 $1$ 个数字 $0$，赋值给 $y$。
操作后的数 $n = x + y$。

给定 $n$，求所有可能的 $x$，从小至大排序输出。

题解

发现

$$y = x \cdot 10^k$$

其中 $k$ 是添加的 $0$ 的个数，满足 $k \in \mathbb{N}^+$。

因此：

$$n = x + x \cdot 10^k = x \cdot (10^k + 1)$$

即对于给定的 $n$，所有可能的 $x$ 的值为：

$$\frac{n}{10^k + 1} 当 k \in \mathbb{N}^+ 且 (10^k + 1) | n$$

参考代码

Submission #334979970

Tricks: 从大到小枚举 $k$，结果的 $x$ 必定是从小到大的，省一步排序。

2132C1. The Cunning Seller (easy version)

题意

西瓜卖家在他的每次交易中只能卖掉 $3^x$ 个西瓜，价格为 $3^{x + 1} + x \cdot 3^{x - 1}$，其中 $x$ 为非负整数。

买家希望通过最少的交易次数买到 $n$ 个西瓜（不能多也不能少），输出在此情况下西瓜的总价。

题解

容易发现，卖掉 $3^x$ 个西瓜，相当于在三进制下使 $n$ 的从右至左第 $x + 1$ 位减少 $1$。

那么，为了获得最小的次数，对于三进制下从右至左第 $x + 1$ 位，它的值为 $y$ 时，我们需要进行 $y$ 次卖掉 $3^x$ 个西瓜的操作。

代入原式，加和即可。

预处理 $3^x$ 的值即可，没必要推价格的递推公式。

参考代码

Submission #335129815

2132C2. The Cunning Seller (hard version)

题意

西瓜卖家在他的每次交易中只能卖掉 $3^x$ 个西瓜，价格为 $3^{x + 1} + x \cdot 3^{x - 1}$，其中 $x$ 为非负整数。

买家希望通过不多于 $k$ 次交易，以最小的价格购买 $n$ 个西瓜，输出此时的总价，若不能满足题目要求则输出 $-1$。

题解

首先把 C1 的代码抄过来，并记录交易次数、每次交易的（西瓜数的）指数。

发现 $3 \times 3^{x-1}$ 的交易总是比 $3^x$ 的交易要便宜。设当西瓜数为 $x$ 时的西瓜价格为 $f(x)$，列式计算替换 $3^x$ 的交易为 $3 \times 3^{x-1}$ 的交易所降低的总价：

$$f(3^x) - 3 \cdot f(3^{x-1}) = 3^{x + 1} + x \cdot 3^{x - 1} - 3 \cdot 3^x - 3 \cdot (x - 1) \cdot 3^{x - 2}$$

合并同底数幂：

$$= 3^{x + 1} + x \cdot 3^{x - 1} - 3^{x + 1} - (x - 1) \cdot 3^{x - 1}$$

合并同类项：

$$= 3^{x - 1}$$

所以当有至少 $2$ 个剩余的交易次数时，应将指数最大的交易替换掉，因为这样可以降低最多的总价。注意，当剩余的交易的指数都为 $0$ 时，就不能替换了。

这样做复杂度还是太高了，怎么优化？可以考虑只记录每个指数的出现次数，然后直接批量替换交易。

参考代码

易错点：

替换次数不能是负数

多组数据不要忘记 memset

Submission #335139556

2132D. From 1 to Infinity

题意

12345678910111213... 的前 $k$ 个数字之和是多少？

$k \leq 10^{15}$。

题解

Codeforces 官方题解没读懂，于是花了一晚上自己钻研出了一个方法。

观察发现，一位数在数字串中占据 $1 \times 9$ 个位置，二位数占据 $2 \times 90$ 个位置，以此类推。总结可得 $l$ 位数在数字串中占据 $9l \times 10^{l - 1}$ 个位置。

那么，我们通过循环地从 $k$ 中减去 $9l \times 10^{l - 1}$ 直到 $k$ 小于 $9l \times 10^{l - 1}$ ，就可以得到 $k$ 所对应的数 $n$ 的位数。

接着，我们使用 $k \div l$ 来获得 $n$ 在 $l$ 位数中是第几个，再加上 $10^{l - 1}$，即为 $n$ 的值。

我们已经知道了第 $k$ 位数字所对应的数 $n$，那么 $1$ 到 $n-1$ 的数字之和可以通过以下方式来求出：

把求和区间中加入一个 $0$，变为求 $[0, n-1]$ 的数字之和，这一步不影响最终结果。
我们可以给所有数字加上前导零，使其与 $n-1$ 一样长（设长度为 $l$），这一步不影响最终结果。
拆分求和区间：（该步骤递归进行，$x$ 代表当前求和区间右端点）
- $x$ 的第一位为 $d_1$，第一位小于 $d_1$ 的构成一组（该部分可以直接求数字和，具体方法见用数学期望计算区间内整数各数位的和的和）；
- 第一位等于 $d_1$ 的分成两部分：
  - 第一部分为第一位等于 $d_1$ 的数，其中每个数的第一位被直接删除（该部分进入递归循环）；
  - 第二部分为 $d_1$ 乘上第一部分包括的数的个数。
当 $x$ 为 $k \cdot 10^{m} - 1$ 的形式或一位数时，直接求和，结束递归。

以 $n = 345$ 为例：

求 $[0, 345]$ 的数字和：
- 求 $[0, 299]$ 的数字和：
  - 共有 $300$ 个数，可得后两位数字和为 $4.5 \times 300 \times 2 = 2700$；
  - 首位在 $[0, 2]$，期望为 $1$，所以首位数字和为 $1 \times 300 = 300$；
  - 因此 $[0, 299]$ 的数字和为 $2700 + 300 = 3000$。
- 求 $[0, 45]$ 的数字和：
  - 求 $[0, 39]$ 的数字和，为 $240$。
  - 求 $[0, 5]$ 的数字和，为 $15$。
  - $4 \times 6 = 24$。
  - 所以 $[0, 45]$ 的数字和为 $240 + 15 + 24 = 279$。
- $3 \times 46 = 138$。

所以 $[0, 345]$ 的数字和为 $3000 + 279 + 138 = 3417$。

参考代码

Submission #335238142

2132E. Arithmetics Competition

题意

有两个数组 $a$ 和 $b$，$a$ 的长度为 $n$，$b$ 的长度为 $m$。

给出 $q$ 次询问，每次询问包括三个数 $x, y, z$，表示在 $a$ 中至多选择 $x$ 个数，在 $b$ 中至多选择 $y$ 个数，总共选择 $z$ 个数，求选择的数字之和的最大值。

题解

首先，考虑暴力解法。排序两个数组，每次询问的每次选择都选择可以选择的最大数字。

显然，这样是无法通过问题的。那么，如何优化呢？

我们最终在同一个数组里选择的数一定是在一个连续区间内，如果我们能计算出这个区间，那么就可以通过 $O(n)$ 前缀和预处理解决问题。

设选择 $p$ 个 $a$ 中的数，总共选择 $z$ 个数（可以计算出选择 $b$ 中的元素数 $q$）时选择的数字之和的最大值为 $f(p, z)$，该值可以在 $O(1)$ 时间内计算出来。

发现当 $z$ 不变时 $f$ 是一个单峰函数，于是采用三分搜索求解。

参考代码

Submission #335250108

用数学期望计算区间内整数各数位的和的和

Sun, 24 Aug 2025 13:07:00 +0800

问题

$[0, n)$ 中的数的数位和的和是多少？

保证：$n = p \times 10^q$，$p, q$ 为正整数。即 $n$ 是 $x999\dots$ 的形式。

例如：$[0, 20)$ 中数的数位和的和是 $0 + 1 + 2 + 3 + \dots + 9 + (1 + 0) + (1 + 1) + (1 + 2) + \dots + (1 + 9) = 100$。

用数学期望算

将 $n$ 这个数的首位和其他位分开，记 $n$ 的位数为 $l$。

假设所有在原区间内地数都是 $l$ 位的，若不足 $l$ 位的数，在前面补 $0$。这一操作并不影响结果。

先讨论除首位外的其他位，观察上图我们发现，这些位的值在 $0$ 到 $9$ 之间均匀地分布，所以可以计算每一位的数学期望为 $4.5$。又因为统计数位和的区间包括了 $n$ 个数，总共存在 $n \times (l - 1)$ 个数位，所以这一部分的数位和为 $4.5 \times n \times (l - 1)$。

再讨论首位，设首位值为 $d_1$，相似地，可以证明第一位的值在 $0$ 到 $d_1$ 之间均匀分布，所以首位数学期望为 $\frac{d_1}{2}$。因此首位数位和为 $\frac{d_1}{2} \times n$。

上面两式相加即为 $[0, n)$ 中数的数位和的和。

CF-2131 (Codeforces Round 1042, Div. 3) 题解

Wed, 13 Aug 2025 16:34:00 +0800

2131A. Lever

题意

有数组 $a, b$，长度为 $n$。现在循环进行操作，每次操作包含两步：

选择一个 $1 \leq i \leq n$ 且 $a_i > b_i$，然后使 $a_i$ 减少 $1$；若没有这样的 $i$，则忽略这一步。
选择一个 $1 \leq i \leq n$ 且 $a_i < b_i$，然后使 $a_i$ 增加 $1$；若没有这样的 $i$，则忽略这一步。

若在某次操作中，步骤 $1$ 被忽略了，则终止循环。

请问循环将会执行多少次？题目保证在任意一步中，对于所有可供选择的 $i$，不论选择哪个 $i$ 都不影响最终答案。

题解

目力惊人的我们发现，步骤 $2$ 不会影响步骤 $1$。

证明：对于某次操作中没有被忽略的步骤 $2$，选择的下标为 $i$，由于 $a_i < b_i$，可得 $a’_i \leq b_i$。因此，操作后的 $i$ 不可能被步骤 $1$ 选择，即步骤 $2$ 不影响步骤 $1$。

对于每个 $i$，操作 $1$ 至多可以执行 $\max(a_i - b_i, 0)$ 次。

遍历每个 $i$，累加操作 $1$ 的次数，最后加上 $1$（被忽略的那一次）即为答案。

参考代码

Submission #333289337

2131B. Alternating Series

题意

定义长度为 $n$ 的数组 $a$ 是好的当且仅当：

对于每个 $1 \leq i \le n$，$a_i \times a_{i + 1} \le 0$；
所有长度为 $2$ 以上的子数组的元素之和都为正。

定义好的数组 $a$ 比另一个好的数组 $b$ 更好当且仅当 $[|a_1|, |a_2|, \ldots, |a_n|]$ 比 $[|b_1|, |b_2|, \ldots, |b_n|]$ 的字典序更小。

输出一个长度为 $n$ 的好的数组，使其比所有长度为 $n$ 的好的数组更好。

题解

这题完全可以找规律做

注意到好的数组满足：

符号交替出现；
所有长度为 $2$ 以上的子数组的元素之和都为正。

证明：

考虑子数组 $[a_{i - 1}, a_i, a_{i + 1}]$，其中 $2 \leq i \leq n - 1$。根据符号交替性：

$$a_{i - 1} + a_i + a_{i + 1} \leq -1 + a_i - 1 = a_i - 2$$

而根据题目要求 $a_{i - 1} + a_i + a_{i + 1} \geq 1$ 可得：

$$a_i \geq 3$$

对于边界情况 $i = n$，同理易得 $a_i \geq 2$。

综上可得数组构造方法：

对于奇数下标，取 $a_i = -1$
对于偶数下标
- 当 $2 \leq i \leq n - 1$ 时，有 $a_i \geq 3$，为了绝对值字典序最小，取 $3$。
- 当 $i = n$ 时，有 $a_i \geq 2$，同理取 $2$。

正确性证明：

符号交替性显然满足
对于任意长度 $k \geq 2$ 的子数组 $s$：
- 当 $k = 2$ 时：由一个 $2$ 或 $3$ 与一个 $-1$ 组成，$\sum s \geq 2 - 1 = 1$；
- 当 $k = 3$ 时：
  - $[3, -1, (2 or 3)]$，$\sum s \geq 3 - 1 + 2 = 4$，
  - $[-1, 3, -1]$，$\sum s \geq -1 + 3 - 1 = 1$；
- 当 $k \geq 4$ 时：可以看作多个子数组的和，为正。

参考代码

Submission #333498392

2131C. Make it Equal

题意

给定两个可重集合 $S$ 和 $T$，可以对 $S$ 中任意一个元素 $x$ 进行操作：将 $S$ 中的一个 $x$ 替换为 $x + k$ 或 $|x - k|$。

请问是否可以将 $S$ 变化为 $T$？

题解

容易证明：我们只能将元素 $x$ 替换为 $y$ 当且仅当 $x \equiv y (\bmod k)$ 或 $x \equiv -y (\bmod k)$。

实现：存储 $S_i \bmod k$ 与 $-S_i \bmod k$ 中较小的一个，比较两集合经过这样处理后的新集合是否相同即可。

参考代码

Submission #333526673

2131D. Arboris Contractio

题意

有一棵拥有 $n$ 个节点的树，你希望尽可能地缩小它的直径。为了缩小直径，你可以对这棵树进行若干次操作：

选择两个树上的节点 $s$ 和 $t$；
删除这两个节点简单路径上的所有边；
连接 $s$ 和简单路径上的除 $s$ 外的所有节点。

容易证明每次操作后，这张图还是树。

请问：最少进行多少次操作，使得树的直径最小化？

题解

容易发现：

分类讨论
- 对于 $n \leq 3$ 的树，不需要操作
  - $n = 1$，直径为 $0$，是最小值
  - $n = 2$，直径为 $1$，是最小值
  - $n = 3$，直径为 $2$，是最小值
- 对于 $n > 3$ 的树，树的直径最小值为 $2$
  - 直径为 $1$ 意味着树中最长简单路径上只有 $2$ 个节点，在 $n > 3$ 条件下，不可能存在
操作的作用在于使某条简单路径上的所有点与简单路径某一端点直接相连

稍加推导即可得到关键结论：

我们应该选择一个固定的节点作为根节点，然后使其作为 $s$ 参与每次操作。
树的直径是 $2$ 的充要条件是叶节点的深度全为 $1$。

证明关键结论2：

必要性（如果树的直径是 $2$，那么所有叶节点的深度必须是 $1$）
1. 假设树的直径是 $2$，这意味着树中最长的简单路径包含 $3$ 个节点（路径长度为 $2$）。
2. 如果存在一个叶节点 $u$，其深度大于 $1$，那么它至少通过一个中间节点连接到根节点。
3. 由于树的结构，这个叶节点 $u$ 到根节点的距离大于 $1$，即路径长度至少为 $2$。
4. 同时，因为 $u$ 是叶节点，它没有其他子节点，所以从 $u$ 出发的最长路径只能回到它的父节点，再延伸到根节点。
5. 由于 $n > 3$，所以这条路径可以延伸到其它连接到根的节点。
6. 这样会导致存在一条路径长度大于 $2$，与“直径为 $2$”矛盾。
7. 因此，若树的直径为 $2$，所有叶节点必须直接连接到根节点，即深度为 $1$。
充分性（如果所有叶节点的深度都是 $1$，那么树的直径是 $2$）
1. 假设所有叶节点的深度都是 $1$，即它们都直接与根节点相连。
2. 那么树的结构是以根为中心的星形结构，所有叶节点都连接在根上。
3. 在这种结构中，任意两个节点之间的最长路径是从一个叶节点到根再到另一个叶节点，路径长度为 $2$。
4. 因此，树的直径为 $2$。

因此，我们每次选择一个深度非 $1$ 的叶节点进行操作即可。容易证明，这样的操作只会使一个叶节点的深度从非 $1$ 变为 $1$。

那么，如何选择最佳的根节点呢？

由于无论选择怎样的 $root$，我们都是对所有深度非 $1$ 的叶节点逐个做一次操作，因此，我们只需统计所有深度非 $1$ 的叶节点的个数（记作 $ans$）即可。

显而易见地，我们有：（$cnt_0$ 表示叶节点总个数，$cnt_{root}$ 表示直接连接 $root$ 的叶节点个数）

$$ ans = cnt_0 - cnt_{root} $$

$cnt_0$ 可以通过数节点的度数来 $O(n)$ 地计算；
$cnt_{root}$ 通过 $root$ 连接的每个点的度数来计算，由于树的边数性质，复杂度为 $O(n)$。

参考代码

Submission #333756238

2131E. Adjacent XOR

题意

有一个长度为 $n$ 的数组 $a$。你可以对每个 $1 \leq i < n$ 做至多一次操作：

将 $a_i$ 改为 $a_i \oplus a_{i + 1}$。

其中，$\oplus$ 表示异或运算。

请问能否将 $a$ 变为 $b$？

题解

若 $a_n \neq b_n$，则完全不可能。

考虑 $a_i$ 与 $a_{i + 1}$，在以下情况下是可以使 $a_i$ 变为 $b_i$ 的：

$a_i = b_i$，不用操作。
$a_i \oplus a_{i + 1} = b_i$，先操作 $a_i$，再决定要不要操作 $a_{i + 1}$。
$a_i \oplus b_{i + 1} = b_i$，先决定要不要操作 $a_{i + 1}$，再操作 $a_i$。

容易发现，如果将每个 $a_i$ 与 $a_{i + 1}$ 的操作顺序连边，构成的图必定是有向无环的，或者说我们构建了一个AOV网。

例如以下样例：

n = 8
a = [3, 3, 5, 5, 0, 3, 3, 6]
b = [5, 6, 3, 6, 3, 0, 5, 6]
EXPECTED = YES

构建出的图是这样的：

因此，构成的图是可以拓扑排序的，即必定存在一种方案可以完成全部需要完成的操作。

结论：只要对于所有 $1 \leq i < n$，都有以下三个条件之一为真：

$a_i = b_i$
$a_i \oplus a_{i + 1} = b_i$
$a_i \oplus b_{i + 1} = b_i$

那么就可以将 $a$ 转变为 $b$。

参考代码

Submission #333464914

CF-2128 (Codeforces Round 1039, Div. 2) 题解

Sat, 09 Aug 2025 21:32:00 +0800

很神奇啊，AB两道题都不知道怎么过的

2128A. Recycling Center

题意重述

有 $n$ 个垃圾袋，每个垃圾袋的重量为 $a_i$。

每次行动你可以选择一个垃圾袋，将它摧毁（应该是回收掉吧？）。若其重量大于 $c$，你需要消耗 $1$ 金币；反之这个垃圾袋可以免费摧毁。同时，其他的垃圾袋重量翻倍。

输出：摧毁掉所有垃圾袋所消耗的最小金币数。

解法

思路

考虑垃圾袋中有且仅有一个可以免费摧毁的情况，那么显然应该优先摧毁这个免费的。

回到问题，有多个可以免费摧毁的话，应该优先摧毁这些垃圾袋中的哪个？应该优先摧毁最重的免费摧毁垃圾袋，因为它将会最快地变成付费垃圾袋。

这样的话，就可以通过排序解决问题。

参考代码

Submission #331279467

2128B. Deque Process

题意重述

当且仅当一个长度为 $n$ 的数组 $a$ 中存在连续的 $5$ 个数是递减或递增的时，我们定义这个数组是坏的，反之它是好的。

有一个排列 $p_1, p_2,… , p_n$，你要从这个排列的左侧或右侧移除元素，直至所有元素都被移除。

给出移除元素的方式使得移出的元素组成的数组是好的。如果有多种移除方法，输出任意一种。题目保证一定存在答案。

解法

思路

只需保证可以打断目前形成的递减或递增趋势即可。不妨假设移出元素构成的数组 $q$ 满足 $q_1 < q_2 > q_3 < q_4 > q_5 …$。

证明：在奇数轮取左右两个中较小的，则必定可以在偶数轮取到比上轮大的数，此时在偶数轮取较大的，则必定可以在奇数轮取到比上轮小的数……直到取完所有元素。

参考代码

Submission #333145898

2128C. Leftmost Below

题意重述

有一个长度为 $n$ 的数组 $a$，初始值为 $0$。

你可以做若干次操作，每次操作你可以选择一个大于 $min(a)$ 的数 $x$，它将加到数组中从左到右第一个小于 $x$ 的数。

请问是否可以让 $a$ 变为数组 $b$？

解法

思路

对于每个 $2 \leq i \leq n$，令 $m_i = \min(b_1, \ldots, b_{i-1})$。可以证明：当且仅当对于所有 $2 \leq i \leq n$ 满足 $b_i - m_i < m_i$ 时，可以达成 $a = b$。

充分性证明：可以从左至右构建数组 $a$。对于每个 $i$，若 $b_i < m_i$，则直接添加 $b_i$；否则，先添加 $b_i - m_i$，再添加 $m_i$。

必要性证明：假设构造 $a = b$。在每一步中，均有 $a_i \leq b_i$。考虑最后一次对 $a_i$ 进行操作的值 $x$。根据 $i$ 的定义，必有 $$a_i < x \leq \min(a_1, \ldots, a_{i - 1}) \leq \min(b_1, \ldots, b_{i-1})$$ 因此，$b_i = a_i + x \leq 2x - 1 \leq 2m_i - 1$。

参考代码

Submission #333148494

CF-2122 (Codeforces Round 1038, Div. 1 + 2) 题解

Mon, 21 Jul 2025 15:31:00 +0800

2122A. Greedy Grid

题意

定义 Greedy Path 为：从左上角出发，每次向右或下的相邻一格移动，且移动的格子的值不小于另一个选择。

路径的值为：经过的所有格子权值之和。

问题：存不存在 $n \times m$ 的由非负整数组成的网格，满足没有 Greedy Path 的值达到“所有向(右/下)走的路径的值的最大值”？

解法

思路

Greedy Path 会向大的方向走，因此考虑一种设计网格的方案：把 Greedy Path “引诱” 到一条起始格非常大、后面都很小的路径上；再构造一条起始小、后面非常大的路径，使这条路径值大于 Greedy Path 即可。

图为 $3 \times 3$ 的例子：

什么时候无法构造出这样的网格呢？

只有一条路径，即 $n = 1$ 或 $m = 1$；
两条路径不重合的部分只有一个点，即 $n = m = 2$。（假设构造的是 $a_{1, 2} > a_{2, 1}$，由于 $a_{1, 1} + a_{1, 2} + a_{2, 2} > a_{1, 1} + a_{2, 1} + a_{2, 2}$，两种路径会重合）

结论

$n = 1$ 或 $m = 1$ 时，只有一条路径，因此输出 No；

$n = m = 2$ 时，只有两条路径，因为 Greedy Path 会走向值较大的格，最大值的路线也是这样，所以 Greedy Path 的路线和最大值路线一定是一样的，也输出 No。

容易证明，其他情况下都存在满足题意的网格，输出 Yes。

参考代码

#include <iostream>

using namespace std;

int main() {
	int t;
	cin >> t;
	while (t -- ) {
		int n, m;
		cin >> n >> m;
		if (n == 1 || m == 1 || (n == 2 && m == 2)) puts("No");
		else puts("Yes");
	}
	return 0;
}

2122B. Pile Shuffling

题意

你有 $n$ 摞数字，每摞由 $a_i$ 个 0 和 $b_i$ 个 1 组成，其中 0 在上面，1 在下面。

每次操作你只能将任意一摞数字的最上方的一个数移动到任意一摞的任意位置。

最终要求每一摞数字由上面的 $c_i$ 个 0 和下面的 $d_i$ 个 1 组成，输出最小操作次数。

解法

思路

只考虑挪出数字的情况。

若 $b_i > d_i$，我们需要将所有上面的 0 挪开（到本摞要挪走的最靠下一个 1 的下面或到其他堆），操作次数是 $\min(a_i, c_i) + b_i - d_i$（因为可以先挪 1，也可以后挪 1）。
若 $a_i > c_i$，我们需要将 $a_i - c_i$ 个 0 挪走，操作次数是 $a_i - c_i$。

结论

对于每堆数字：

若 $a_i > c_i$，$ans += a_i - c_i$。
若 $b_i > d_i$，$ans += a_i + b_i - d_i$。

参考代码

赛时没关同步过了，刚刚交的不关同步过不了？

#include <iostream>

using namespace std;

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);

	int t;
	cin >> t;
	while (t -- ) {
		int n;
		cin >> n;

		long long ans = 0;
		while (n -- ) {
			int a, b, c, d;
			cin >> a >> b >> c >> d;
			if (a > c) ans += a - c;
			if (b > d) ans += min(a, c) + b - d;
		}
		cout << ans << endl;
	}
	return 0;
}

2122C. Manhattan Pairs

题意

将 $n$ 个点分成 $\frac{n}{2}$ 对，使得每对点之间的曼哈顿距离之和最大。输出任意一种配对方案。

保证 $\sum{n} \leq 2 \times 10^5$，$n$ 是偶数。

解法

思路

考虑一维情况，最优方案是将最小的 $\frac{n}{2}$ 个点与最大的 $\frac{n}{2}$ 个点配对。

那么开始考虑二维情况，最优方案显然是：

$x$ 坐标最小的 $\frac{n}{2}$ 个点（定义为 $X_l$）与最大的 $\frac{n}{2}$ 个点（定义为 $X_r$）配对；
$y$ 坐标最小的 $\frac{n}{2}$ 个点（定义为 $Y_l$）与最大的 $\frac{n}{2}$ 个点（定义为 $Y_r$）配对。

所以我们将所有点分成 $4$ 部分处理：

$X_l \cap Y_l$ 与 $X_r \cap Y_r$ 配对；
$X_l \cap Y_r$ 与 $Y_r \cap Y_l$ 配对。

设：

$|X_l \cap Y_l| = a$
$|X_r \cap Y_r| = b$
$|X_l \cap Y_r| = c$
$|Y_r \cap Y_l| = d$

那么有：

$a + c = b + d$，因为 $|X_l| = |X_r|$；
$a + d = b + c$，因为 $|Y_l| = |Y_r|$。

两式相加、移项、系数化为1 后可得：$a = b$ 和 $c = d$，所以刚刚提到的配对方法不会出现剩下的点。

结论

$X_l \cap Y_l$ 与 $X_r \cap Y_r$ 配对；
$X_l \cap Y_r$ 与 $X_r \cap Y_l$ 配对。

参考代码

参考了 Tourist 的解法，通过三次排序分出了四组。

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 2e5 + 10;

int x[N], y[N], idx[N];

int main() {
	int t;
	cin >> t;
	while (t -- ) {
		int n;
		cin >> n;
		for (int i = 0; i < n; i ++ ) {
			cin >> x[i] >> y[i];
			idx[i] = i;
		}
		sort(idx, idx + n, [&](int i, int j) {return x[i] < x[j];});
		sort(idx, idx + n / 2, [&](int i, int j) {return y[i] < y[j];});
		sort(idx + n / 2, idx + n, [&](int i, int j) {return y[i] < y[j];});
		// Xl&Yl, Xl&Yr, Xr&Yl, Xr&Yr
		for (int i = 0; i < n / 2; i ++ ) {
			cout << idx[i] + 1 << ' ' << idx[n - 1 - i] + 1 << endl;
		}
	}
	return 0;
}

树状数组及典型例题

Sun, 13 Jul 2025 11:40:00 +0800

BIT 中 Binary 是形容 Index 的，不是形容 Tree 的。

树状数组

树状数组是一种支持单点修改和区间查询的代码量较小的数据结构。树状数组能解决的问题是线段树能解决的问题的子集，也就是说树状数组能解决的问题线段树一定能解决，线段树能解决的问题树状数组不一定能解决。

常规情况下用树状数组的前提条件：存储的信息和运算方法要支持结合律和可差分。

可差分：有逆运算。

当然，例如 $\max$ 等不可差分运算，树状数组只能支持前缀查询。

引入

举个例子，我们想知道 $a[1] + a[2] + \cdots + a[7]$ 的前缀和。

普通的做法是：直接将 $7$ 个数求和。

树状数组的做法是：将一段前缀 $[1, n]$ 分割成不超过 $\log n$ 段区间，并通过一些预处理使得每段区间的和都可以 $O(1)$ 地求出。于是，我们就成功地缩减了问题规模。

管辖区间

下图展示了树状数组的工作原理：

不难发现，$c[i]$ 管辖 $[i - lowbit(i) + 1, i]$ 这段区间。

lowbit(x) 是指 x 在二进制下最低的 1 及其后面的 0，根据二进制反码相关知识可以推导出较为简单的计算方法：lowbit(x) = x & -x。

前缀（区间）查询

为了不重不漏的拆分前缀区间，每次向前“跳”的时候一定是要“跳”到当前区间的左端点的左一位作为新区间的右端点，根据刚刚提到的管辖区间可得新右端点应为 $i - lowbit(i)$。

int query(int x) {
    int res = 0;
    for (int i = x; i >= 1; i -= lowbit(i)) res += c[i]; // 此处运算方法根据题意替换；看个人习惯，for循环可写作while循环
    return res;
}

注意第 3 行不要写成 i -= lowbit(x)

根据前缀和的原理，只要运算方法是可差分的，可以前缀查询就是可以区间查询。

单点修改

在进行单点修改时，只需遍历所有管辖 $a[i]$ 的 $c[x]$。由于 $c[i]$ 被 $c[i + lowbit(i)]$ 直接管辖，我们就可以直接通过这种方式来遍历所有需要修改的 $c[x]$。

1
2
3

void update(int x, int val) {
    for (int i = x; i <= n; i += lowbit(i)) c[i] += val; // 根据题意替换；可写作while循环
}

建树

最简单的方法是直接替换成 $n$ 次单点修改，复杂度 $O(n \log n)$。

也可以 $\Theta (n)$ 建树，方法很多，这里介绍一种：

既然 $c[i]$ 表示的区间是 $[i - lowbit(i) + 1, i]$，我们就可以 $\Theta (n)$ 建立一个前缀和数组，再通过前缀和求区间和的方法写入 $c$ 数组。

复杂度分析

时间复杂度：

建树：$\Theta (n)$ 或 $O(n \log n)$
修改：$O(\log n)$
查询：$O(\log n)$

空间复杂度：$O(n)$

参考代码

P3374 【模板】树状数组 1

#include <iostream>

using namespace std;

typedef long long LL;

const int N = 5e5 + 10;

LL a[N], c[N];
int n, m;

inline int lowbit(int x) { return x & -x; }

void update(int x, LL val) {
    while (x <= n) {
        c[x] += val;
        x += lowbit(x);
    }
}

LL query(int x) {
    LL res = 0;
    while (x > 0) {
        res += c[x];
        x -= lowbit(x);
    }
    return res;
}

int main() {
    cin >> n >> m;
	for (int i = 1; i <= n; i ++ ) cin >> a[i], update(i, a[i]);

    while (m -- ) {
        int op;
        cin >> op;
        if (op == 1) {
            int x; LL k;
            cin >> x >> k;
            update(x, k);
        } else if (op == 2) {
            int x, y;
            cin >> x >> y;
            cout << query(y) - query(x - 1) << endl;
        }
    }
    return 0;
}

Luogu P3368. 树状数组 2

P3368 【模板】树状数组 2

题意

区间修改，单点查询。

分析

我们可以通过差分算法将区间修改转化为单点修改，同时单点查询变为区间查询，树状数组秒了。

参考代码

#include <iostream>

using namespace std;

typedef long long LL;

const int N = 5e5 + 10;

LL a[N], s[N];
LL c[N];
int n, m;

inline int lowbit(int x) { return x & -x; }

void update(int x, LL val) {
    while (x <= n) {
        c[x] += val;
        x += lowbit(x);
    }
}

LL query(int x) {
    LL res = 0;
    while (x > 0) {
        res += c[x];
        x -= lowbit(x);
    }
    return res;
}

int main() {
    cin >> n >> m;
	
	for (int i = 1; i <= n; i ++ ) cin >> a[i];
	for (int i = 1; i <= n; i ++ ) s[i] = a[i] - a[i - 1];
    for (int i = 1; i <= n; i ++ ) {
        update(i, s[i]);
    }

    while (m -- ) {
        int op;
        cin >> op;
        if (op == 1) {
            LL x, y, k;
            cin >> x >> y >> k;
            update(x, k);
            update(y + 1, -k);
        } else if (op == 2) {
            int x;
            cin >> x;
            cout << query(x) << endl;
        }
    }
    return 0;
}

CSP 2024 游记

Sat, 28 Sep 2024 11:30:00 +0800

Day -1

考场，又一次是八十中。

备赛，氢氰菘悚。

Day 0

8:30

起床，出发前往考场。

9:00

进入考场，完全不紧张。上午考 J 组。

我发现 CSP 的女考生占比逐年增加，去年我记得好像是 $2/31$，今年就变成 $4/34$

9:30

发卷，$12$ 页，大致看了一下，也就最后一道补全程序稍微有点难度，考的汉诺塔。

10:27

做完了，汉诺塔那题花了12分钟验证我的答案。话说这次CCF怎么这么大方，整了个大张的答题卡。

11:30

离开考场，自我感觉能考个 $100$ 分。

13:00

今年小图灵真快，一个半小时就出估分了，估分 $97.5$。有一道格雷码不会，扣了 $2$ 分，另外那个 $0.5$ 好像是一道有争议的题。

14:30

下午继续考 S 组。发卷，$16$ 页，压力有点大。

16:23

卡点写完了卷子，赶紧把答题卡涂了。感觉自己发挥一般般，可能比去年好一丢丢，估计难度差不多。

18:00

估分，$70.5$。

Day 6

成绩出了，J 组 $98$，S 组 $72.5$。

GESP7级做题经验及题解

Mon, 26 Aug 2024 22:03:00 +0800

更新记录

[2024-08-26 22:03] 完成了 <商品交易> 和 <纸牌游戏> 的题解与感受。
[2024-08-27 15:08] 完成了 <交流问题> 的题解与感受，并提供了所有题目的正确代码。
[2024-08-27 21:58] 完成了 <俄罗斯方块> 的题解与感受，补充了 <纸牌游戏> 的感受。
[2024-08-28 16:34] 完成了 <黑白翻转> 和 <区间乘积> 的题解与感受，完结撒花。
[2024-08-28 16:53] 补充了 <总结> 部分。

正确代码

洛谷 - 云剪贴板，Github - Gist

商品交易 202312 A

洛谷题库 P10110

题解

本质上是求一个边权为 $1$ 的最短路。每进行一次交换，总资产就会少 $1$ 元。

根据题意，用手上的第 $x$ 种商品交换第 $y$ 种商品，花费 $v_y - v_x + 1$ 元，总资产变化为 $-v_x + v_y - (v_y - v_x + 1) = -1$。（$-v_x$ 是第 $x$ 件商品没了，$+v_y$ 同理）

最后加上期望获得的商品的价格 $v_b$ 与原本持有的商品的价格 $v_a$ 的差即可。

感受

非常巧妙的一道最短路问题，算是一个简化版的 SPFA（由于边权为 $1$，所以不需要 st 数组防止重复入队）。

放段代码比较一下：

SPFA 模板

int spfa() {
    memset(dist, 0x3f, sizeof dist);
    queue<int> q;
    dist[1] = 0; st[1] = true; q.push(1);
    while (!q.empty()) {
        int t = q.front(); q.pop();
        st[t] = false;
        for (int i = h[t]; i != -1; i = ne[i]) {
            int j = e[i];
            if (dist[j] > dist[t] + w[i]) {
                dist[j] = dist[t] + w[i];
                if (!st[j]) {
                    q.push(j); st[j] = true;
                }
            }
        }
    }
    if (dist[n] == INF) return INF;
    return dist[n];
}

本题正解

int main() {
    /*
        ...
        v 数组有必要存的只有 v[a], v[b]
        所以用 va, vb 两个 int 替代
    */
    queue<int> q;
    q.push(a);
    st[a] = 1;
    dist[a] = 0;
    while (!q.empty()) {
        int t = q.front(); q.pop();
        if (t == b) {
            break;
        }
        for (int i = h[t]; ~i; i = ne[i]) {
            int j = e[i];
            if (dist[j] > dist[t] + 1) {
                dist[j] = dist[t] + 1;
                q.push(j);
            }
        }
    }
    if (dist[b] != INF) {
        cout << vb - va + dist[b] << endl;
    } else {
        cout << "No solution";
    }
    return 0;
}

数据量有点迷惑性，$10^5$ 对应的时间复杂度 $O(n\log n)$ 让人联想到 Dijkstra 等算法，然后发现实际上是一个 $O(n)$ 的 BFS。

此题难度不高，出题组第一次出七级的题可能把握不住题目难度，不作七级题目难度参考。

纸牌游戏 202312 B

洛谷题库 P10111

题解

经典最值问题，有非常浓厚的状态转移风味，并且无后效性，考虑 DP。

状态表示 f[i][j][k] 表示在第 $i$ 轮出了牌 $j$、累计换牌（额外扣分） $k$ 次时可以获得的最高分数。
状态计算 f[i][j][k] = max(f[i - 1][t][k + ((j == t) ? 0 : -1)])，其中 $t \in \lbrace 0, 1, 2 \rbrace$。

最后取所有 $j \in \lbrace 0, 1, 2 \rbrace , 0 \leq k \le n$ 的 f[n][j][k] - b[k] 的最大值（b[k] 为额外扣分数组的前缀和）。

注：可以把 f 数组的第一维压掉，但不差这点空间。

感受

做代码优化时，别的不用考虑，只要保证做的是等价变形。——yxc

DP 的状态表示基本靠硬想，唯一的技巧就是题里有啥就写啥，想到什么表示方法就试试，不行的话就尝试增加或减少一个维度之类的。

偶尔做题时会发现一些有意思的小事情，比如每轮得分可以表示为 ((c[i] == j) ? a[i] : (2 * ((c[i] + 3 - j) % 3 - 1) * a[i]))（c[i] 为对手出牌，j 为我方出牌，a[i] 为本局分数）~~，然后你就会发现这玩意完全没用~~。

如果状态转移想的不太清楚的话，会产生大量复制粘贴，最终码量在 2KB 左右，找规律可以减少一些复制粘贴，可以降到 1KB 码量。

本题难度中等，状态表示很难，算是一道优秀的 DP 题。

交流问题 202403 A

洛谷题库 P10378

题解

A 校和 B 校很明显是一个二分图的两部分。每个连通块都有两种分学校的方案，可以通过染色法分出学校，左右两半分别是 A B 校或 B A 校，两种方案产生了两组“该连通块中 A 校人数和 B 校人数”，记录两组中较小的 B 校人数（其实 B 校还是 A 校没区别，所以也可以只求一组，取两校人数的最小值）。仅需计算该二分图所有的连通块的“较小的 B 校人数”之和，该数是 B 校总人数的最小值，用 $n$ 减去该数就是 B 校总人数的最大值（即 A B 校学生数互换）。

感受

二分图明显就明显在所有边（交流）都在两学校之间，学校内不连边。每个连通块内的集合（学校）划分就是给每个点（学生）打标签，与染色法十分相似。

很水，感觉思考深度和前两题完全不是一个级别（话好像说反了）。

俄罗斯方块 202403 B

洛谷题库 P10379

题解

用类似于 floodfill 的算法解决，固定从每个俄罗斯方块左上角开始搜索，这样就可以使每个方块拥有一个固定的有根搜索树，相同形状的俄罗斯方块搜索树也相同，把遍历顺序（层序遍历，树上 DFS 等）当作这个类型的俄罗斯方块独一无二的标识。

用 set 的去重功能统计有多少种遍历顺序，即有多少种俄罗斯方块。

感受

floodfill 的特征还算明显，难就难在如何表示每个俄罗斯方块。这么做我是完全没想到的，看别人的题解看到的。遍历顺序是一个搜索的过程中就产生的东西，不增加复杂度，可能是一个比较容易发现的算法，但是我没发现。

巧妙的搜索题，难度的话，中等？

黑白翻转 202406 A

洛谷题库 P10723

题解

我们发现，只有连接两个及以上黑色节点的白色节点才需要染黑。白色叶节点并不能连接黑色节点，没有必要染成白色，所以循环删除所有白色叶节点。最后统计剩下的白色节点数并输出，因为最后剩下的白色节点都是需要染成黑色的。

注：无根树的叶节点的定义是度数不大于 $1$ 的点。

感受

难度中等。

思路就是连接黑色节点，其余白色全部删除。容易走到歪路上，像是 DFS 之类（有可能路没歪但是我想不明白）。

区间乘积 202406 B

洛谷题库 P10724

题解

容易发现：一个数是完全平方数时，它的所有质因子的指数都为偶数。

在质因数分解的过程中，我们可以通过状态压缩来存储每个质因子的指数的奇偶性，每一个二进制位代表一个质因子，这一位为 $1$ 的含义是其对应的质因子的指数是偶数，反之亦然。判断区间乘积是否为完全平方数可以通过该区间质因数分解结果的异或和是否为 $0$ 来判断。

建立 f 数组，记录区间异或和出现次数，答案就是重复区间异或和出现的次数。

感受

难度简单。

当我们发现要记录奇偶性，又是加起来的时候，就可以想到异或以及状态压缩。

重复区间异或和出现次数这一点比较难想。

总结

整体难度略高，不稳定。

考的算法是搜索、图论、DP、数学这几类，其中 DP 和数学很难。

C++和Python的取模的区别

Sat, 10 Aug 2024 11:04:00 +0800

现象

print(8 % 3)
print(4 % 7)
print(-8 % 3)
print(-4 % 7)
print(8 % -3)
print(4 % -7)
print(-8 % -3)
print(-4 % -7)

在 Python 中，运行以上程序的结果是：

2
4
1
3
-1
-3
-2
-4

在 C++ 中，编写看起来意思一样的程序：

#include <iostream>

using namespace std;

int main() {
	cout << 8 % 3 << endl;
	cout << 4 % 7 << endl;
	cout << -8 % 3 << endl;
	cout << -4 % 7 << endl;
	cout << 8 % -3 << endl;
	cout << 4 % -7 << endl;
	cout << -8 % -3 << endl;
	cout << -4 % -7 << endl;
	return 0;
}

然而，两个程序的运行结果不一样。下面是 C++ 程序的结果。

2
4
-2
-4
2
4
-2
-4

分析

整理数据

整理一下数据，列个表格。

算式	`Python` 结果	`C++` 结果
$8 \bmod 3$	$2$	$2$
$4 \bmod 7$	$4$	$4$
$-8 \bmod 3$	$1$	$-2$
$-4 \bmod 7$	$3$	$-4$
$8 \bmod -3$	$-1$	$2$
$4 \bmod -7$	$-3$	$4$
$-8 \bmod -3$	$-2$	$-2$
$-4 \bmod -7$	$-4$	$-4$

原因

两种语言给出不同的结果的原因是这两种语言执行除法的方式不同。（欧几里得除法：a = b * q + r，a 为被除数，b 为除数，q 为商，r 为余数）

Python 采用的方法是：向负无穷方向舍入，即让商更小（但需保证 $-|b| \le r \le |b|$）。
C++ 采用的方法是：向零舍入，即让商更靠近零（但需保证 $-|b| \le r \le |b|$）。

举个例子

-8 / 3
Python:
-8 = 3 * -3 + 1
C++:
-8 = 3 * -2 - 2

4 / -7
Python:
4 = -7 * -1 - 3
C++:
4 = -7 * 0 + 4

拓展

如何让余数变为非负整数

保证余数为非负整数只需 $((a \bmod b) + b) \bmod b$。

波兰表示法与逆波兰表示法

Sat, 10 Aug 2024 10:31:00 +0800

算术形式

表达“三与四相加”时，前缀记法（即波兰表达式）写作 +34，中缀记法写作 3+4，后缀记法（即逆波兰表达式）写作 34+。中缀表达式 (1-2)*3 的前缀记法为 *-123，后缀记法为 12-3*。

请注意，逆波兰表达式不是把波兰表达式反转。

运算波兰表达式时，无需记住运算的层次，只需要直接寻找第一个运算的操作符。以二元运算为例，从左至右读入表达式，遇到一个操作符后跟随两个操作数时，则计算之，然后将结果作为操作数替换这个操作符和两个操作数；重复此步骤，直至所有操作符处理完毕。

逆波兰表达式的解释器一般是基于堆栈的。解释过程一般是：操作数入栈；遇到操作符时，操作数出栈，求值，将结果入栈；当一遍后，栈顶就是表达式的值。

由于简单运算符都是二元的，所以波兰表达式与逆波兰表达式不需要括号。

例子

前缀表达式

  - / * + 5 7 3 6 4
= - / * 12    3 6 4
= - / 36        6 4
= - 6             4
= 2

  + - 6 * 4 5 2
= + - 6 20    2
= + -14       2
= -12

后缀表达式

  5 7 + 3 * 6 / 4 -
= 12    3 * 6 / 4 -
= 36        6 / 4 -
= 6             4 -
= 2

  6 4 5 * - 2 +
= 6 20    - 2 +
= -14       2 +
= -12

CSP 2023 游记

Sun, 17 Sep 2023 09:14:00 +0800

Day -1

确定考场：北京市第八十中学

啊这……去过不知道多少遍了……

Day 0

9:30

发卷。

钉在一起了？这……不太好翻吧？

11:10

做完了，觉得没什么好检查的了，直接涂答题卡。

迷惑身边的学长怎么涂了半小时。

11:30

考完了，经典收卷不能离开座位。

14:30

时间挺紧，继续考S组。

15:10

已经把会做的题都做完了，决定开始涂答题卡。

15:45

欣赏风景……^_^

16:30

交卷，轻松。

比去年只打J组还轻松。

17:30

J组估分 $69$，比去年低了 $10$ 分！

不应该啊，今年题比去年简单 $10$ 倍。

Day 1

周日，原神？启动！。

S组估分 $47.5$，正常，毕竟我也没认真答。

Day ?

最后成绩：

CSP-J	CSP-S
66	52.5
晋级	晋级
?等奖	?等奖

二分爆long long解决方法

Sun, 23 Oct 2022 14:07:00 +0800

UPD: 2025-07-15

爆掉出现的问题

此处使用爆int举例：

#include <iostream>

using namespace std;

bool check(int x) {
    return x > 1919810;
}

int main() {
    int l = 114514, r = 2.14748e9;
    while ((r - l) > 1) {
        // 1.
        int mid = (l + r) / 2;
        // 2.
        int mid = l + (r - l) / 2;
        if (check(mid)) {
            r = mid;
        } else {
            l = mid + 1;
        }
    }
    cout << l << endl;
    return 0;
}

结果是：

使用1号代码输出-1073686390，使用2号代码输出1919810。

为什么它等于mid

$L+\frac{R-L}{2} = \frac{2L + R - L}{2} = \frac{L + R}{2}$

就是l和r的平均值mid。

为什么不会爆

首先，一般的二分答案都是二分正数（不是的话，答案范围一般不大，如浮点二分三次方根），那r - l就不会爆。

r - l不爆，(r - l) / 2也不会爆。

至于l + (r - l) / 2，很明显，这个值一定在l和r之间，既然l和r不爆，那这个就不可能爆。

总结

当然，除非真的要爆long long了才会用这招，不然写错了可就爆0了。

注：写二分也要注意边界条件哈，听说只有 10% 的程序员能写对二分hhh。

附：整型浮点型爆炸极限

类型名	二分爆炸极限	EPS建议值
`int`	$l = 0, r = 10^{9}$	???
`long long`	$l = 0, r = 4.6 \times 10^{18}$	???
`double`	???	$10^{-8}$ 一般就用 $10^{-5}$（可存15位十进制）
`long double`	???	$10^{-26}$ 一般不用太精确，所以 $10^{-15}$ 就差不多（可存33位十进制）

CSP 2022 参赛经历

Sun, 18 Sep 2022 15:00:00 +0800

Day -2

今天做了个模拟，成绩65，一般般。最主要的是保持一个好状态准备迎接J1。

Day -1

小图灵集训队集训日。今天终于能从J1的思维中跳出来放松一下了！

Day 0

7:30

起床了！洗把脸清醒一下。

8:10

坐上出租车冲向考场！路上复习一下排序的稳定性。

8:45

到达考场所在大厦的楼底下。

验证身份后拿起袋子爬楼，要爬7楼。

走进考场，好紧张好紧张。没想到能遇到同学校的学长，心放下来了一半。

9:30

发卷。

拿到卷子，先浏览一遍，可以看出没有组合数学，位运算放到了阅读程序第一题，阅读第二三题看起来很难，要多分配时间，补全程序很简单，枚举和floodfill。

11:00

做完了，还要检查。

居然出租车上复习都能压中题，欧皇附身了！

11:30

下楼啦，心全放下来了。

19:00

直播时间到！

没想到考后7小时就出估分了，77不是太好。能现场听题解，所有不懂的地方全懂了。

Day 1

周一，上学。

上课就只有两个字，好困！

Day 3

估分更正，79。

这道题到底说的是强连通还是弱联通？！

9.考虑由 $N$ 个顶点构成的有向连通图，采用邻接矩阵的数据结构表示时，该矩阵中至少存在（）个非零元素。

A $N - 1$

B $N$

C $N + 1$

D $N^2$

Day 9

出成绩啦，77又变回去了哈哈哈。

晋级，是肯定的，毕竟我在北京。

可以冲J2啦。

size_t相当于unsigned long long

Thu, 11 Aug 2022 14:38:00 +0800

UPD: 2025-07-15

问题

代码

vector<int> vec;
// some code here
for (int i = 0; i < vec.size() - 1; i ++ ) {
    cout << vec[i] << ' ';
}

原本思路

只打印$vec$的前$|vec| - 1$个元素，就用这个挺好！

显示出的问题

Segmentation Fault 11/0/11

解读

1
2

C:/xxx/xxx.cpp:12:23: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<int>::size_type' {aka 'long long unsigned int'} [-Wsign-compare]
     for (int i = 0; i < vec.size(); i ++ ) {

可以发现如果size是$0$，又因为 size_type 是 unsigned long long，那么就会减出$18446744073709551615$，明显是要报错的。

快速幂

Thu, 11 Aug 2022 11:56:00 +0800

目的

求$m ^ k$ $\bmod$ $p$

反复平方法

预处理

$O(k)$预处理出来以下的数：
$m ^ {2 ^ 0}$ $\bmod$ $p$
$m ^ {2 ^ 1}$ $\bmod$ $p$
$m ^ {2 ^ 2}$ $\bmod$ $p$
…
$m ^ {2 ^{\log{k}}}$ $\bmod$ $p$

怎么做？直接循环！代码忽略，因为还要优化。

算答案

举例子，$4 ^{5}$ $\bmod$ $10$ $ = (4^{2 ^ 2}$ $\bmod$ $10$ $\times$ $4 ^{2 ^ 0}$ $\bmod$ $10)$ $\bmod$ $10$

就可以调预处理的数了，
$4^{2 ^ 2}$ $\bmod$ $10$ $ = $ $6$
$4^{2 ^ 0}$ $\bmod$ $10$ $ = $ $4$
$(6$ $\times$ $4)$ $\bmod$ $10$ $ = $ $4$

验证一下：
$4^5$ $\bmod$ $10$ $=$ $1024$ $\bmod$ $10$ $=$ $4$

把$k$转化为二进制并取出对应的数再相乘，$O(k)$。

把两个步骤合在一起

int qmi(int m, int k, int p) {
    int t = 1 % p;
    while (k) {
        if (k & 1) t = (LL)t * m % p;
        m = (LL)m * m % p;
        k >>= 1;
    }
    return t;
}

关键操作：

k & 1 $k$ 的末位（二进制）为$0$
LL 乘的过程可能会爆int，使用long long

至此，模板题就可以$\Large{\color{green}{AC}}$辣！

应用题

幂次方

题面

对任意正整数 $N$，计算 $X^N \bmod 233333$ 的值。

（输入输出不用管他）

解法

把$233333$看作$p$，彻头彻尾的一道快速幂题。

qmi(X, N, 233333)

越狱

题面

监狱有连续编号为 $1$ 到 $n$ 的 $n$ 个房间，每个房间关押一个犯人。

有 $m$ 种宗教，每个犯人可能信仰其中一种。

如果相邻房间的犯人信仰的宗教相同，就可能发生越狱。

求有多少种状态可能发生越狱，对 $100003$ 取余。

解法

直接想发生越狱的情况数不好想，那就想不发生越狱，$1$有$n$钟选择，$2$要想不发生越狱需要避开$1$的选择，有$n - 1$钟，后面的每一个人都需要避开前面一人的选择，都是$n - 1$种选择。列算式： $$m (m - 1)^{n-1}$$ 那不越狱的方案数就是： $$m^n - m(m - 1)^{n - 1}$$ 用快速幂解决问题。

组合数学 - 从n个球中取m个

Sun, 10 Jul 2022 11:52:00 +0800

UPD: 2025-07-13

不放回（无重排列组合）

有序

$$P_n^m$$

无序

$$C_n^m$$

放回（可重排列组合）

有序

一个一个取，每步可以有$n$种选择，乘法原理： $$n \times n \times n \times…\times n\ = n^m$$

无序

可重组合，可记作： $\bar{C}_n^m$（c bar n m)， $H_n^m$。

重点：隔板法

从$n$元集中可重复的选取$m$个元素，则方程$x_1 + x_2 + x_3 + … + x_n = m$的非负整数解的个数就是可以选的方式的总个数。那么我们可以把这个问题看成在$m$个元素中插入$n-1$个分隔符，每段中是一种元素，就是在$n+m-1$个位置中选取$n-1$个放分隔符，也是$n+m-1$个位置中选取$m$个不放分隔符，就可以用无重组合的方式表示可重组合： $$C_{n+m-1}^{m}$$

无序，每种至少选一个

可重组合的变形，仍使用隔板法。

这次每种至少选一个的使得两个隔板不能放在一起，位置数减小到了$m - 1$，所以答案就是： $$C_{m-1}^{n-1}$$

计蒜客T3633 - 景区三角形

Sun, 01 May 2022 21:07:00 +0800

题目

题目链接：景区三角形

解法

暴力解

直接找出三个点，进行check()，非常简单的思路。

满分解

很明显，这是一个无向图，看数据范围可以看出应该用邻接表。

暴力解的缺点在于可能挑出三个毫无关联的点，那就让每个点拥有1个$fa$，有了它的存在，我们就得找这个图的生成树，因为起码得有个点是根才有$fa$的概念。

假设遍历到的点是$cur$，找到相邻点$v$，那么我们只用看$fa$和$v$是否相邻了，变得非常简单，复杂度降低了很多。

最终，再来谈论一下实现，在判断是否相邻时，使用二分查找，进一步优化。

放代码：

#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>

using namespace std;

const int N = 1e5 + 10;

int n, m;
bool st[N];
int a, b, c;
vector<int> G[N];

struct Node {
    int x, fa;
};

int main() {
    freopen("triangle.in", "r", stdin);
    freopen("triangle.out", "w", stdout);
    cin >> n >> m;
    for (int i = 0; i < m; i ++ ) {
        int u, v;
        cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    for (int i = 1; i <= n; i ++ ) {
        sort(G[i].begin(), G[i].end());
    }

    // bfs
    queue<Node> q;
    q.push(Node{1, -1});
    st[1] = 1;
    while (!q.empty()) {
        Node cur = q.front();
        q.pop();
        bool flag = false;
        for (int i = 0; i < G[cur.x].size(); i ++ ) {
            int v = G[cur.x][i];
            if (cur.fa != -1 && st[v] && v != cur.fa && binary_search(G[v].begin(), G[v].end(), cur.fa)) {
                a = cur.fa;
                b = cur.x;
                c = v;
                if (a > b) swap(a, b);
                if (b > c) swap(b, c);
                if (a > b) swap(a, b);
                flag = true;
                break;
            }
            if (!st[v]) {
                st[v] = true;
                q.push(Node{v, cur.x});
            }
        }
        if (flag) break;
    }
    printf("%d %d %d \n", a, b, c);
    return 0;
}

拓展：基本不使用STL完成这道题

链式前向星

int h[N]; // 链表头
int e[M]; // 通往哪个点
int ne[M]; // 链表中下一个
int w[M]; // 边权
int idx; // 记录到第几条边

// 无权加边（有向）
void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

// 有权加边（有向）
void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

手写队列

int q[N], hh, tt;

// q.empty()
hh == tt

// q.push(x);
q[++ tt] = x;

// q.front()
q[hh + 1]

// q.pop();
hh ++ ;

// bfs模板
q[++ tt] = x;
st[x] = true;
while (hh != tt) {
    hh ++ ;
    if (check(q[hh])) {
        q[++ tt] = get(q[hh]);
    }
}

完整代码

注：抛弃了二分，否则太复杂了。

#include <iostream>
#include <cstring>

using namespace std;

const int N = 1e5 + 10;

int n, m;
bool st[N];
int a, b, c;
int h[N], e[N], ne[N], idx;
int q[N], fa[N], hh, tt;

void add(int u, int v) {
    e[idx] = v, ne[idx] = h[u], h[u] = idx ++ ;
}

bool find(int u, int v) {
    for (int i = h[u]; i != -1; i = ne[i]) {
        if (e[i] == v) return true;
    }
    return false;
}

void swap(int &x, int &y) {
    int z = x;
    x = y;
    y = z;
}

int main() {
    memset(h, -1, sizeof h);
    freopen("triangle.in", "r", stdin);
    freopen("triangle.out", "w", stdout);
    cin >> n >> m;
    for (int i = 0; i < m; i ++ ) {
        int u, v;
        cin >> u >> v;
        add(u, v);
        add(v, u);
    }

    q[++ tt] = 1;
    fa[tt] = -1;
    st[1] = 1;
    while (hh != tt) {
        hh ++ ;
        bool flag = false;
        for (int i = h[q[hh]]; i != -1; i = ne[i]) {
            int v = e[i];
            if (fa[hh] != -1 && st[v] && v != fa[hh] && find(fa[hh], v)) {
                a = fa[hh];
                b = q[hh];
                c = v;
                if (a > b) swap(a, b);
                if (b > c) swap(b, c);
                if (a > b) swap(a, b);
                flag = true;
                break;
            }
            if (!st[v]) {
                st[v] = true;
                q[++ tt] = v;
                fa[tt] = q[hh];
            }
        }
        if (flag) break;
    }

    printf("%d %d %d \n", a, b, c);
    return 0;
}

UPD:2023-10-21

哈希表

Thu, 21 Apr 2022 21:24:00 +0800

UPD: 2025-07-13

功能

add(8);
add(9);
find(10); // false
find(8); // true

实现

首先，写一个散列函数。

1
2
3

int get(int x) {
    return (x % N + N) % N; // 解决负数问题
}

接着，就出现了问题，散列值可能发生碰撞，如何解决呢？

拉链法

每个散列值存一个链表（结构就很像链式前向星了）。

代码如下：

#include <cstring>
#include <iostream>

using namespace std;

const int N = 100003;

int h[N], e[N], ne[N], idx;

void insert(int x) {
    int k = (x % N + N) % N;
    e[idx] = x;
    ne[idx] = h[k];
    h[k] = idx ++ ;
}

bool find(int x) {
    int k = (x % N + N) % N;
    for (int i = h[k]; i != -1; i = ne[i])
        if (e[i] == x)
            return true;

    return false;
}

int main() {
    int n;
    scanf("%d", &n);

    memset(h, -1, sizeof h);

    while (n -- ) {
        char op[2];
        int x;
        scanf("%s%d", op, &x);

        if (*op == 'I') {
            insert(x);
        } else {
            if (find(x)) puts("Yes");
            else puts("No");
        }
    }

    return 0;
}

开放寻址法

通过让 $N$ 增大减少碰撞。并在每次碰撞发生时向后找空位（这是放的时候）。代码如下：

#include <cstring>
#include <iostream>

using namespace std;

const int N = 200003, null = 0x3f3f3f3f;

int h[N];

int find(int x) {
    int t = (x % N + N) % N;
    while (h[t] != null && h[t] != x)
    {
        t ++ ;
        if (t == N) t = 0;
    }
    return t;
}

int main() {
    memset(h, 0x3f, sizeof h);

    int n;
    scanf("%d", &n);

    while (n -- ) {
        char op[2];
        int x;
        scanf("%s%d", op, &x);
        if (*op == 'I') {
            h[find(x)] = x;
        } else {
            if (h[find(x)] == null) puts("No");
            else puts("Yes");
        }
    }

    return 0;
}

循环队列

Tue, 19 Apr 2022 15:25:00 +0800

UPD: 2023-10-21 UPD: 2025-07-13

循环队列

功能

节省空间。

普通队列用过的空间不能用了，循环队列可以重复利用。

`1`	`push(1); pop(); push(2); pop();`

实际比赛中根本用不到（现在这年头还有谁手写数据结构啊），直接用 STL queue。

代码

#include <iostream>

using namespace std;

// 队列长度，可以自己修改。
const int N = 10;

// 队列
struct Queue {
    int q[N];
    int hh = 1, tt = 0;

    void push(int x) {
        q[( ++ tt) % N] = x;
        if (hh / N && tt / N) {
            hh -= (int)min(hh / N, tt / N) * N;
            tt -= (int)min(hh / N, tt / N) * N;
        }
    }

    void pop() {
        hh ++ ;
    }

    int front() {
        return q[hh % N];
    }

    int back() {
        return q[tt % N];
    }

    bool empty() {
        return hh > tt;
    }

    int size() {
        return tt - hh + 1;
    }
};

关于

Mon, 01 Jan 0001 00:00:00 +0000

👋 你好，我是 @ray2060
🐰 我 14 岁了
💻 我从 2021 年开始 OI 生涯
📧 我的电子邮箱是 r@pythoner.work

归档

Mon, 01 Jan 0001 00:00:00 +0000

链接

Mon, 01 Jan 0001 00:00:00 +0000

搜索

Mon, 01 Jan 0001 00:00:00 +0000