GESP25年9月编程题解析

原创已于 2025-10-09 15:11:26 修改 · 1.2k 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #数据结构

于 2025-09-30 19:07:06 首次发布

GESP 专栏收录该内容

2 篇文章

订阅专栏

一级

商店折扣

题目描述

商店正在开展促销活动，给出了两种方案的折扣优惠。第一种方案是购物满 $x$ 元减 $y$ 元；第二种方案是直接打 $n$ 折，也就是说价格变为原先的 $n /10$ 。这里的 $x, y, n$ 均是正整数，并且 $\leq y < x$ ， $\leq n < 10$ 。

需要注意的是，第一种方案中满减优惠只能使用一次。例如购物满 $10$ 元减 $3$ 元时，若挑选了价格总和为 $33$ 元的物品，只能减免 $3$ 元，需要支付 $30$ 元。

小明在商店挑选了价格总和为 $p$ 元的物品，结账时只能使用一种优惠方案。小明最少需要支付多少钱呢？

输入格式

四行，四个正整数 $x, y, n, p$ ，含义见题目描述。

输出格式

一行，一个小数，表示小明最少需要支付多少钱，保留两位小数。

输入输出样例 #1

输入 #1

输出 #1

3.00

输入输出样例 #2

输入 #2

输出 #2

2.20

说明/提示

对于所有测试点，保证 $\leq y < x \leq 100$ ， $\leq n < 10$ ， $\leq p \leq 100$ 。

题目解析

#include <iostream>
using namespace std;
int main()
{
    int x,y,n;
    cin >> x >> y >> n;  // 读取满减门槛 x、减免金额 y、折扣 n
    double p;
    cin >> p;  // 读取商品总价 p
    double ans1 = p;  // 存储第一种方案的支付金额，初始为原价
    double ans2 = p;  // 存储第二种方案的支付金额，初始为原价
    if(ans1 >= x)ans1 -= y;  // 若满足满减条件，应用第一种方案（满 x 减 y）
    ans2 = ans2 * n / 10;  // 应用第二种方案（打 n 折，即乘以 n / 10）
    if(ans1 < ans2)printf("%.2lf",ans1);  // 比较两种方案，输出较少的支付金额（保留两位小数）
    else printf("%.2lf",ans2);
    return 0;
}

金字塔

题目描述

金字塔由 $n$ 层石块垒成。从塔底向上，每层依次需要 $\times n, (n-1) \times (n-1), \cdots, 2 \times 2, 1 \times 1$ 块石块。请问搭建金字塔总共需要多少块石块？

输入格式

一行，一个正整数 $n$ ，表示金字塔的层数。

输出格式

一行，一个正整数，表示搭建金字塔所需的石块数量。

输入输出样例 #1

输入 #1

输出 #1

输入输出样例 #2

输入 #2

输出 #2

说明/提示

对于所有测试点，保证 $\leq n \leq 50$ 。

题目解析

#include <iostream>
using namespace std;
int main()
{
    int n;
    cin >> n;  // 读取输入的金字塔层数 n
    int ans = 0;  // 定义变量 ans 用于存储总石块数，初始化为 0
    // 从第 n 层开始向下计算到第 1 层，累加每层的石块数
    for(int i = n;i >= 1;i -- )ans += i * i;
    cout << ans << endl;  // 输出总石块数
    return 0;
}

二级

优美的数字

题目描述

如果一个正整数在十进制下的所有数位都相同，小 A 就会觉得这个正整数很优美。例如，正整数 $6$ 的数位都是 $6$ ，所以 $6$ 是优美的。正整数 $99$ 的数位都是 $9$ ，所以 $99$ 是优美的。正整数 $123$ 的数位不都相同，所以 $123$ 并不优美。

小 A 想知道不超过 $n$ 的正整数中有多少优美的数字。你能帮他数一数吗？

输入格式

一行，一个正整数 $n$ 。

输出格式

一行，一个正整数，表示不超过 $n$ 的优美正整数的数量。

输入输出样例 #1

输入 #1

输出 #1

输入输出样例 #2

输入 #2

输出 #2

说明/提示

对于所有测试点，保证 $\leq n \leq 2025$ 。

题目解析

#include <iostream>
using namespace std;
int main()
{
    int n;
    cin >> n;
    int ans = 0;
    for(int i = 1;i <= n;i ++ )
    {
        int t = i;
        int vis = t % 10;
        int flag = 1;
        while(t > 0)
        {
            int num = t % 10;
            if(num != vis)
            {
                flag = 0;
                break;
            }
            t /= 10;
        }
        if(flag)ans ++ ;
    }
    cout << ans << endl;
    return 0;
}

菱形

题目描述

小 A 想绘制一个菱形。具体来说，需要绘制的菱形是一个 $n$ 行 $n$ 列的字符画， $n$ 是一个大于 $1$ 的奇数。菱形的四个顶点依次位于第 $1$ 行、第 $1$ 列、第 $n$ 行、第 $n$ 列的正中间，使用 # 绘制。相邻顶点之间也用 # 连接。其余位置都是 .。

例如，一个 $5$ 行 $5$ 列的菱形字符画是这样的：

..#..
.#.#.
#...#
.#.#.
..#..

给定 $n$ ，请你帮小 A 绘制对应的菱形。

输入格式

一行，一个正整数 $n$ 。

输出格式

输出共 $n$ 行，表示对应的菱形。

输入输出样例 #1

输入 #1

输出 #1

.#.
#.#
.#.

输入输出样例 #2

输入 #2

输出 #2

....#....
...#.#...
..#...#..
.#.....#.
#.......#
.#.....#.
..#...#..
...#.#...
....#....

说明/提示

对于所有测试点，保证 $\leq n \leq 29$ 并且 $n$ 为奇数。

题目解析

解题思路：

老套的打印图形，有点意思，图形打印分为上下两半部分，即区间 $[1, (n + 1) /2]$ 和 $[(n + 1) /2, n]$ 。对于每行的打印，可以进行分类讨论：

$n u m 1$ 为首先输出的 . 的个数
$n u m 2$ 为输出的 # 的个数
- $mi d$ 为 # 之间需要填充的 . 的个数
- 若是其值大于 2，则需要使用 $mi d$ 填充， $n u m 2$ 置为 2
$n u m 3$ 为最后输出的 . 的个数

#include <iostream>
using namespace std;
int main()
{
    int n;
    cin >> n;
    for(int i = 1;i <= n;i ++ )
    {
        if(i <= (n + 1) / 2)
        {
            int num1 = (n + 1) / 2 - i;
            int num3 = num1;
            int num2 = n - num1 - num3;
            int mid = 0;
            if(num2 > 2)
            {
                mid = num2 - 2;
                num2 = 2;
            }
            for(int j = 1;j <= num1;j ++ )cout << ".";
            if(num2 == 1)cout << "#";
            else 
            {
                cout << "#";
                for(int j = 1;j <= mid;j ++ )cout << ".";
                cout << "#";
            }
            for(int j = 1;j <= num3;j ++ )cout << ".";
            cout << endl;
        }
        else 
        {
            int num1 = i - (n + 1) / 2;
            int num3 = num1;
            int num2 = n - num1 - num3;
            int mid = 0;
            if(num2 > 2)
            {
                mid = num2 - 2;
                num2 = 2;
            }
            for(int j = 1;j <= num1;j ++ )cout << ".";
            if(num2 == 1)cout << "#";
            else 
            {
                cout << "#";
                for(int j = 1;j <= mid;j ++ )cout << ".";
                cout << "#";
            }
            for(int j = 1;j <= num3;j ++ )cout << ".";
            cout << endl; 
        }
    }
    return 0;
}

三级

日历制作

题目描述

小 A 想制作 $2025$ 年每个月的日历。他希望你能编写一个程序，按照格式输出给定月份的日历。

具体来说，第一行需要输出 MON TUE WED THU FRI SAT SUN，分别表示星期一到星期日。接下来若干行中依次输出这个月所包含的日期，日期的个位需要和对应星期几的缩写最后一个字母对齐。例如， $2025$ 年 $9$ 月 $1$ 日是星期一，在输出九月的日历时， $1$ 号的个位 $1$ 就需要与星期一 MON 的最后一个字母 N 对齐。九月的日历输出效果如下:

MON TUE WED THU FRI SAT SUN
  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

你能帮助小 A 完成日历的制作吗?

输入格式

一行，一个正整数 $m$ ，表示需要按照格式输出 $2025$ 年 $m$ 月的日历。

输出格式

输出包含若干行，表示 $2025$ 年 $m$ 月的日历。

输入输出样例 #1

输入 #1

输出 #1

MON TUE WED THU FRI SAT SUN
  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

输入输出样例 #2

输入 #2

输出 #2

MON TUE WED THU FRI SAT SUN
                          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

说明/提示

对于所有测试点，保证 $\leq m \leq 12$ 。

题目解析

解题思路：

点开电脑的日历…就能看到每月的第一天是星期几
a 数组存储每月的第一天是星期几
b 数组存储每月有多少天，不用判断闰年，2025 是平年
输入日历
- 输出日历表头
- 对空的天数进行输出
- 根据 b 数组对应每月天数，结合 idx 进行换行、num 进行输出

#include <iostream>
using namespace std;
int main()
{
    int m;
    cin >> m;
    int a[13] = {0,3,6,6,2,4,7,2,5,1,3,6,1};
    int b[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
    cout << "MON TUE WED THU FRI SAT SUN" << endl;
    int num = 1;
    for(int i = 1;i <= a[m] - 1;i ++ )printf("    ");
    int idx = a[m];
    while(num <= b[m])
    {
        if(idx > 7)
        {
            cout << endl;
            idx = 1;
        }
        printf("%3d ",num);
        num ++ ;
        idx ++ ;
    }
    return 0;
}

数组清零

题目描述

小 A 有一个由 $n$ 个非负整数构成的数组 $[a_1, a_2, \ldots, a_n]$ 。他会对阵组 $a$ 重复进行以下操作，直到数组 $a$ 只包含 0。在一次操作中，小 A 会依次完成以下三个步骤：

在数组 $a$ 中找到最大的整数，记其下标为 $k$ 。如果有多个最大值，那么选择其中下标最大的。
从数组 $a$ 所有不为零的整数中找到最小的整数 $a_j$ 。
将第一步找出的 $a_k$ 减去 $a_j$ 。

例如，数组 $a = [2, 3, 4]$ 需要 7 次操作变成 $[0, 0, 0]$ ：

$\rightarrow [2, 3, 2] \rightarrow [2, 1, 2] \rightarrow [2, 1, 1] \rightarrow [1, 1, 1] \rightarrow [1, 1, 0] \rightarrow [1, 0, 0] \rightarrow [0, 0, 0]$

小 A 想知道，对于给定的数组 $a$ ，需要多少次操作才能使得 $a$ 中的整数全部变成 0。可以证明， $a$ 中整数必然可以在有限次操作后全部变成 0。你能帮他计算出答案吗？

输入格式

第一行，一个正整数 $n$ ，表示数组 $a$ 的长度。

第二行， $n$ 个非负整数 $a1,a2,…,ana_1, a_2, \ldots, a_n$ ，表示数组 $a$ 中的整数。

输出格式

一行，一个正整数，表示 $a$ 中整数全部变成 0 所需要的操作次数。

输入输出样例 #1

输入 #1

3
2 3 4

输出 #1

输入输出样例 #2

输入 #2

5
1 3 2 2 5

输出 #2

说明/提示

对于所有测试点，保证 $\leq n \leq 100$ ， $\leq a_i \leq 100$ 。

题目解析

#include <iostream>
using namespace std;
const int N = 2e6 + 10;
int a[N];
int main()
{
    int n;
    cin >> n;
    for(int i = 1;i <= n;i ++ )cin >> a[i];
    int cnt = 0;
    while(1)
    {
        int flag = 1;
        for(int i = 1;i <= n;i ++ )
        {
            if(a[i] != 0)
            {
                flag = 0;
                break;
            }
        }
        if(flag)break;
        int maxidx = -1,minidx = -1;
        int maxnum = -0x3f3f3f3f,minnum = 0x3f3f3f3f;
        for(int i = 1;i <= n;i ++ )
        {
            if(a[i] >= maxnum)
            {
                maxnum = a[i];
                maxidx = i;
            }
            if(a[i] < minnum && a[i] != 0)
            {
                minnum = a[i];
                minidx = i;
            }
        }
        a[maxidx] -= a[minidx];
        cnt ++ ;
    }
    cout << cnt << endl;
    return 0;
}

四级

排兵布阵

题目描述

作为将军，你自然需要合理地排兵布阵。地图可以视为 $n$ 行 $m$ 列的网格，适合排兵的网格以 1 标注，不适合排兵的网格以 0 标注。现在你需要在地图上选择一个矩形区域排兵，这个矩形区域内不能包含不适合排兵的网格。请问可选择的矩形区域最多能包含多少网格？

输入格式

第一行，两个正整数 $n, m$ ，分别表示地图网格的行数与列数。

接下来 $n$ 行，每行 $m$ 个整数 $ai,1,ai,2,…,ai,ma_{i,1}, a_{i,2}, \ldots, a_{i,m}$ ，表示各行中的网格是否适合排兵。

输出格式

一行，一个整数，表示适合排兵的矩形区域包含的最大网格数。

输入输出样例 #1

输入 #1

输出 #1

输入输出样例 #2

输入 #2

输出 #2

说明/提示

对于所有测试点，保证 $\leq n, m \leq 12$ ， $\leq a_{i,j} \leq 1$ 。

题目解析

#include <iostream>
using namespace std;
const int N = 5050;
int a[N][N];
int judge(int x,int y,int dx,int dy)
{
    int cnt = 0;
    for(int i = x;i <= x + dx;i ++ )
    {
        for(int j = y;j <= y + dy;j ++ )
        {
            if(a[i][j] == 0)return -1;
            else cnt ++ ;
        }
    }
    return cnt;
}
int main()
{
    int n,m;
    cin >> n >> m;
    for(int i = 1;i <= n;i ++ )
    {
        for(int j = 1;j <= m;j ++ )
        {
            cin >> a[i][j];
        }
    }
    int ans = 0;
    for(int x = 1;x <= n;x ++ )
    {
        for(int y = 1;y <= m;y ++ )
        {
            for(int dx = 0;x + dx <= n;dx ++ )
            {
                for(int dy = 0;y + dy <= m;dy ++ )
                {
                    ans = max(ans,judge(x,y,dx,dy));
                }
            }
        }
    }
    cout << ans << endl;
    return 0;
}

最长连续段

题目描述

对于 $k$ 个整数构成的数组 $[b1,b2,…,bk][b_1, b_2, \ldots, b_k]$ ，如果对 $\leq i < k$ 都有 $b_{i+1} = b_i + 1$ ，那么称数组 $b$ 是一个连续段。

给定由 $n$ 个整数构成的数组 $[a1,a2,…,an][a_1, a_2, \ldots, a_n]$ ，你可以任意重排数组 $a$ 中元素顺序。请问在重排顺序之后， $a$ 所有是连续段的子数组中，最长的子数组长度是多少？

例如，对于数组 $[1, 0, 2, 4]$ ，可以将其重排为 $[4, 0, 1, 2]$ ，有以下 $10$ 个子数组：

$[4], [0], [1], [2], [4, 0], [0, 1], [1, 2], [4, 0, 1], [0, 1, 2], [4, 0, 1, 2]$

其中除 $[4, 0], [4, 0, 1], [4, 0, 1, 2]$ 以外的子数组均是连续段，因此是连续段的子数组中，最长子数组长度为 3。

输入格式

第一行，一个正整数 $n$ ，表示数组长度。

第二行， $n$ 个整数 $a1,a2,…,ana_1, a_2, \ldots, a_n$ ，表示数组中的整数。

输出格式

一行，一个整数，表示数组 $a$ 重排顺序后，所有是连续段的子数组的最长长度。

输入输出样例 #1

输入 #1

4
1 0 2 4

输出 #1

输入输出样例 #2

输入 #2

9
9 9 8 2 4 4 3 5 3

输出 #2

说明/提示

对于 $40%40\%$ 的测试点，保证 $\leq n \leq 8$ 。

对于所有测试点，保证 $\leq n \leq 10^5$ ， $−109≤ai≤109-10^9 \leq a_i \leq 10^9$ 。

题目解析

解题思路：

对数组排序然后去重
对遍历去重后的区间使用双指针即可

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 2e6 + 10;
int a[N];
int main()
{
    int n;
    cin >> n;
    for(int i = 1;i <= n;i ++ )cin >> a[i];
    sort(a + 1,a + 1 + n);
    int tail = unique(a + 1,a + 1 + n) - a - 1;
    int ans = 0;
    for(int i = 1;i <= tail;i ++ )
    {
        int j = i + 1;
        while(j <= tail && a[j] - a[j - 1] == 1)j ++ ;
        ans = max(ans, j - i);
        i = j - 1;
    }
    cout << ans << endl;
    return 0;
}

五级

有趣的数字和

题目背景

为保证只有时间复杂度合理的算法通过本题，本题时限下调。

题目描述

如果一个正整数的二进制表示包含奇数个 $1$ ，那么小 A 就会认为这个正整数是有趣的。

例如， $7$ 的二进制表示为 $111)_2$ ，包含 $1$ 的个数为 $3$ 个，所以 $7$ 是有趣的。但是 $9=(1001)_2$ 包含 $2$ 个 $1$ ，所以 $9$ 不是有趣的。

给定正整数 $l, r$ ，请你统计满足 $l≤n≤rl\le n\le r$ 的有趣的整数 $n$ 之和。

输入格式

一行，两个正整数 $l, r$ ，表示给定的正整数。

输出格式

一行，一个正整数，表示 $l, r$ 之间有趣的整数之和。

输入输出样例 #1

输入 #1

3 8

输出 #1

输入输出样例 #2

输入 #2

65 36248

输出 #2

328505490

说明/提示

【数据范围】

对于 $40%40\%$ 的测试点，保证 $1≤l≤r≤1041\le l\le r\le 10^4$ 。

对于另外 $30%30\%$ 的测试点，保证 $l = 1$ 并且 $r=2^k-1$ ，其中 $k$ 是大于 $1$ 的正整数。

对于所有测试点，保证 $\le l\le r\le 10^9$ 。

【提示】

由于本题的数据范围较大，整数类型请使用 long long。

题目解析

本题解在洛谷时限下调前后都可AC。

我们发现，对于连续的四个数字，其中必定有两个奇数，两个偶数，因此我们可以把整个数轴按照区间长度为 4 来进行讨论，通过打表能够更直观的看到该规律，打表代码如下：

#include <iostream>
#define int long long
using namespace std;
signed main()
{
    int idx = 0;
    // 部分打表
    for(int i = 0;i <= 31;i ++ )
    {
        int t = i;
        int cnt = 0;
        while(t > 0)
        {
            if(t & 1)cnt ++ ;
            t >>= 1;
        }
        idx ++ ;
        if(cnt & 1)cout << i << " " << "符合条件" << endl;
        else cout << i << endl;
        if(idx == 4)
        {
            cout << endl;
            idx = 0;
        }
    }
    return 0;
}

打表结果：

0
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 符合条件

对于每个长度为 4 的区间，我们可以对其离散化编号，将 $l$ 和 $r$ 的坐标 / 4 即可得到区间编号，我们把区间编号从 0 开始，那么第 $n$ 个区间对应的范围也就是 $[n \times 4, n \times 4 + 3]$ 。在这里我们把 $n u m 1$ 即为 $l$ 所处的区间编号， $n u m 2$ 即为 $r$ 所处的区间编号，对于每个合理的区间，我们来进行分类讨论：

若是该区间完全被 $[l, r]$ 覆盖，我们称之为全覆盖区间，合法区间范围为 $[n u m 1 + 1, n u m 2 - 1]$ ，其有效计入答案值为两端数字之和 / 中间两个数字之和，由于两端数字之和 = 中间两个数字之和，**因此在这里，我们对全覆盖区间的有效答案求和就可以简单记为两端数字之和。**即： $((i \times 4) + (i \times 4 + 3))$ 。
对于没有被 $[l, r]$ 全覆盖的区间，我们称之为半覆盖区间：
- 若是 $l$ 所在的半覆盖区间和 r 所在的半覆盖区间属于同一区间，那么我们暴力枚举区间 $[l, r]$ 即可
- 若是 $l$ 和 $r$ 所在区间不同，我们需要对区间 $[l, n u m 1 \times 4 + 3]$ 和 $[n u m 2 \times 4, r]$ 进行暴力枚举
最终答案即为全覆盖区间的有效答案 + 半覆盖区间的有效答案

由此，我们可以用 $O (1)$ 时间复杂度来解决这个问题：

#include <iostream>
#define int long long
using namespace std;
signed main()
{
    int l,r;
    cin >> l >> r;
    int num1 = l / 4;
    int num2 = r / 4;
    int ans = 0;
    if(num1 == num2)
    {
        for(int i = l;i <= r;i ++ )
        {
            int t = i;
            int cnt = 0;
            while(t > 0)
            {
                if(t & 1)cnt ++ ;
                t /= 2;
            }
            if(cnt & 1)ans += i;
        }
    }
    else 
    {
        for(int i = l;i <= num1 * 4 + 3;i ++ )
        {
            int t = i;
            int cnt = 0;
            while(t > 0)
            {
                if(t & 1)cnt ++ ;
                t /= 2;
            }
            if(cnt & 1)ans += i;
        }
        for(int i = num2 * 4;i <= r;i ++ )
        {
            int t = i;
            int cnt = 0;
            while(t > 0)
            {
                if(t & 1)cnt ++ ;
                t >>= 1;
            }
            if(cnt & 1)ans += i;
        }
    }
    for(int i = num1 + 1;i <= num2 - 1;i ++ )
    {
        ans += ((i * 4) + (i * 4 + 3));
    }
    cout << ans << endl;
    return 0;
}

数字选取

题目描述

给定正整数 $n$ ，现在有 $1,2,…,n1,2,\ldots,n$ 共计 $n$ 个整数。你需要从这 $n$ 个整数中选取一些整数，使得所选取的整数中任意两个不同的整数均互质（也就是说，这两个整数的最大公因数为 $1$ ）。请你最大化所选取整数的数量。

例如，当 $n = 9$ 时，可以选择 $1, 5, 7, 8, 9$ 共计 $5$ 个整数。可以验证不存在数量更多的选取整数的方案。

输入格式

一行，一个正整数 $n$ ，表示给定的正整数。

输出格式

一行，一个正整数，表示所选取整数的最大数量。

输入输出样例 #1

输入 #1

输出 #1

输入输出样例 #2

输入 #2

输出 #2

说明/提示

对于 $40%40\%$ 的测试点，保证 $1≤n≤10001\le n\le 1000$ 。

对于所有测试点，保证 $1≤n≤1051\le n\le 10^5$ 。

题目解析

解题思路：

1 肯定要作为答案加入
奇质数要作为答案加入
但凡 $\ge 2$ ，证明一定存在 2 的幂次方，从 2 的幂次方中选取一个数作为答案加入

#include <iostream>
using namespace std;
const int N = 2e6 + 10;
// 埃氏筛法模板
int primes[N];
int st[N];
int idx = 0;
// 返回奇质数的个数
int get_primes(int n)
{
    for(int i = 2;i <= n;i ++ )
    {
        if(!st[i])primes[idx ++ ] = i;
        for(int j = i;j <= n;j += i)st[j] = true;
    }
    int cnt = 0;
    for(int i = 0;i < idx;i ++ )
    {
        if(primes[i] & 1)cnt ++ ;
    }
    return cnt;
}
int main()
{
    int n;
    cin >> n;
    int ans = 1 + get_primes(n);
    // 若是 n >= 2，则一定存在 2 的幂次方
    if(n >= 2)ans ++ ;
    cout << ans << endl;
    return 0;
}

六级

货物运输

题目描述

A 国有 $n$ 座城市，依次以 $1,2,…,n1,2,\ldots,n$ 编号，其中 $1$ 号城市为首都。这 $n$ 座城市由 $n - 1$ 条双向道路连接，第 $i$ 条道路（ $\le i < n$ ）连接编号为 $u_i,v_i$ 的两座城市，道路长度为 $l_i$ 。任意两座城市间均可通过双向道路到达。

现在 A 国需要从首都向各个城市运送货物。具体来说，满载货物的车队会从首都开出，经过一座城市时将对应的货物送出，因此车队需要经过所有城市。A 国希望你设计一条路线，在从首都出发经过所有城市的前提下，最小化经过的道路长度总和。注意一座城市可以经过多次，车队最后可以不返回首都。

输入格式

第一行，一个正整数 $n$ ，表示 A 国的城市数量。

接下来 $n - 1$ 行，每行三个正整数 $u_i,v_i,l_i$ ，表示一条双向道路连接编号为 $u_i,v_i$ 的两座城市，道路长度为 $l_i$ 。

输出格式

一行，一个整数，表示你设计的路线所经过的道路长度总和。

输入输出样例 #1

输入 #1

输出 #1

输入输出样例 #2

输入 #2

输出 #2

说明/提示

对于 $30%30\%$ 的测试点，保证 $\le n \le 8$ 。

对于另外 $30%30\%$ 的测试点，保证仅与一条双向道路连接的城市恰有两座。

对于所有测试点，保证 $\le n \le 10^5$ ， $\le u_i,v_i \le n$ ， $\le l_i \le 10^9$ 。

树是一个无环图，对于树的遍历我们可以使用贪心，为了使答案最小化，有着如下策略：

对于根到叶子节点的最大路径，我们只需要遍历一次
对于其他路径，我们需要遍历两次
sum 计算路径长度总和，maxl 记录从叶节点到根的最大路径长度
答案即为 sum * 2 - maxl
这道题目一定要开 long long

#include <iostream>
#include <cstring>
#define int long long
using namespace std;
const int N = 2e6 + 10;
// 邻接表建树
int e[N],ne[N],h[N],w[N],vis[N],idx;
// 初始化从叶节点到根节点的最长路径和树的路径长度总和
int maxl = -0x3f3f3f3f,sum = 0;
void init()
{
    memset(h,-1,sizeof(h));
    idx = 0;
}
void add(int a,int b,int c)
{
    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx ++ ;
}
// 搜索最长路径
void dfs(int u,int len)
{
    for(int i = h[u];i != -1;i = ne[i])
    {
        int j = e[i];
        if(!vis[j])
        {
            // 无回溯搜索
            vis[j] = true;
            dfs(j,len + w[i]);
        }
    }
    maxl = max(maxl,len);
}
signed main()
{
    init();
    int n;
    cin >> n;
    for(int i = 1;i <= n - 1;i ++ )
    {
        int a,b,c;
        cin >> a >> b >> c; 
        add(a,b,c);
        add(b,a,c);
        sum += c;
    }
    // 对根节点进行标记再进行搜索
    vis[1] = true;
    dfs(1,0);
    cout << sum * 2 - maxl << endl;
    return 0;
}

划分字符串

题目描述

小 A 有一个由 $n$ 个小写字母组成的字符串 $s$ 。他希望将 $s$ 划分为若干个子串，使得子串中每个字母至多出现一次。例如，对于字符串 street 来说，str + e + e + t 是满足条件的划分；而 s + tree + t 不是，因为子串 tree 中 e 出现了两次。

额外地，小 A 还给出了价值 $a1,a2,…,ana_1,a_2,\ldots,a_n$ ，表示划分后长度为 $i$ 的子串价值为 $a_i$ 。小 A 希望最大化划分后得到的子串价值之和。你能帮他求出划分后子串价值之和的最大值吗？

输入格式

第一行，一个正整数 $n$ ，表示字符串的长度。

第二行，一个包含 $n$ 个小写字母的字符串 $s$ 。

第三行， $n$ 个正整数 $a1,a2,…,ana_1,a_2,\ldots,a_n$ ，表示不同长度的子串价值。

输出格式

一行，一个整数，表示划分后子串价值之和的最大值。

输入输出样例 #1

输入 #1

6
street
2 1 7 4 3 3

输出 #1

输入输出样例 #2

输入 #2

8
blossoms
1 1 2 3 5 8 13 21

输出 #2

说明/提示

对于 $40%40\%$ 的测试点，保证 $1≤n≤1031\le n\le 10^3$ 。

对于所有测试点，保证 $1≤n≤1051\le n\le 10^5$ ， $1≤ai≤1091\le a_i\le 10^9$ 。

题目解析

划分出的每个子串中，每个小写字母至多出现 1 次，要求子串价值之和最大。价值规则是长度为 $k$ 的子串，价值为 $a [k]$ ，我们用 $d p [i]$ 表示 “处理完字符串的前 $i$ 个字符时，能得到的最大价值之和”。

初始化 $d p [i]$ 为 0
初始化 $v i s [26]$ 为 $f a l se$
遍历 $k$ 从 1 到 26
- 先判断边界：若 $i - k < 0$ ，直接 break
- 找到子串的左端点索引： $i d x = i - k$
- 检查字符 $s [i d x]$ 是否在 $v i s$ 中：
  - 若已存在：break
  - 若不存在：标记 $v i s [s [i d x] -^{'} a^{'}] = t r u e$ ，计算 $d p [i - k] + a [k]$ ，用该值更新 $d p [i]$
遍历结束后， $d p [i]$ 就是前 $i$ 个字符的最大价值和

#include <iostream>
#define int long long  
using namespace std;
const int N = 1e5 + 10;  
int a[N], dp[N];
string s;
signed main() 
{
    int n;
    cin >> n;  
    cin >> s;  
    for(int i = 1;i <= n;i ++ )cin >> a[i];  
    dp[0] = 0;  
    // 计算前i个字符的最大价值和
    for(int i = 1;i <= n;i ++ ) 
    {
        dp[i] = 0;  // 初始化当前最大价值和为0
        bool vis[26];  // 记录当前子串中出现的字符
        for(int j = 0;j < 26;j ++ )vis[j] = false; 
        // 尝试以i为结尾的子串，长度k从1到26，子串为s[idx..i-1]
        for(int k = 1;k <= 26;k ++ ) 
        {
            if(i - k < 0)break; 
            int idx = i - k;  
            char c = s[idx];  
            if(vis[c - 'a'])break; 
            vis[c - 'a'] = true; 
            dp[i] = max(dp[i], dp[i - k] + a[k]);
        }
    }
    
    cout << dp[n] << endl;  
    return 0;
}