第十四届蓝桥杯大赛软件赛省赛（C/C++ 大学B组）_蓝桥杯软件测试真题

---

要来力

---

试题 A: 日期统计

本题总分：$5$ 分

---

【问题描述】

  小蓝现在有一个长度为 $100$ 的数组，数组中的每个元素的值都在 $0$ 到 $9$ 的范围之内。数组中的元素从左至右如下所示：
  $5$ $6$ $8$ $6$ $9$ $1$ $6$ $1$ $2$ $4$ $9$ $1$ $9$ $8$ $2$ $3$ $6$ $4$ $7$ $7$ $5$ $9$ $5$ $0$ $3$ $8$ $7$ $5$ $8$ $1$ $5$ $8$ $6$ $1$ $8$ $3$ $0$ $3$ $7$ $9$ $2$ $7$ $0$ $5$ $8$ $8$ $5$ $7$ $0$ $9$ $9$ $1$ $9$ $4$ $4$ $6$ $8$ $6$ $3$ $3$ $8$ $5$ $1$ $6$ $3$ $4$ $6$ $7$ $0$ $7$ $8$ $2$ $7$ $6$ $8$ $9$ $5$ $6$ $5$ $6$ $1$ $4$ $0$ $1$ $0$ $0$ $9$ $4$ $8$ $0$ $9$ $1$ $2$ $8$ $5$ $0$ $2$ $5$ $3$ $3$
  现在他想要从这个数组中寻找一些满足以下条件的子序列：
  1. 子序列的长度为 $8$；
  2. 这个子序列可以按照下标顺序组成一个 $\mathrm{yyyymmdd}$ 格式的日期，并且要求这个日期是 $2023$ 年中的某一天的日期，例如 $20230902$，$20231223$。$\mathrm{yyyy}$ 表示年份，$\mathrm{mm}$ 表示月份，$\mathrm{dd}$ 表示天数，当月份或者天数的长度只有一位时需要一个前导零补充。
  请你帮小蓝计算下按上述条件一共能找到多少个不同的 $2023$ 年的日期。对于相同的日期你只需要统计一次即可。

【答案提交】

  这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

---

235

---

  枚举长度为$8$的子序列复杂度直接炸裂，不过考虑到日期前缀为$2023$且唯一，因为找到$2023$第一次出现的位置截断后枚举长度为$4$的子序列与$2023$年的合法日期取交集即可。

#include <bits/stdc++.h>

char *A = "5686916124919823647759503875815861830379270588570991944686338516346707827689565614010094809128502533";

char *prefix = "2023";

int n = 100, m = 0, ds[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

std::set<int> subs[4], target;

std::vector<int> ans;

int main() {
    for (int k = 0; k < 4 && m < n; ++m)
        if (prefix[k] == A[m]) ++k;
    for (; m < n; ++m) {
        for (int i = 2; i >= 0; --i)
            for (int sb : subs[i])
                subs[i + 1].insert(sb * 10 + A[m] - '0');
        subs[0].insert(A[m] - '0');
    }
    for (int m = 1; m <= 12; ++m)
        for (int d = 1; d <= ds[m]; ++d)
            target.insert(m * 100 + d);
    std::set_intersection(target.begin(), target.end(), subs[3].begin(), subs[3].end(), std::back_inserter(ans));
    printf("%d", ans.size());
}
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

---

试题 B: 01 串的熵

本题总分：$5$ 分

---

【问题描述】

  对于一个长度为 $n$ 的 $01$ 串 $S=x_1{x}_2{x}_3\cdots x_n$，香农信息熵的定义为 $H(S)=-{\sum }_i^{n}p(x_i){\log }_2(p(x_i))$，其中 $p(0),p(1)$ 表示在这个 $01$ 串中 $0$ 和 $1$ 出现的占比。比如，对于 $S=100$ 来说，信息熵 $H(S)=-\frac{1}{3}{\log }_2(\frac{1}{3})-\frac{2}{3}{\log }_2(\frac{2}{3})-\frac{2}{3}{\log }_2(\frac{2}{3})=1.3083$。对于一个长度为 $23333333$ 的 $01$ 串，如果其信息熵为 $11625907.5798$，且 $0$ 出现次数比 $1$ 少，那么这个 $01$ 串中 $0$ 出现了多少次？

【答案提交】

  这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

---

11027421

---

对于一个长度为$a+b$且$0$出现$a$次的$01$串$S$，$H(S)=-a\frac{a}{a+b}{\log }_2(\frac{a}{a+b})-b\frac{b}{a+b}{\log }_2(\frac{b}{a+b})$，嗯算就完了。

#include <stdio.h>
#include <math.h>

int n = 23333333;

double target = 11625907.5798;

int main() {
    for (double i = 0, j = n; i <= n; i += 1, j -= 1)
        if (abs(i * (- i / n * log2(i / n)) + j * (- j / n * log2(j / n)) - target) < 1e-4) {
            printf("%.0lf", i);
            return 0;
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

试题 C: 冶炼金属

时间限制: $1.0\mathrm{s}$ 内存限制: $256.0\mathrm{MB}$ 本题总分：$10$ 分

---

【问题描述】

  小蓝有一个神奇的炉子用于将普通金属 $O$ 冶炼成为一种特殊金属 $X$。这个炉子有一个称作转换率的属性 $V$，$V$ 是一个正整数，这意味着消耗 $V$ 个普通金属 $O$ 恰好可以冶炼出一个特殊金属 $X$，当普通金属 $O$ 的数目不足 $V$ 时，无法继续冶炼。
  现在给出了 $N$ 条冶炼记录，每条记录中包含两个整数 $A$ 和 $B$，这表示本次投入了 $A$ 个普通金属 $O$，最终冶炼出了 $B$ 个特殊金属 $X$。每条记录都是独立的，这意味着上一次没消耗完的普通金属 $O$ 不会累加到下一次的冶炼当中。
  根据这 $N$ 条冶炼记录，请你推测出转换率 $V$ 的最小值和最大值分别可能是多少，题目保证评测数据不存在无解的情况。

【输入格式】

  第一行一个整数 $N$，表示冶炼记录的数目。
  接下来输入 $N$ 行，每行两个整数 $A、B$，含义如题目所述。

【输出格式】

  输出两个整数，分别表示 $V$ 可能的最小值和最大值，中间用空格分开。

【样例输入】

3
75 3
53 2
59 2
1
2
3
4

【样例输出】

20 25
1

【样例说明】

  当 $V=20$ 时，有：$\lfloor \frac{75}{20}\rfloor =3,\lfloor \frac{53}{20}\rfloor =2,\lfloor \frac{59}{20}\rfloor =2$，可以看到符合所有冶炼记录。
  当 $V=25$ 时，有：$\lfloor \frac{75}{25}\rfloor =3,\lfloor \frac{53}{25}\rfloor =2,\lfloor \frac{59}{25}\rfloor =2$，可以看到符合所有冶炼记录。
  且再也找不到比 $20$ 更小或者比 $25$ 更大的符合条件的 $V$ 值了。

【评测用例规模与约定】

  对于 $30\%$ 的评测用例，$1\le N\le 10^2$。
  对于 $60\%$ 的评测用例，$1\le N\le 10^3$。
  对于 $100\%$ 的评测用例，$1\le N\le 10^4，1\le B\le A\le 10^9$。

---

记$V_i^{max}$为满足$\lfloor \frac{A_i}{V_i}\rfloor =B_i$的最大值，$V_i^{min}$为满足$\lfloor \frac{A_i}{V_i}\rfloor =B_i$的最小值，则最大的$V$取 min ⁡ { V i m a x } \min\{V_i^{max}\} min{Vimax​}，因为取最大值可能会使$\lfloor \frac{A_i}{V_i}\rfloor >B_i$成立，同理最小的$V$取 max ⁡ { V i m a x } \max\{V_i^{max}\} max{Vimax​}。
对于$A$、$B$我们取$\lfloor \frac{A}{B}\rfloor$做$V^{max}$，当$A=VB$时$V$的取值唯一，显然成立，否则$\lceil \frac{A}{B}\rceil =V^{max}+1$，当取$V^{max}+1$做$V$时带入$\lfloor \frac{A}{V}\rfloor =\lfloor \frac{B(V-1)+A^{\prime }}{V}\rfloor <B$，故$V^{max}$最大。
考虑到$\lfloor \frac{A}{V}\rfloor$为单调减函数，我们取$A,B+1$的最大值加$1$,显然最小。

#include <stdio.h>
#include <algorithm>

int n, a, b, max = 0x3f3f3f3f, min = 0;

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        scanf("%d %d", &a, &b);
        max = std::min(max, a / b);
        min = std::max(min, a / (b + 1) + 1);
    }
    printf("%d %d", min, max);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

试题 D: 飞机降落

时间限制: $2.0\mathrm{s}$ 内存限制: $256.0\mathrm{MB}$ 本题总分：$10$ 分

---

【问题描述】

  $N$ 架飞机准备降落到某个只有一条跑道的机场。其中第 $i$ 架飞机在 $T_i$ 时刻到达机场上空，到达时它的剩余油料还可以继续盘旋 $D_i$ 个单位时间，即它最早可以于 $T_i$ 时刻开始降落，最晚可以于 $T_i+D_i$ 时刻开始降落。降落过程需要 $L_i$个单位时间。
  一架飞机降落完毕时，另一架飞机可以立即在同一时刻开始降落，但是不能在前一架飞机完成降落前开始降落。
  请你判断 $N$ 架飞机是否可以全部安全降落。

【输入格式】

  输入包含多组数据。
  第一行包含一个整数 $T$，代表测试数据的组数。
  对于每组数据，第一行包含一个整数 $N$。
  以下 $N$ 行，每行包含三个整数：$T_i$，$D_i$ 和 $L_i$。

【输出格式】

  对于每组数据，输出 $\mathrm{YES}$ 或者 $\mathrm{NO}$，代表是否可以全部安全降落。

【样例输入】

2
3
0 100 10
10 10 10
0 2 20
3
0 10 20
10 10 20
20 10 20
1
2
3
4
5
6
7
8
9

【样例输出】

YES
NO
1
2

【样例说明】

  对于第一组数据，可以安排第 $3$ 架飞机于 $0$ 时刻开始降落，$20$ 时刻完成降落。安排第 $2$ 架飞机于 $20$ 时刻开始降落，$30$ 时刻完成降落。安排第 $1$ 架飞机于 $30$ 时刻开始降落，$40$ 时刻完成降落。
  对于第二组数据，无论如何安排，都会有飞机不能及时降落。

【评测用例规模与约定】

  对于 $30\%$ 的数据，$N\le 2$。
  对于 $100\%$ 的数据，$1\le T\le 10，1\le N\le 10，0\le T_i,D_i,L_i\le 10^5$。

---

感觉暴搜会被卡常，所以选用记忆化搜索，用二进制表示第$i$位为$1$表示第$i$量飞机降落，记$d{p}_{status}$为$status$表示的降落状态的最早完成时间，$-1$表示不可达，$\inf$表示未访问，时间复杂度为$O({\sum }_{i=1}^T(N_i{C}_N^N+(N_i-1)C_N^{N-1}+\cdots +C_N^1))=O(TN{2}^{N-1})$。

#include <stdio.h>
#include <algorithm>

int T, n, t[1 << 10], d[1 << 10], l[1 << 10], dp[1 << 10], inf = 0x3f3f3f3f;

int dfs(int status, int depth) {
    if (dp[status] != inf) return dp[status];
    if (depth == n) return dp[status] = t[status] + l[status];
    for (int i = status; i; ) {
        int p = i & -i;
        int q = dfs(status - p, depth + 1);
        if (q != -1 && q <= t[p] + d[p])
            dp[status] = std::min(dp[status], std::max(t[p], q) + l[p]);
        i -= p;
    }
    if (dp[status] == inf) dp[status] = -1;
    return dp[status];
}

void run() {
    scanf("%d", &n);
    for (int i = 0; i < n; ++i)
        scanf("%d %d %d", &t[1 << i], &d[1 << i], &l[1 << i]);
    int full = (1 << n) - 1;
    for (int i = 0; i <= full; ++i) dp[i] = inf;
    dfs(full, 1);
    printf(dp[full] >= 0 ? "YES\n" : "NO\n");
}

int main() {
    scanf("%d", &T);
    while (T--) run();
}
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

---

试题 E: 接龙数列

时间限制: $1.0\mathrm{s}$ 内存限制: $256.0\mathrm{MB}$ 本题总分：$15$ 分

---

【问题描述】

  对于一个长度为 $K$ 的整数数列：$A_1,A_2,\cdots ,A_K$，我们称之为接龙数列当且仅当 $A_i$ 的首位数字恰好等于 $A_{i-1}$ 的末位数字 $(2\le i\le K)$。
  例如 $12,23,35,56,61,11$ 是接龙数列；$12,23,34,56$ 不是接龙数列，因为 $56$ 的首位数字不等于 $34$ 的末位数字。所有长度为 $1$ 的整数数列都是接龙数列。
  现在给定一个长度为 $N$ 的数列 $A_1,A_2,\cdots ,A_N$，请你计算最少从中删除多少个数，可以使剩下的序列是接龙序列？

【输入格式】

  第一行包含一个整数 $N$。
  第二行包含 $N$ 个整数 $A_1,A_2,\cdots ,A_N$。

【输出格式】

  一个整数代表答案。

【样例输入】

5
11 121 22 12 2023
1
2

【样例输出】

1
1

【样例说明】

  删除 $22$，剩余 $11,121,12,2023$ 是接龙数列。

【评测用例规模与约定】

  对于 $20\%$ 的数据，$1\le N\le 20$。
  对于 $50\%$ 的数据，$1\le N\le 10000$。
  对于 $100\%$ 的数据，$1\le N\le 10^5，1\le A_i\le 10^9$。所有 $A_i$ 保证不包含前导 $0$。

---

  令$d{p}_{i,d}$为$[1,i]$范围内构成的最长接龙序列以$d$结尾的长度，则有状态转移方程$d{p}_{i,d}=\max (d{p}_{i-1,d},d{p}_{i-1,b_i})$，其中$b_i$为$A_i$的首位数字，然后滚动数组优化下，根据序理论，答案为 N − max ⁡ { d p d } N-\max\{dp_d\} N−max{dpd​}。

#include <stdio.h>
#include <string.h>
#include <algorithm>

int n, ans, dp['9' + 1];

char a[18];

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        scanf("%s", &a);
        int last = a[strlen(a) - 1];
        dp[last] = std::max(dp[last], dp[a[0]] + 1);
    }
    for (int i = '1'; i <= '9'; ++i)
        ans = std::max(ans, dp[i]);
    printf("%d", n - ans);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

---

试题 F: 岛屿个数

时间限制: $2.0\mathrm{s}$ 内存限制: $256.0\mathrm{MB}$ 本题总分：$15$ 分

---

【问题描述】

  小蓝得到了一副大小为 $M\times N$ 的格子地图，可以将其视作一个只包含字符 $‘0’$（代表海水）和 $‘1’$（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上$/$下$/$左$/$右四个方向上相邻的 $‘1’$ 相连接而形成。
  在岛屿 $\mathrm{A}$ 所占据的格子中，如果可以从中选出 $k$ 个不同的格子，使得他们的坐标能够组成一个这样的排列：$(x0,y0),(x_1,y_1),...,(x_{k-1},y_{k-1})$，其中 $(x_{(i+1)\%k},y_{(i+1)\%k})$ 是由 $(x_i,y_i)$ 通过上$/$下$/$左$/$右移动一次得来的 $(0\le i\le k-1)$，此时这 $k$ 个格子就构成了一个 “环”。如果另一个岛屿 $\mathrm{B}$ 所占据的格子全部位于这个 “环” 内部，此时我们将岛屿 $\mathrm{B}$ 视作是岛屿 $\mathrm{A}$ 的子岛屿。若 $\mathrm{B}$ 是 $\mathrm{A}$ 的子岛屿，$\mathrm{C}$ 又是 $\mathrm{B}$ 的子岛屿，那 $\mathrm{C}$ 也是 $\mathrm{A}$ 的子岛屿。
  请问这个地图上共有多少个岛屿？在进行统计时不需要统计子岛屿的数目。

【输入格式】

  第一行一个整数 $T$，表示有 $T$ 组测试数据。
  接下来输入 $T$ 组数据。对于每组数据，第一行包含两个用空格分隔的整数 $M、N$ 表示地图大小；接下来输入 $M$ 行，每行包含 $N$ 个字符，字符只可能是 $‘0’$ 或 $‘1’$。

【输出格式】

  对于每组数据，输出一行，包含一个整数表示答案。

【样例输入】

2
5 5
01111
11001
10101
10001
11111
5 6
111111
100001
010101
100001
111111
1
2
3
4
5
6
7
8
9
10
11
12
13

【样例输出】

1
3
1
2

【样例说明】

  对于第一组数据，包含两个岛屿，下面用不同的数字进行了区分：
$01111$
$11001$
$10201$
$10001$
$11111$
  岛屿 $2$ 在岛屿 $1$ 的 “环” 内部，所以岛屿 $2$ 是岛屿 $1$ 的子岛屿，答案为 $1$。
  对于第二组数据，包含三个岛屿，下面用不同的数字进行了区分：
$111111$
$100001$
$020301$
$100001$
$111111$
  注意岛屿 $3$ 并不是岛屿 $1$ 或者岛屿 $2$ 的子岛屿，因为岛屿 $1$ 和岛屿 $2$ 中均没有“环”。

【评测用例规模与约定】

  对于 $30\%$ 的评测用例，$1\le M,N\le 10$。
  对于 $100\%$ 的评测用例，$1\le T\le 10，1\le M,N\le 50$。

---

bfs，先将公海标记出来，然后碰到内海直接当成陆地，注意海洋有八个方向可以扩散。

#include <stdio.h>

char map[66][66], inf = 0x7f;

int T, n, m, offset[]{ -1, 0, 0, 1, 1, 0, 0, -1, -1, -1, -1, 1, 1, 1, 1, -1 };

int h, t, X[2333], Y[2333];

void bfs(int x, int y, int a, int r) {
    X[0] = x, Y[0] = y, map[x][y] = inf;
    for (h = 0, t = 1; h != t;) {
        x = X[h], y = Y[h], ++h;
        for (int i = 0; i < r;) {
            int k = x + offset[i++], g = y + offset[i++];
            if (k < 0 || k >= n || y < 0 || y >= m) continue;
            if (map[k][g] <= a) {
                X[t] = k, Y[t] = g, ++t;
                map[k][g] = inf;
            }
        }
    }
}

void run() {
    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; ++i)
        scanf("%s", map[i]);
    for (int i = 0; i < n; ++i) {
        if (map[i][0] == '0') bfs(i, 0, '0', 16);
        if (map[i][m - 1] == '0') bfs(i, m - 1, '0', 16);
    }
    for (int i = 0; i < m; ++i) {
        if (map[0][i] == '0') bfs(0, i, '0', 16);
        if (map[n - 1][i] == '0') bfs(n - 1, i, '0', 16);
    }
    int ans = 0;
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j)
            if (map[i][j] == '1'){
                bfs(i, j, '1', 8);
                ++ans;
            }
    printf("%d\n", ans);
}

int main() {
    scanf("%d", &T);
    while (T--) run();
}
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

---

试题 G: 子串简写

时间限制: $1.0\mathrm{s}$ 内存限制: $256.0\mathrm{MB}$ 本题总分：$20$ 分

---

【问题描述】

  程序猿圈子里正在流行一种很新的简写方法：对于一个字符串，只保留首尾字符，将首尾字符之间的所有字符用这部分的长度代替。例如 $\mathrm{internation}$-$\mathrm{alization}$ 简写成 $i18n$，$\mathrm{Kubernetes}$ （注意连字符不是字符串的一部分）简写成 $K8s$，$\mathrm{Lanqiao}$ 简写成 $L5o$ 等。
  在本题中，我们规定长度大于等于 $K$ 的字符串都可以采用这种简写方法（长度小于 $K$ 的字符串不配使用这种简写）。
  给定一个字符串 $S$ 和两个字符 $c_1$ 和 $c_2$，请你计算 $S$ 有多少个以 $c_1$ 开头 $c_2$ 结尾的子串可以采用这种简写？

【输入格式】

  第一行包含一个整数 $K$。
  第二行包含一个字符串 $S$ 和两个字符 $c_1$ 和 $c_2$。

【输出格式】

  一个整数代表答案。

【样例输入】

4
abababdb a b
1
2

【样例输出】

6
1

【样例说明】

  符合条件的子串如下所示，中括号内是该子串：
$[\mathrm{abab}]\mathrm{abdb}$
$[\mathrm{ababab}]\mathrm{db}$
$[\mathrm{abababdb}]$
$\mathrm{ab}[\mathrm{abab}]\mathrm{db}$
$\mathrm{ab}[\mathrm{ababdb}]$
$\mathrm{abab}[\mathrm{abdb}]$

【评测用例规模与约定】

  对于 $20\%$ 的数据，$2\le K\le |S|\le 10000$。
  对于 $100\%$ 的数据，$2\le K\le |S|\le 5\times 10^5$。$S$ 只包含小写字母。$c_1$ 和 $c_2$ 都是小写字母。
  $|S|$ 代表字符串 $S$ 的长度。

---

  几乎裸一维dp，不是这题凭什么值20分啊。

#include <stdio.h>

char s[500023], &c1 = s[500010], &c2 = s[500020];

int i, k, dp[500010];

long long ans = 0;

int main() {
    scanf("%d\n%s %s %s", &k, s + 1, &c1, &c2);
    for (i = 1; s[i]; ++i) {
        if (s[i] == c1) dp[i] = 1;
        dp[i] += dp[i - 1];
    }
    while (--i >= k)
        if (s[i] == c2)
            ans += dp[i - k + 1];
    printf("%lld", ans);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

---

试题 H: 整数删除

时间限制: $1.0\mathrm{s}$ 内存限制: $256.0\mathrm{MB}$ 本题总分：$20$ 分

---

【问题描述】

  给定一个长度为 $N$ 的整数数列：$A_1,A_2,\cdots ,A_N$。你要重复以下操作 $K$ 次：
  每次选择数列中最小的整数（如果最小值不止一个，选择最靠前的），将其删除。并把与它相邻的整数加上被删除的数值。
  输出 $K$ 次操作后的序列。

【输入格式】

  第一行包含两个整数 $N$ 和 $K$。
  第二行包含 $N$ 个整数，$A_1,A_2,A_3,\cdots ,A_N$。

【输出格式】

  输出 $N-K$ 个整数，中间用一个空格隔开，代表 $K$ 次操作后的序列。

【样例输入】

5 3
1 4 2 8 7
1
2

【样例输出】

17 7
1

【样例说明】

  数列变化如下，中括号里的数是当次操作中被选择的数：
$[1]4287$
$5[2]87$
$[7]107$
$177$

【评测用例规模与约定】

  对于 $20\%$ 的数据，$1\le K<N\le 10000$。
  对于 $100\%$ 的数据，$1\le K<N\le 5\times 10^5，0\le A_i\le 10^8$。

---

?$1s$，$N$还开到$5e5$，出题人没什么大病吧
关键$A_i$对答案的贡献最差呈指数增加，实测答案范围可达$3.76e16$，这意味着我们无法用一个$64$位整形同时表示$A_i$和$i$，以减少比较所使用的时间，而且用优先队列模拟还要考虑数据过期问题，手搓二叉堆看看吧，什么*题。
当然可能存在更优的解法，但题目的表述已经很“自然”了，考虑贪心又涉及到“松弛”复杂度更差，反正我想不出来。
不过现代处理器寄存器都挺大了，不用在值传递，值分开传递，引用传递之间择优，基本上256位以内无脑值传递，别写的编译器看不懂就行。

#include <stdio.h>
#include <algorithm>

const int N = 5e5 + 6;

std::pair<long long, int> heap[N << 1];

int n, k, l[N], r[N];

long long a[N];

inline void sink(int x) {
    for (int k = x; (k = k << 1) <= n; x = k) {
        if (k < n && heap[k + 1] < heap[k]) ++k;
        if (heap[x] < heap[k]) break;
        std::swap(heap[x], heap[k]);
    }
}

int main() {
    scanf("%d %d", &n, &k);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &a[i]);
        heap[i] = {a[i], i};
        l[i] = i - 1;
        r[i] = i + 1;
    }
    r[0] = 1; r[n] = 0;
    for (int i = n / 2; i; --i) sink(i);
    for (; k--; sink(1)) {
        std::pair<long long, int> top = heap[1];
        if (a[top.second] != top.first) {
            heap[1].first = a[top.second], ++k;
        } else {
            heap[1] = heap[n--];
            l[r[top.second]] = l[top.second];
            r[l[top.second]] = r[top.second];
            a[l[top.second]] += top.first;
            a[r[top.second]] += top.first;
        }
    }
    for (int i = r[0]; i; i = r[i])
        printf("%lld ", a[i]);
}
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

对不起，常数小就是可以为所欲为的.jpg

---

试题  I: 景区导游

时间限制: $5.0\mathrm{s}$ 内存限制: $256.0\mathrm{MB}$ 本题总分：$25$ 分

---

【问题描述】

  某景区一共有 $N$ 个景点，编号 $1$ 到 $N$。景点之间共有 $N-1$ 条双向的摆渡车线路相连，形成一棵树状结构。在景点之间往返只能通过这些摆渡车进行，需要花费一定的时间。
  小明是这个景区的资深导游，他每天都要按固定顺序带客人游览其中 $K$ 个景点：$A_1,A_2,\cdots ,A_K$。今天由于时间原因，小明决定跳过其中一个景点，只带游客按顺序游览其中 $K-1$ 个景点。具体来说，如果小明选择跳过 $A_i$，那么他会按顺序带游客游览 $A_1,A_2,\cdots ,A_{i-1},A_{i+1},\cdots ,A_K,(1\le i\le K)$。
  请你对任意一个 $A_i$，计算如果跳过这个景点，小明需要花费多少时间在景点之间的摆渡车上？

【输入格式】

  第一行包含 $2$ 个整数 $N$ 和 $K$。
  以下 $N-1$ 行，每行包含 $3$ 个整数 $u,v$ 和 $t$，代表景点 $u$ 和 $v$ 之间有摆渡车线路，花费 $t$ 个单位时间。
  最后一行包含 $K$ 个整数 $A_1,A_2,\cdots ,A_K$ 代表原定游览线路。

【输出格式】

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

【样例输入】

6 4
1 2 1
1 3 1
3 4 2
3 5 2
4 6 3
2 6 5 1
1
2
3
4
5
6
7

【样例输出】

10 7 13 14
1

【样例说明】

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

【评测用例规模与约定】

  对于 $20\%$ 的数据，$2\le K\le N\le 10^2$。
  对于 $40\%$ 的数据，$2\le K\le N\le 10^4$。
  对于 $100\%$ 的数据，$2\le K\le N\le 10^5，1\le u,v,A_i\le N，1\le t\le 10^5$。保证 $A_i$ 两两不同。

---

lca模板题，记$dis{t}_{i,j}$为$i\to j$花费的时间，则第$i$个输出为${\sum }_{j=1}^{k-1}dis{t}_{A_j,A_{j+1}}-dis{t}_{A_{j-1},A_j}-dis{t}_{A_j,A_{j+1}}+dis{t}_{A_{j-1},A_{j+1}}$，将路线上序号差不超过$2$的路径用tarjan算出，然后代入计算就行。

#include <stdio.h>

const int N = 1e5 + 6;

int n, k, u, v, w, cur, a[N], f[N], q[N], head[N], next[6 * N], ver[6 * N], wei[6 * N];

long long l, r[N], t[N], ans[N << 1];

inline void link(int *g, int u, int v, int w) { next[++cur] = g[u], g[u] = cur, ver[cur] = v, wei[cur] = w; }

int find(int x) { return x == f[x] ? x : (f[x] = find(f[x])); }

void tarjan(int u) {
    f[u] = u;
    for (int i = head[u]; i; i = next[i])
        if (!f[ver[i]]) {
            t[ver[i]] = t[u] + wei[i];
            tarjan(ver[i]);
            f[ver[i]] = u;
        }
    for (int i = q[u]; i; i = next[i])
        if (f[ver[i]])
            ans[wei[i]] = t[u] + t[ver[i]] - 2 * t[find(ver[i])];
}

int main() {
    scanf("%d %d", &n, &k);
    for (int i = 1; i < n; ++i) {
        scanf("%d %d %d", &u, &v, &w);
        link(head, u, v, w);
        link(head, v, u, w);
    }
    for (int i = 1; i <= k; ++i) {
        scanf("%d", &a[i]);
        if (i > 1) {
            link(q, a[i], a[i - 1], i - 1);
            link(q, a[i - 1], a[i], i - 1);
        }
        if (i > 2) {
            link(q, a[i], a[i - 2], N + i - 2);
            link(q, a[i - 2], a[i], N + i - 2);
        }
    }
    int rand = (23333333 % n) + 1;
    tarjan(rand);
    for (int i = k - 1; i; --i)
        r[i] = r[i + 1] + ans[i];
    for (int i = 1; i <= k; ++i) {
        printf("%lld ", l + r[i + 1] + ans[N + i - 1]);
        l += ans[i - 1];
    }
}
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

---

试题 J: 砍树

时间限制: $1.0\mathrm{s}$ 内存限制: $256.0\mathrm{MB}$ 本题总分：$25$ 分

---

【问题描述】

  给定一棵由 $n$ 个结点组成的树以及 $m$ 个不重复的无序数对 $(a_1,b_1),(a_2,b_2),\cdots ,(a_m,b_m)$，其中 $a_i$ 互不相同，$b_i$ 互不相同，$a_i,b_j(1\le i,j\le m)$。
  小明想知道是否能够选择一条树上的边砍断，使得对于每个 $(a_i,b_i)$ 满足 $a_i$ 和 $b_i$ 不连通，如果可以则输出应该断掉的边的编号（编号按输入顺序从 $1$ 开始），否则输出 $-1$。

【输入格式】

  输入共 $n+m$ 行，第一行为两个正整数 $n，m$。
  后面 $n-1$ 行，每行两个正整数 $x_i，y_i$ 表示第 $i$ 条边的两个端点。
  后面 $m$ 行，每行两个正整数 $a_i，b_i$。

【输出格式】

  一行一个整数，表示答案，如有多个答案，输出编号最大的一个。

【样例输入】

6 2
1 2
2 3
4 3
2 5
6 5
3 6
4 5
1
2
3
4
5
6
7
8

【样例输出】

4
1

【样例说明】

  断开第 $2$ 条边后形成两个连通块： { 3 , 4 } ， { 1 , 2 , 5 , 6 } \{3, 4\}，\{1, 2, 5, 6\} {3,4}，{1,2,5,6}，满足 $3$ 和 $6$ 不连通，$4$ 和 $5$ 不连通。
  断开第 $4$ 条边后形成两个连通块： { 1 , 2 , 3 , 4 } ， { 5 , 6 } \{1, 2, 3, 4\}，\{5, 6\} {1,2,3,4}，{5,6}，同样满足 $3$ 和 $6$ 不连通，$4$ 和 $5$ 不连通。
  $4$ 编号更大，因此答案为 $4$。

【评测用例规模与约定】

  对于 $30\%$ 的数据，保证 $1<n\le 1000$。
  对于 $100\%$ 的数据，保证 $1<n\le 10^5，1\le m\le \frac{n}{2}$。

---

刚开始没看出来是裸差分，想的是从入度为$0$的节点遍历，经过哪条边就模拟拿掉，然后树被拆成两颗，也就是节点被划分为两个集合，所以这也是不断将某个节点加入集合的过程，对于加入集合的节点我们将它关联的二元组设一个权值并加一，然后统计总权值，总权值到$m$并且没有二元权值大于$1$则当前边是一个备选答案，然后迭代出最大。
这种做法的好处是题目无解可以提前跳出，复杂度下界比较优，但既然现在想通了就按树上差分去写，人就是突出一个懒。

#include <stdio.h>

const int N = 1e5 + 6;

int n, m, u, v, cur = 1, val[N], f[N], q[N], head[N], next[3 * N], ver[3 * N];

inline void link(int *g, int u, int v) { next[++cur] = g[u], g[u] = cur, ver[cur] = v; }

int find(int x) { return x == f[x] ? x : (f[x] = find(f[x])); }

void tarjan(int u) {
    f[u] = u;
    for (int i = head[u]; i; i = next[i])
        if (!f[ver[i]]) {
            tarjan(ver[i]);
            f[ver[i]] = u;
        }
    for (int i = q[u]; i; i = next[i])
        if (f[ver[i]]) {
            val[u]++;
            val[ver[i]]++;
            val[find(ver[i])] -= 2;
            ver[i] = ver[i ^ 1] = 0;
        }
}

void dfs(int u, int r) {
    f[u] = r;
    for (int i = head[u]; i; i = next[i])
        if (ver[i] != r) {
            f[ver[i]] = u;
            dfs(ver[i], u);
            val[u] += val[ver[i]];
        }
}

int main() {
    scanf("%d %d", &n, &m);
    for (int i = 1; i < n; ++i) {
        scanf("%d %d", &u, &v);
        link(head, u, v);
        link(head, v, u);
    }
    for (int i = 1; i <= m; ++i) {
        scanf("%d %d", &u, &v);
        link(q, u, v);
        link(q, v, u);
    }
    int rand = (23333333 % n) + 1;
    tarjan(rand);
    dfs(rand, rand);
    cur = -2;
    for (int i = 1; i <= n; ++i)
        for (int x = head[i]; x; x = next[x])
            if (f[i] == ver[x]){
                if (val[i] == m && cur < x) cur = x;
            } else {
                if (val[ver[x]] == m && cur < x) cur = x;
            }
    printf("%d", cur >> 1);
}
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