树 on 分而治之

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

树状数组及典型例题

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;
}

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 和数学很难。