[蓝桥杯 2023 省 B] 景区导游

GitHub跳转原题关系图返回列表

跳过一个景点只是把线路上的两段相邻距离换成一段，先用倍增 LCA 求出任意两点在树上的距离，再用总时间加减这三次变化就能 O(1) 得到每个答案。

OJ: luogu

题目 ID: P9245

难度:普及+/提高-

标签:树倍增LCA图论前缀和

创建: 2026-10-02 15:07

更新: 2026-10-07 12:15

前置题目

luogu P1364医院设置B 的暴力解（brute.cpp 的 path_len）对每对相邻景点各做一次单源 BFS，直接复用 A 教的『树上两点路径唯一、BFS 第一次到达的层数就是边数距离』这一步来量出 d(u,v)；B 的正解在这条路径唯一性上把同一量改写为 dist[u]+dist[v]-2dist[lca] 并用倍增把反复 BFS 压成 O(log N)，额外叠加的 LCA/倍增与线路增量观察是 A 未教的新流程，故为模板级前置。

形式化题目

给定一棵有 $N$ 个结点、 $N-1$ 条边的带权树（边权 $t$ 表示通行时间），以及一个长度为 $K$ 的结点序列

A_1, A_2, \dots, A_K \qquad (A_i \text{ 两两不同}).

树中任意两点 $u, v$ 之间路径唯一，记 $d(u,v)$ 为这条唯一路径上的边权之和，称它是 $u$ 到 $v$ 的时间花费。

对每个 $i \in [1, K]$ ，把 $A_i$ 从序列中删掉，令剩下的 $K-1$ 个结点保持原相对顺序构成新序列 $B$ ，求

S_i = \sum_{j=1}^{K-2} d(B_j, B_{j+1}),

即新序列中相邻两项的时间花费之和（ $K = 2$ 时这个和为 $0$ ）。

要求输出 $S_1, S_2, \dots, S_K$ 。

暴力解法

思路

题面的定义本身就是一份算法，直接照抄即可：

对每个要跳过的位置 $i$ ，把除 $A_i$ 之外的结点按原顺序抄进一个新序列；
对新序列里每一对相邻结点 $(u, v)$ ，从 $u$ 出发对整棵树做一次 BFS，求出 $u$ 到所有点的距离，取其中 $v$ 的距离作为这一段的时间；
把新序列所有相邻段的时间加起来，就是 $S_i$ 。

第 2 步之所以可以直接用 BFS 求距离，是因为树上两点之间的路径唯一：BFS 从 $u$ 扩散时一旦到达 $v$ ，走过的边权和就已经是全部可能中最小的，也就是 $d(u,v)$ 。

这个写法不做任何建模和优化，因此是可靠的对拍基线。用样例 1 手算一遍：跳过 2 时新序列是 $6,5,1$ ，两段分别是 $7$ 和 $3$ ，合计 $10$ ；跳过 1 时新序列是 $2,6,5$ ，两段分别是 $7$ 和 $7$ ，合计 $14$ 。

代码

cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109/**
 * Author by Rainboy blog: https://rainboylv.com github: https://github.com/rainboylvx
 * rbook: -> https://rbook.roj.ac.cn  https://rbook2.roj.ac.cn
 * rainboy的学习导航网站: https://idx.roj.ac.cn
 * create_at: 2026-10-03 11:38
 * update_at: 2026-10-03 11:38
 */
// brute.cpp：小数据暴力解，用来帮助理解题意并辅助对拍。
// 直接照抄题面的定义：
//   对每一个要跳过的景点 A[i]，把剩下的 K-1 个景点按原顺序排成新线路，
//   再一段一段地数时间——对其中每一对相邻景点 (u, v) 都单独做一次 BFS，
//   从 u 出发遍历整棵树算出到所有点的距离，取 dist[v] 就是这一段的时间。
// 每段路径都要重新搜一遍整棵树，复杂度约 O(K^2 * N)，
// 节点数稍大就会很慢，所以只适合小数据对拍。
#include <iostream>
#include <queue>
using namespace std;

const int MAXN = 1005; // 暴力只跑小树
const int MAXM = 2005;

int n, k;
int a[MAXN];    // 原定游览线路 A[1..K]
int keep[MAXN]; // 跳过某个景点后剩下的游览顺序

// 链式前向星存树
int head[MAXN], to[MAXM], nxt[MAXM], edge_cnt;
int wt[MAXM];

long long dist[MAXN]; // 本次 BFS 中，起点到每个点的路径长度；-1 表示还没访问
queue<int> q;   // BFS 队列

// 加一条无向边：u <-> v，花费时间 w。
void add_edge(int u, int v, int w) {
    edge_cnt++;
    to[edge_cnt] = v;
    wt[edge_cnt] = w;
    nxt[edge_cnt] = head[u];
    head[u] = edge_cnt;
}

// 求树上 u 到 v 的唯一路径长度：从 u 出发做一次 BFS。
long long path_len(int u, int v) {
    for (int i = 1; i <= n; i++) {
        dist[i] = -1;
    }
    while (!q.empty()) {
        q.pop();
    }

    dist[u] = 0;
    q.push(u);
    while (!q.empty()) {
        int x = q.front();
        q.pop();
        for (int i = head[x]; i != 0; i = nxt[i]) {
            int y = to[i];
            if (dist[y] != -1) continue;
            dist[y] = dist[x] + wt[i];
            q.push(y);
        }
    }
    return dist[v];
}

void read_input() {
    cin >> n >> k;
    for (int i = 1; i <= n - 1; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        add_edge(u, v, w);
        add_edge(v, u, w);
    }
    for (int i = 1; i <= k; i++) {
        cin >> a[i];
    }
}

void solve() {
    for (int skip = 1; skip <= k; skip++) {
        // 把跳过 A[skip] 之后剩下的景点按原顺序收集到 keep[]。
        int cnt = 0;
        for (int i = 1; i <= k; i++) {
            if (i == skip) continue;
            cnt++;
            keep[cnt] = a[i];
        }

        // 一段一段地重新搜，累加新线路里每一对相邻景点之间的时间。
        long long total = 0;
        for (int i = 1; i <= cnt - 1; i++) {
            total += path_len(keep[i], keep[i + 1]);
        }

        if (skip != 1) cout << " ";
        cout << total;
    }
    cout << "\n";
}

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

    read_input();
    solve();

    return 0;
}

复杂度

$K$ 个待跳过位置，每个位置要算 $K-1$ 段，每段一次 $O(N)$ 的 BFS，总时间复杂度

O(K^2 N),

空间复杂度 $O(N)$ 。 $N = K = 10^5$ 时约 $10^{15}$ 次松弛，完全无法运行。

瓶颈

瓶颈不是某一步常数太大，而是同一份信息被反复重算：

设 $L_j = d(A_j, A_{j+1})$ （ $1 \leqslant j < K$ ）表示原线路第 $j$ 段的时间。删掉 $A_i$ 之后，新线路和原线路相比只有 $A_i$ 附近发生了变化：

离 $A_i$ 足够远的那些段 $L_j$ （ $j \notin \{i-1,\, i\}$ ）在新线路里原封不动地保留了下来；
只有 $A_i$ 左右两侧的至多两段被去掉，中间情况还补上一段 $d(A_{i-1}, A_{i+1})$ 。

也就是说 $S_i$ 与 $T$ 只差 $O(1)$ 个量。但暴力为每个 $i$ 都把剩下的 $K-2$ 段重新搜了一遍树，于是 $L_j$ 这个只由树和点对决定的量被计算了 $O(K)$ 次。

只要先把 $L_1, \dots, L_{K-1}$ 各算一次并累加出总时间， $S_i$ 就是一次 $O(1)$ 的加减。

正解

思路

第一步：把 $S_i$ 写成总时间的一次增量

令原线路的总时间为

T = \sum_{j=1}^{K-1} L_j = \sum_{j=1}^{K-1} d(A_j, A_{j+1}).

删掉 $A_i$ 之后，新的相邻点对和原来相比只有三种可能：

位置	消失的段	新增的段	$S_i$
$i = 1$	$L_1 = d(A_1,A_2)$	无	$T - L_1$
$1 < i < K$	$L_{i-1} = d(A_{i-1},A_i)$ 、 $L_i = d(A_i,A_{i+1})$	$d(A_{i-1},A_{i+1})$	$T - L_{i-1} - L_i + d(A_{i-1},A_{i+1})$
$i = K$	$L_{K-1} = d(A_{K-1},A_K)$	无	$T - L_{K-1}$

中间那一行是全题的枢纽：本来线路走的是 $A_{i-1} \to A_i \to A_{i+1}$ ，删掉 $A_i$ 后就变成直接从 $A_{i-1}$ 走到 $A_{i+1}$ ；所以两段并成一段，总时间要减掉这两段、再加上新的一段。

这一步把“为每个 $i$ 重建序列并重新求和”的需求彻底消掉了， $S_i$ 只依赖 $T$ 、两个旧段和至多一个新段。

第二步：用 LCA 在 $O(\log N)$ 内求出任意两点距离

剩下的事只有一件：把 $d(u,v)$ 求快。把树根固定为 $1$ 号结点，令

dist[x]：根到 $x$ 的路径长度；
lca(u,v)： $u$ 与 $v$ 的最近公共祖先。

则对任意两点有

d(u,v) = dist[u] + dist[v] - 2\,dist[\mathrm{lca}(u,v)].

这个公式为什么成立？ 设 $w = \mathrm{lca}(u,v)$ 。 $u$ 到根和 $v$ 到根的路径在 $w$ 以上完全重合，在 $w$ 以下互不相交；而 $u \to w \to v$ 正是 $u$ 到 $v$ 那条唯一路径。于是

dist[u] + dist[v] = \underbrace{(dist[w] + d(w,u))}_{dist[u]} + \underbrace{(dist[w] + d(w,v))}_{dist[v]} = 2\,dist[w] + d(u,v),

移项即得。所以求出 $dist$ 和 LCA 就够了。

第三步：倍增求 LCA

$K$ 最大 $10^5$ ，总共约 $2K$ 次求距离，如果每次沿着树往上爬（链上最坏 $O(N)$ ），总复杂度会退化成 $O(NK)$ 。倍增法把单次询问降到 $O(\log N)$ ：

先 BFS 一遍，得到每个点的 depth[x]、dist[x] 和父亲 up[x][0]。用 BFS 而不是递归 DFS，因为树可能是一条长 $10^5$ 的链，递归会爆栈。
递推倍增表：up[x][j] 表示 $x$ 向上跳 $2^j$ 步到达的祖先，由 $x$ 跳 $2^{j-1}$ 步再跳 $2^{j-1}$ 步得到，即 up[x][j] = up[up[x][j-1]][j-1]。
询问时先把较深的点向上提到同一深度；若两点已经相同，它就是 LCA。否则从大到小枚举 $j$ ，只要两个人的 $2^j$ 级祖先不同就一起上跳。循环结束时两人深度相同、自身不同、父亲相同，那个父亲就是 LCA。
对根的 up[1][0] 设成它自己作为哨兵，这样任何一次跳跃都不会越出数组。

因为 $2^{20} > 10^5$ ，取 LOG = 20 即可。

完整流程与样例推演

先用倍增算出原线路的每一段并求和得到 $T$ ，再按上表逐项加减输出。以样例 1 为例，树是

$2 \xleftarrow{1} 1 \xleftarrow{1} 3 \xrightarrow{2} 4 \xrightarrow{3} 6$ ，另外 $3 \xrightarrow{2} 5$ ，线路是 $2 \to 6 \to 5 \to 1$ 。

graph TD
  V1(("1")) ---|1| V2(("2"))
  V1 ---|1| V3(("3"))
  V3 ---|2| V4(("4"))
  V3 ---|2| V5(("5"))
  V4 ---|3| V6(("6"))

图中每个结点是景点，边上的数字是摆渡时间。原线路依次经过 $2 \to 6 \to 5 \to 1$ ，也就是在图上先走到 $4$ 、再走到 $6$ ，然后折返到 $3$ 、 $5$ ，最后回到 $1$ 。

三段距离与总时间为

段	路径	距离
$2 \to 6$	$2-1-3-4-6$	$1+1+2+3 = 7$
$6 \to 5$	$6-4-3-5$	$3+2+2 = 7$
$5 \to 1$	$5-3-1$	$2+1 = 3$
—	合计 $T$	$17$

按公式逐个答案：

跳过	类型	计算	$S_i$
$2$	$i=1$	$17 - L_1 = 17 - 7$	$10$
$6$	中间	$17 - 7 - 7 + d(2,5)$ ，其中 $d(2,5)=1+1+2=4$	$7$
$5$	中间	$17 - 7 - 3 + d(6,1)$ ，其中 $d(6,1)=3+2+1=6$	$13$
$1$	$i=K$	$17 - L_3 = 17 - 3$	$14$

得到 10 7 13 14，与题面样例一致。对比暴力解：它把 $d(2,6)=7$ 、 $d(6,5)=7$ 这些量在每个答案里都重算了一遍，而这里每一段只算一次。

代码

build_root() 用 BFS 求出 depth/dist/父亲，build_lift() 递推倍增表，lca() 与 path_len() 提供 $O(\log N)$ 的两点距离；solve() 先累加出原线路总时间，再按“首段 / 中间两段换一段 / 尾段”三种情况输出。

cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169/**
 * Author by Rainboy blog: https://rainboylv.com github: https://github.com/rainboylvx
 * rbook: -> https://rbook.roj.ac.cn  https://rbook2.roj.ac.cn
 * rainboy的学习导航网站: https://idx.roj.ac.cn
 * create_at: 2026-10-03 11:38
 * update_at: 2026-10-03 11:38
 */
// P9245 [蓝桥杯 2023 省 B] 景区导游
// 思路：
//   1. 这是一棵树，两点之间只有一条路径，所以“从 u 到 v 花多少时间”就是
//      dist[u] + dist[v] - 2 * dist[lca(u, v)]，其中 dist[x] 是根到 x 的距离。
//   2. 原路线总时间 total 是相邻两点的距离之和；跳过 A[i] 只是把两段相邻距离
//      a[i-1] -> a[i] 和 a[i] -> a[i+1] 合并成一段 a[i-1] -> a[i+1]，
//      所以答案 = total - d(a[i-1],a[i]) - d(a[i],a[i+1]) + d(a[i-1],a[i+1])。
//   3. 总时间 total 加上首/中/尾三种情况下的增量，就得到每个答案；
//      全程只需要 O(K) 次 LCA 询问，每次 O(log N)。
#include <iostream>
#include <queue>
using namespace std;

typedef long long ll;

const int MAXN = 100005; // 景点数上限
const int MAXM = 200005; // 无向边数上限（每条边存正反两条）
const int LOG = 20;      // 2^20 > 10^5，足够跳到根

int n, k;
int a[MAXN]; // 原定游览线路 A[1..K]

// 链式前向星存树
int head[MAXN], to[MAXM], nxt[MAXM], edge_cnt;
ll wt[MAXM]; // 每条边的摆渡时间

int depth[MAXN];       // 根到该点的边数
ll dist[MAXN];         // 根到该点的路径长度
int up[MAXN][LOG + 1]; // up[x][j]：x 向上跳 2^j 步到达的祖先

// 加一条无向边：u <-> v，花费时间 w。
void add_edge(int u, int v, ll w) {
    edge_cnt++;
    to[edge_cnt] = v;
    wt[edge_cnt] = w;
    nxt[edge_cnt] = head[u];
    head[u] = edge_cnt;
}

void read_input() {
    cin >> n >> k;
    for (int i = 1; i <= n - 1; i++) {
        int u, v;
        ll t;
        cin >> u >> v >> t;
        add_edge(u, v, t);
        add_edge(v, u, t);
    }
    for (int i = 1; i <= k; i++) {
        cin >> a[i];
    }
}

// 以 1 号景点为根，BFS 求出 depth、dist 和 up[x][0]。
// 用队列而不是递归，避免 n = 10^5 的链把栈撑爆。
void build_root() {
    for (int i = 1; i <= n; i++) {
        depth[i] = -1;
    }
    queue<int> q;
    depth[1] = 0;
    dist[1] = 0;
    up[1][0] = 1; // 根的祖先设成自己，越界也不会跳出去
    q.push(1);

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = head[u]; i != 0; i = nxt[i]) {
            int v = to[i];
            if (depth[v] != -1) continue;
            depth[v] = depth[u] + 1;
            dist[v] = dist[u] + wt[i];
            up[v][0] = u;
            q.push(v);
        }
    }
}

// 预处理倍增表：up[x][j] 表示 x 向上跳 2^j 步的祖先。
void build_lift() {
    for (int j = 1; j <= LOG; j++) {
        for (int x = 1; x <= n; x++) {
            up[x][j] = up[up[x][j - 1]][j - 1];
        }
    }
}

// 把 x 向上提 d 步。
int jump_up(int x, int d) {
    for (int j = 0; j <= LOG; j++) {
        if ((d >> j) & 1) {
            x = up[x][j];
        }
    }
    return x;
}

// 倍增求最近公共祖先。
int lca(int u, int v) {
    if (depth[u] < depth[v]) {
        int tmp = u;
        u = v;
        v = tmp;
    }
    u = jump_up(u, depth[u] - depth[v]);

    if (u == v) return u;

    // 从大步到小步一起爬，直到两人的父亲相同。
    for (int j = LOG; j >= 0; j--) {
        if (up[u][j] != up[v][j]) {
            u = up[u][j];
            v = up[v][j];
        }
    }
    return up[u][0];
}

// 树上从 u 到 v 的唯一路径长度。
ll path_len(int u, int v) {
    int w = lca(u, v);
    return dist[u] + dist[v] - 2 * dist[w];
}

void solve() {
    build_root();
    build_lift();

    // 原路线的总时间：相邻两点距离之和。
    ll total = 0;
    for (int i = 1; i <= k - 1; i++) {
        total += path_len(a[i], a[i + 1]);
    }

    for (int i = 1; i <= k; i++) {
        if (i == 1) {
            // 跳过第一个点，只要去掉第一段。
            cout << total - path_len(a[1], a[2]);
        } else if (i == k) {
            // 跳过最后一个点，只要去掉最后一段。
            cout << total - path_len(a[k - 1], a[k]);
        } else {
            // 中间的点：两段合并成一段。
            ll erase_two = path_len(a[i - 1], a[i]) + path_len(a[i], a[i + 1]);
            ll add_one = path_len(a[i - 1], a[i + 1]);
            cout << total - erase_two + add_one;
        }
        if (i != k) cout << " ";
    }
    cout << "\n";
}

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

    read_input();
    solve();

    return 0;
}

复杂度

阶段	复杂度
BFS 求 `depth`、`dist`、父亲	$O(N)$
倍增表	$O(N \log N)$
原线路总时间 $T$	$O(K \log N)$
$K$ 个答案	$O(K \log N)$
总计	$O\big((N+K)\log N\big)$

空间复杂度 $O(N \log N)$ ，其中 up 表约 $2 \times 10^6$ 个 int。答案最大约 $K \cdot N \cdot t = 10^{15}$ 量级，dist、总时间和输出都要用 long long。

$N = K = 10^5$ 的链状数据实测约 $0.33$ 秒。

总结

这道题的解法是两次“把重复的事只做一次”：

消除重复的求和。观察到删掉中间一个点只是把线路上的两段并成一段，于是先算出原线路总时间 $T$ ，每个 $S_i$ 就变成 $T$ 减去（至多）两段、再加上（至多）一段。这一层是纯观察，和树的结构无关。
消除重复的求距离。树上两点距离用 $dist[u] + dist[v] - 2\,dist[\mathrm{lca}(u,v)]$ 求，而 LCA 用倍增表 $O(\log N)$ 询问一次，避免了对同一棵树反复做 BFS。

两次优化合起来把 $O(K^2 N)$ 的暴力降到了 $O((N+K)\log N)$ 。这类“把每个询问写成全局量的增量” + “用倍增把树上路径询问变便宜”的组合，在树上路径问题里非常常见，值得当作一个固定的套路记住。

P9245 [蓝桥杯 2023 省 B] 景区导游

题目描述

某景区一共有 $N$ 个景点，编号 $1$ 到 $N$ 。景点之间共有 $N-1$ 条双向的摆渡车线路相连，形成一棵树状结构。在景点之间往返只能通过这些摆渡车进行，需要花费一定的时间。

小明是这个景区的资深导游，他每天都要按固定顺序带客人游览其中 $K$ 个景点： $A_{1},A_{2},\ldots,A_{K}$ 。今天由于时间原因，小明决定跳过其中一个景点，只带游客按顺序游览其中 $K-1$ 个景点。具体来说，如果小明选择跳过 $A_{i}$ ，那么他会按顺序带游客游览 $A_{1},A_{2},\ldots,A_{i-1},A_{i+1},\ldots,A_{K}(1 \leq i \leq K)$ 。

请你对任意一个 $A_{i}$ ，计算如果跳过这个景点，小明需要花费多少时间在景点之间的摆渡车上？

输入格式

第一行包含 $2$ 个整数 $N$ 和 $K$ 。

以下 $N-1$ 行，每行包含 $3$ 个整数 $u, v, t$ ，代表景点 $u$ 和 $v$ 之间有摆渡车线路，花费 $t$ 个单位时间。

最后一行包含 $K$ 个整数 $A_{1},A_{2},\ldots,A_{K}$ 代表原定游览线路。

输出格式

输出 $K$ 个整数，其中第 $i$ 个代表跳过 $A_{i}$ 之后，花费在摆渡车上的时间。

输入输出样例 #1

输入 #1

text

输出 #1

text

110 7 13 14

说明/提示

【样例说明】

原路线是 $2 \rightarrow 6 \rightarrow 5 \rightarrow 1$ 。

当跳过 $2$ 时，路线是 $6 \rightarrow 5 \rightarrow 1$ ，其中 $6 \rightarrow 5$ 花费时间 $3+2+2=7$ ， $5 \rightarrow 1$ 花费时间 $2+1=3$ ，总时间花费 $10$ 。

当跳过 $6$ 时，路线是 $2 \rightarrow 5 \rightarrow 1$ ，其中 $2 \rightarrow 5$ 花费时间 $1+1+2=4$ ， $5 \rightarrow 1$ 花费时间 $2+1=3$ ，总时间花费 $7$ 。

当跳过 $5$ 时，路线是 $2 \rightarrow 6 \rightarrow 1$ ，其中 $2 \rightarrow 6$ 花费时间 $1+1+2+3=7$ ， $6 \rightarrow 1$ 花费时间 $3+2+1=6$ ，总时间花费 $13$ 。

当跳过 $1$ 时，路线时 $2 \rightarrow 6 \rightarrow 5$ ，其中 $2 \rightarrow 6$ 花费时间 $1+1+2+3=7$ ， $6 \rightarrow 5$ 花费时间 $3+2+2=7$ ，总时间花费 $14$ 。

【评测用例规模与约定】

对于 $20 \%$ 的数据， $2 \leq K \leq N \leq 100$ 。

对于 $40 \%$ 的数据， $2 \leq K \leq N \leq 10^{4}$ 。

对于 $100 \%$ 的数据， $2 \leq K \leq N \leq 10^{5}$ ， $1 \leq u,v,A_{i} \leq N$ ， $1 \leq t \leq 10^{5}$ 。保证 $A_{i}$ 两两不同。

蓝桥杯 2023 省赛 B 组 I 题。