2021 程序设计训练 on cyp0633's Blog

CCF CSP 202109 @ HNU 游记

Sun, 19 Sep 2021 00:00:00 +0000

此处所指的是大学组的CSP，举行于2021年9月19日。

暴力出奇迹，骗分过样例。

暴搜挂着机，打表出省一。

NOIP名言

又是一年CSP时，抱着当年OI攒下的一点点老本，以 “过150就算赢” 为目标，本着暴力出奇迹的原则，参加了学校统一组织的考试。

关于考场

考场在湖南大学前进楼机房，设备可以说是很有年代感了。目测17寸左右的低分辨率显示器，2C2T的Pentium E5700 CPU，Windows 7，再搭配上Orwell Dev-C++ 5.11，整个简直像是上个时代的产物。由于远古的TDM-GCC 4.9.2、调用STL时的糟糕体验和层出不穷的bug，每次用Dev-C++ 调试，我都想打人…… 如果觉得Visual Studio Code不开源，哪怕装个VSCodium也好啊……

哦，顺便提一嘴，Orwell Dev-C++ 是有正统续作的，由Embarcadero开发，终于能用了：

Embarcadero/Dev-Cpp

Java环境好像也没有IntelliJ IDEA，Python好像也只能用IDLE，所以C++ 环境也不算差？

还行啦，CPU再烂也是独占的，起码比信息院机房的瘦客户机好用多了。

第一题

逐个输入，每个数都加入最大值，遇到比上个数大的就加进和的最小值。画图好理解。

第二题

先试了暴力方法，$p$ 从 $1$ 到 $10000$ 循环（没必要也千万不要把数改成 $0$），直接统计大于 $p$ 的数的区间数，70分，TLE三个点。

然后尝试搜索的思路，类似于暴力思路的改进，仍然是搜索大于p的区间数，但不会搜索整个数组，而是在上一个p所划分的区间内搜索。比如1 3 5 3 6 0 2 8，$p=1$ 时划出1 3 5 3 6和2 8，然后分别在这两个区间内继续搜索 $p=2$ 的情况即可。

误以为区间数是随 $p$ 先上升后下降的，试图用BFS控制搜索深度，幸亏BFS手生，没写完就发现并不是我想的那样（狗头保命），遂停止。

换用熟悉的DFS，结果仍然TLE三个点。原因是每次搜索，$p$ 的步进都是 $1$；事实上，仍然使用上个例子，$p=2$ 得到区间3 5 3 6，区间最小值是3，那么 $p=3$ 的区间数 + 1，然后直接搜索 $p=4$ 的情况即可，不必再搜索3的情况。

DFS优化完成后可以达到100分。

第三题

阅读理解越来越难了，做完前面的还剩2小时左右，估计读都读不完。

没做。

第四题

骗得20分。有20% 的数据，每个卡的爆率相同，易得期望就是 $n$。

还有20分比较简单，不知道为啥暴搜没过，5个牌还会T，真是……

第五题

瞄了一眼，似乎需要可持久化的数据结构，但有一个点没有操作2，也许可以暴力存储历史数据。即便如此还是没写出来，放弃了。

总结

暴搜流派yyds！

湖南大学 2021 程序设计训练笔记 - 作业训练 4

Mon, 06 Sep 2021 00:00:00 +0000

所有代码均已上传至 homework/CSP-Training at master · cyp0633/homework (github.com)。不保证代码均正确，正确的也不保证为最优解，可以查看Commit详情进一步了解。如无说明均用C++ 实现。

1. 在霍格沃茨找零钱

个人难度评级：2

问题描述

如果你是哈利 · 波特迷，你会知道魔法世界有它自己的货币系统 —— 就如海格告诉哈利的：“十七个银西可 (Sickle) 兑一个加隆 (Galleon)，二十九个纳特(Knut) 兑一个西可，很容易。”现在，给定哈利应付的价钱 $P$ 和他实付的钱 $A$，你的任务是写一个程序来计算他应该被找的零钱。

输入形式

输入在 $1$ 行中分别给出 $P$ 和 $A$，格式为 “Galleon.Sickle.Knut”，其间用 $1$ 个空格分隔。这里Galleon是 $[0, 10^7]$ 区间内的整数，Sickle是 $[0, 17)$ 区间内的整数，Knut是 $[0, 29)$ 区间内的整数。

输出形式

在一行中用与输入同样的格式输出哈利应该被找的零钱。如果他没带够钱，那么输出的应该是负数。

样例输入1

10.16.27 14.1.28

样例输出1

3.2.1

样例输入2

14.1.28 10.16.27

样例输出2

-3.2.1

解题思路

建议不要全部化为Knut再计算，直接对应相减然后借位即可。

本题一个坑，没带够钱的情况下，输出的数只有Galleon位有负号，实际上的意思是三个数都有负号，后面两个不需要输出。也就是说，” 样例输出2“的意义是找回 - 3 Galleon, -2 Sickle和 - 1 Knut。我建议的处理方式是，如果在借位之前最高位是负值，则将每一位取相反数，并输出一个负号，然后照常借位计算。

2. 最简单的计算机

个人难度评级：1

问题描述

一个名叫是 $PigHeadThree$ 的研究组织设计了一台实验用的计算机，命名为 $PpMm$。$PpMm$ 只能执行简单的六种命令 $A$，$B$，$C$，$D$，$E$，$F$；只有二个内存 $M1$，$M2$；三个寄存器 $R1$，$R2$，$R3$。六种命令的含义如下：
命令 $A$：将内存 $M1$ 的数据装到寄存器 $R1$ 中；
命令 $B$：将内存 $M2$ 的数据装到寄存器 $R2$ 中；
命令 $C$：将寄存器 $R3$ 的数据装到内存 $M1$ 中；
命令 $D$：将寄存器 $R3$ 的数据装到内存 $M2$ 中；
命令 $E$：将寄存器 $R1$ 中的数据和寄存器 $R2$ 中的数据相加，结果放到寄存器 $R3$ 中；
命令 $F$：将寄存器 $R1$ 中的数据和寄存器 $R2$ 中的数据相减，结果放到寄存器 $R3$ 中。
你的任务是：设计一个程序模拟 $PpMm$ 的运行。

输入形式

有若干组，每组有 $2$ 行，第一行是 $2$ 个整数，分别表示 $M1$ 和 $M2$ 中的初始内容；第二行是一串长度不超过 $200$ 的由大写字母 $A$ 到 $F$ 组成的命令串，命令串的含义如上所述。

输出形式

对应每一组的输入，输出只有一行，二个整数，分别表示 $M1$，$M2$ 的内容；其中 $M1$ 和 $M2$ 之间用逗号隔开。

样例输入

100 288
ABECED
876356 321456
ABECAEDBECAF

样例输出

388,388
2717080,1519268

解题思路

果然是最简单的…… 什么，你不会switch语句都不会用吧？

3. 相同生日

个人难度评级：2

问题描述

在一个有 $n$ 个人的大班级中，存在两个人生日相同的概率非常大，现给出每个学生的学号，出生月日，试找出所有生日相同的学生。

输入形式

第一行为整数 $n$，表示有 $n$ 个学生，$n \le 200$。此后每行包含一个字符串和两个整数，分别表示学生的学号 (字符串长度为 $11$ 位) 和出生月 $(1 \le m \le 12)$ 日 $(1 \le d \le 31)$，学号、月、日之间用一个空格分隔。

输出形式

对每组生日相同的学生，输出一行，其中前两个数字表示月和日，后面跟着所有在当天出生的学生的学号，数字、学号之间都用一个空格分隔。对所有的输出，要求按日期从前到后的顺序输出。对生日相同的学号，按输入的顺序输出。

样例输入

6
07101020105 3 15
07101020115 4 5
07101020118 3 15
07101020108 4 5
07101020111 4 5
07101020121 8 10

样例输出

3 15 07101020105 07101020118
4 5 07101020115 07101020108 07101020111
8 10 07101020121

解题思路

建立 vector<string> birthday[13][32]，然后将对应生日的同学之间 push_back 进对应日期的 vector 即可。要求同日期按输入顺序输出，不需 priority_queue 之类。虽学号是数字但不能直接用 long long，当然你输出保留11位，前面补0也可以，主要就是前导0的问题。

4. 日历问题

个人难度评级：3

问题描述

在我们现在使用的日历中, 闰年被定义为能被 $4$ 整除的年份，但是能被 $100$ 整除而不能被 $400$ 整除的年是例外，它们不是闰年。例如：$1700$, $1800$, $1900$ 和 $2100$ 不是闰年，而 $1600$, $2000$ 和 $2400$ 是闰年。给定从公元 $2000$ 年 $1$ 月 $1$ 日开始逝去的天数，你的任务是给出这一天是哪年哪月哪日星期几。

输入形式

输入包含若干行，每行包含一个正整数，表示从 $2000$ 年 $1$ 月 $1$ 日开始逝去的天数。输入最后一行是 $-1$, 不必处理。可以假设结果的年份不会超过 $9999$。

输出形式

对每个测试样例，输出一行，该行包含对应的日期和星期几。格式为 “YYYY-MM-DD DayOfWeek”, 其中 “DayOfWeek” 必须是下面中的一个： “Sunday”, “Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday” and “Saturday“。

样例输入

样例输出

2004-09-26 Sunday
2004-10-06 Wednesday
2004-10-16 Saturday
2004-10-17 Sunday

解题思路

这个题结合代码看得更明白。

打表，建立五个数组，内容如下：

$[2000,9999]$ 年范围内，每一年的最后一天是1999年12月31号之后的第几天，即只需计算每年天数的前缀和；
$[2000,9999]$ 年范围内，每一年是否是闰年（这个不要用 true 或者 false 表示，否则代码会超过100KB而无法提交）；
闰年中，每一个月的最后一天是上一年12月31日之后第几天，即每个月天数的前缀和；
平年中，同上；
天数模7，每个余数所对应最后日期的星期，第1个值不是 Monday 也不是 Sunday，而是 Saturday（2000/01/01就是周六，过7的倍数天还是周六）。

首先模7算完星期之后，要将输入的天数 + 1，转换为”2000年1月1日起的第几天 “。

然后枚举第一个数组，如果某个年份（减2000）对应的值大于等于天数，则该年份就是所求日期年份。从天数中减掉数组中上一年对应的值（2000年不用），得到所求日期是这一年的第几天。如果天数减为0，则赋给它本年天数值（当然，直接输出12月31日也未尝不可）。

分是否闰年，枚举第三 / 四个数组，以和上面相似的方式确定月份。自然也就很容易得到日期。

格式化输出中，使用 %02d，输出整型并在不足2位的时候补0。

5. 小希的数表

个人难度评级：4

问题描述

Gardon昨天给小希布置了一道作业，即根据一张由不超过 $5000$ 的 $N$ $(3 \le N \le 100)$ 个正整数组成的数表两两相加得到 $N*(N-1)/2$ 个和，然后再将它们排序。例如，如果数表里含有四个数 $1$，$3$，$4$，$9$，那么正确答案是 $4$，$5$，$7$，$10$，$12$，$13$。小希做完作业以后出去玩了一阵，可是下午回家时发现原来的那张数表不见了，好在她做出的答案还在，你能帮助她根据她的答案计算出原来的数表么？

输入形式

包含多组数据，每组数据以一个 $N$ 开头，接下来的一行有按照大小顺序排列的 $N*(N-1)/2$ 个数，是小希完成的答案。文件最后以一个 $0$ 结束。
假设输入保证解的存在性和唯一性。

输出形式

对于每组数据，输出原来的数表。它们也应当是按照顺序排列的。

样例输入

4
4 5 7 10 12 13
4
5 6 7 8 9 10
0

样例输出

1 3 4 9
2 3 4 6

解题思路

设 $a$ 为原数字列表，$s$ 为和的列表。

首先，由于 $s_i$ 和 $a_i$ 是从小到大排列的，反证法易证 $s_1=a_1+a_2$，$s_2=a_1+a_3$。然而 $s_3$ 并不一定是 $a_2+a_3$，而很可能是 $a_1+a_4$ 等。由此，我们需要枚举 $s_3$ 到 $s_{(n-1)*n/2}$，对于每一个 $s_i$，结合 $s_1$ 和 $s_2$，解出 $a_1$、$a_2$ 和 $a_3$，当它们均为正整数的时候才可能符合条件，能够往下进行。符合这里条件的 $a_2+a+_3$ 可能有多组，可能在后续步骤中会毙掉几组。

然后，我们只需要找出 $s_j=a_1+a_i$，就可以算出 $a_i$。因为 $a_1$ 最小，所以 $s_j$ 排在较靠前的位置，比较好找。比如现在我们要找 $a_1+a_4$，如果将 $a_1$、$a_2$ 和 $a_3$ 两两组合算出和，然后将这些和从 $s$ 中剔除，那么可以证明 $a_1+a_4$ 就是剩下的当中最小的一个和，也就能比较容易地从 $s$ 中找出。当然，仍然要检验 $a_4$ 乃至后面所有的 $a_i$ 是不是正整数。

现在我们找到了 $a_4$，那么该怎么找到 $a_5$ 乃至后面的数呢？我们可以仿照前面的方法，将前面已求出的数两两组合求和，将结果存入一个 set 中（毕竟剔除工作比较复杂）。在遍历每个 $s$ 的时候，如果 $s_i$ 的值处在该set中，则跳过。否则，这个值就是 $a_1+a_{j}$，$j$ 是已经确定的 $a$ 数量。然后，将这个 $a_j$ 分别与前面的 $a$ 相加，存入set，就可以及时维护这个set。

所有 $a$ 的值都确定完成，你以为就得出解了吗？早着呢，这样你会WA掉测试点3、4、5、6和7。刚刚我们所求出的这套解，并不一定能满足题目的条件，也就是加出后面的和。既然已经假定所有的 $a$ 已经解出并符合题目要求，那么set中理应出现测试数据给出的所有的 $s_i$。继续遍历，对后面的每一个 $s_i$，都查找它是否在set中。如果不在，那么这组 $a$ 就不是符合条件的解，再取一个 $a_2+a_3$ 吧……

你兴致勃勃地将代码交了上去，发现只解决了7。不同的 $a_i+a_j$ 组合可以得出相同的两个 $s$ 值。这时候再用set就明显不合适了，可以考虑使用同一个键值允许出现多次的set——multiset，同时将已经在 $s$ 中出现的和删除。很容易想到使用multiset的 erase 函数处理，但这个函数有多个重载，如果传入一个键值，它会删除该键值的 ** 所有 ** 元素。而如果传入一个指针 / 迭代器，就只会删除指向的这一个元素。我们的需求是出现一次删除一次，那当然要传入迭代器。

6. 数塔

个人难度评级：2

问题描述

给定一个数塔，如下图所示。在此数塔中，从顶部出发，在每一节点可以选择走左下或右下，一直走到底层。请找出一条路径，使路径上的数值和最大。

				9
			12		15
		10		6		8
	2		18		9		5
19		7		10		4		16

输入形式

输入时第一行一个整数 $n$，表示该数塔的行数，其余 $n$ 行表示该塔每行的数值

输出形式

输出包含两行，第一行为最大路径上的数值之和，第二行 $n$ 个数字为从上而下最大路径数值

样例输入

5
9
12 15
10 6 8
2 18 9 5
19 7 10 4 16

样例输出

59
9 12 10 18 10

解题思路

一道标准的搜索题，可以DFS也可以BFS，搜索过程中传递行号、列号、当前路径长度和用vector存储的完整路径。

7. 斯诺克台球（不做了）

个人难度评级：6

问题描述

斯诺克台球是一项古老而又时尚的运动，使用长方形球桌，台面四角以及两长边中心位置各有一个球袋，使用的球分为1个白球，15个红球和6个彩球共22个球。

其中母球（白球）1只，目标球21只。目标球中：红球15只各1分、黄球1只2分、绿球1只3分、咖啡球1只4分、蓝球1只5分、粉球1只6分、黑球1只7分。

选手需要使用球杆撞击母球去击打目标球来完成得分，每局开始时总是先从红球开始。击球顺序为先打进红球（每次击打允许多个红球同时落袋），然后必须任意指定一个目标彩球击打，如果该彩球被打进（打进后需要再摆回），然后接着击打红球，直到红球全部落袋，然后以黄、绿、咖啡、蓝、粉红、黑的顺序逐个击球（不再摆回），最后以得分高者为胜。任何时候红球落袋都不再摆回，任何时候因犯规导致彩球落袋，彩球必须摆回。

斯诺克比赛由双方轮流击打，必须击打合规的目标球，打进则本方得到相应的分数并继续击打，未打进或犯规轮换为对方击打，未打进不得分，犯规将进行罚分处理。

犯规规则如下：

1. 当击打目标球时，如果先击打到或同时击打到一个或多个其他颜色的球，或者有其他颜色的球落袋，或者打空 (未击打到任何球)，则视为犯规。此时需要比较目标球的分值和与本犯规相关的其他颜色的球的分值，取其中最高的分值，如果该分值小于4，则对方加4分，否则对方加该分值。

2. 当击打红球落袋后，继续击打任意彩球时打空，即未打击到任何球，对方加4分。

相比正式的斯诺克比赛，本问题对规则进行了简化，任何时候都可以结束比赛并计算比赛结果，不考虑白球落袋的情况。

信息化时代的智能台球桌能自动记录实际比赛时的击打记录，并传送到后台，但该记录仅仅是流水记录，并且无参赛选手的任何信息，需要你编程计算每场比赛的比分，同时需要计算单杆100分及以上的情况（单杆得分是指选手一次连续击打所得分数之和）。

输入形式

输入第一行为正整数 $t$ $(t \le 100)$，表示有 $t$ 组测试数据，每组数据代表一局比赛。

在输入中，球的颜色表示为：

**r - 红色球 y - 黄色球 g - 绿色球 c - 咖啡色球 b - 蓝色球 p - 粉红球 B - 黑色球 **

接下来的每组数据包括若干行，每一行为一次击打的结果，为智能球桌记录下来的流水记录，每组数据最后一行为 - 1，表示每组数据的结束。

流水记录包含用空格分隔的2个部分：

首先撞到的球落袋球及数量

第一部分 “首先撞到的球” 为一个字符串，可以是 “rygcbpB” 中1个或多个字符组合（可能有多个字符 “r”）, 或为字符串“$NULL$”。为“$NULL$” 时，第二部分必为空，表示该次击打未撞击到任何球也没有任何球落袋。当红球落袋后继续击打任意彩球时，该部分为 “ygcbpB” 中的任意单个字符时都认为是合规的目标球。

第二部分 “落袋球及数量” 为一个字符串，例如“r2gb”，代表本次击打有两个红球落袋，以及绿球和篮球落袋，红色球r后面有数字（大于 $0$ 小于 $16$），表示红球的落袋数，其他彩球后无数字。该部分可以为空，表示本次击打无球落袋。

比赛在 $A$ 与 $B$ 之间进行，每局比赛总是由 $A$ 先开球。

输出形式

输出为 $t+1$ 行，前 $t$ 行每行输出用冒号分隔的两个整数，表示每局比赛 $A$ 与 $B$ 之间的比分；最后一行输出用冒号分隔的两个整数，表示 $t$ 局比赛之后 $A$ 与 $B$ 之间获得的单杆 $100$ 分及以上的次数之比（单杆得分是指选手一次连续击打所得分数之和）。

样例输入

3
r r1
B
r r2
c c
r r1
b g
-1
rp r1
r br2B
NULL
r r12
y y
g p
-1
rr r3
NULL
r r1
yg y
-1

样例输出

6:7
13:24
7:5
0:0

样例说明

第一局比赛：

A击打红球，打进1个红球，得1分，比分为1:0

A继续击打任意彩球，打到黑球，未打进，不得分，比分为1:0

轮换为B击打红球，打进两个红球，得2分，比分为1:2

B继续击打任意彩球，打到咖啡球，打进咖啡球，咖啡球摆回，得4分，比分为1:6

B继续击打红球，打进一个红球，得1分，比分为1:7

B继续击打任意彩球，打到蓝球，打进绿球，犯规，取分值最大者蓝球，绿球摆回，对方加5分，比分为6:7

-1比赛结束

第二局比赛：

A击打红球，首先打到红球和粉球，犯规，打进1个红球和咖啡球，犯规，咖啡球摆回，取分值最大的粉球，对方加6分，比分为0:6

B击打红球，首先打到红球，打进蓝球、2个红球和黑球，犯规，蓝球和黑球摆回，取分值最大的黑球，对方加7分，比分为7:6

A击打红球，未打到任何球，犯规，对方加4分，比分为7:10

B击打红球，打到红球，打进12个红球，加12分，比分为7:22

B击打任意彩球，打到黄球，打进黄球，黄球摆回，得2分，比分为7:24

B击打黄球，打到绿球，打进粉球，犯规，粉球摆回，对方加6分，比分为13:24

-1比赛结束

第三局比赛：

A击打红球，打到2个红球，打进3个红球，加3分，比分为3:0

A击打任意彩球，打空，未打到任何球，对方加4分，比分为3:4

B击打红球，打到1个红球，打进1个红球，加1分，比分为3:5

B击打任意彩球，打到黄球和绿球，打进黄球，犯规，黄球摆回，取分值最高的绿球，绿球分值小于4，对方加4分，比分为7:5

-1比赛结束

3局比赛中无人单杆得分过100，最后一行输出0:0

解题思路

大模拟做他🐎呢，笑死，根本做不出来😅

8. 最少钱币数

个人难度评级：4

问题描述

这是一个古老而又经典的问题。用给定的几种钱币凑成某个钱数，一般而言有多种方式。例如：给定了6种钱币面值为2、5、10、20、50、100，用来凑15元，可以用5个2元、1个5元，或者3个5元，或者1个5元、1个10元，等等。显然，最少需要2个钱币才能凑成15元。
你的任务就是，给定若干个互不相同的钱币面值，编程计算，最少需要多少个钱币才能凑成某个给出的钱数。

输入形式

输入可以有多个测试用例。每个测试用例的第一行是待凑的钱数值 $M$ $(1 \le M \le 2000，整数)$，接着的一行中，第一个整数 $K$ $(1 \le K \le 10)$ 表示币种个数，随后是 $K$ 个互不相同的钱币面值 $K_i$ $(1 \le K_i \le 1000)$。输入 $M=0$ 时结束。

输出形式

每个测试用例输出一行，即凑成钱数值 $M$ 最少需要的钱币个数。如果凑钱失败，输出 “Impossible”。你可以假设，每种待凑钱币的数量是无限多的。

样例输入

156 2 5 10 20 50 10011 20

样例输出

2Impossible

解题思路

DP题，有点像完全背包。参考了最少钱币数（DP）_Salmon_lee 的博客 - CSDN 博客。

这道题的最优子结构性质是，可以先得出用前 $i$ 种面值得出 $j$ 元以内的最少钱币数。使用前 $i$ 种面值组合成 $j$ 元的最少钱币数，是 “使用前 $i-1$ 种面值组合成 $j$ 元的最少钱币数” 与“使用前 $i$ 种面值组合成 $j-val$ 元的最少钱币数 + 1，$val$ 为第 $j$ 种钱币的面值”的较小值，即状态转移方程：$dp_{i,j}=min(dp_{i-1,j},dp_{i,j-val})$。两层循环，第一层循环遍历各种面值的钱币，第二层循环遍历各种金额，均为从前往后遍历。二维DP示例代码在这里。

那么可不可以压缩成一维呢？自然可以，将前i种面值的这一维压掉。状态转移方程变为 $dp_i=min(dp_i,dp_{i-val})$。

注意多组数据，dp数组需要memset多次。

9. 相等的多项式

个人难度评级：2

问题描述

小明现在在学习多项式的展开：就是把一个形如

$(x+a_1)(x+a_2)…(x+a_n)$

展开成如下形式：

$x^n+b_1x^{n-1}+b_2x^{n-2}+…+b_{n-1}x+b_n$

比如 $(x+1)(x+2)=x^2+3x+2$

$(x+1)^3=x^3+3x^2+3x+1$

小明做了很多练习，但是不知道对错，现在请求你的帮助，判断小明的展开式是否正确。

输入格式

有多组测试数据。

每组测试数据有三行，第一行是一个正整数 $N$，表示多项式最高指数。$N=0$ 表示输入结束，并且不需要处理。

第二行N个整数ai，用空格隔开，$i=1，…,N(-100 \le a_i \le 100)$

第三行N个整数bi，用空格隔开，$i=1，…,N，(-10^9 \le b_i \le 10^9)$

40% 的测试数据 $1 \le N < 5$；

30% 的测试数据 $5 \le N < 10$；

20% 的测试数据 $10 \le N < 15$；

10% 的测试数据1$5 \le N \le 20$；

输出格式

　　对于每组测试数据，输出一行一个字符‘Y’ 如果展开式是正确的，输出‘N’如果展开式错误。

样例输入

样例输出

Y
Y
N

解题思路

如果还记得二项式定理，这道题会好做很多。使用DFS，对每个因式分别选择乘上字母或者数字，边界条件为选择完所有因式，此时将该次数的因子加到结果多项式的数组对应项即可。

题目输入的多项式是按次数由大到小排的，由 $n-1$ 到 $0$，而我们乘出的多项式数组应该反向与它比较。

10. 选美比赛

个人难度评级：1

问题描述

在选美大奖赛的半决赛现场，有 $n$ 名选手 $(2<n<100)$ 参加比赛。比赛结束时，要在现场按照选手的出场顺序宣布最后名次，获得相同分数的选手具有相同的名次，名次连续编号，不用考虑同名次的选手人数。如：

选手数量： 7

选手得分： 5，3，4，7，3，5，6

宣布名次： 3，5，4，1，5，3，2

请编程帮助大奖赛组委会完成半决赛的评分排名工作。

输入形式

选手数量：7

选手得分：5 3 4 7 3 5 6

输出形式

选手的排名：3 5 4 1 5 3 2

样例输入

7
5 3 4 7 3 5 6

样例输出

3 5 4 1 5 3 2

样例说明

本题的关键在于如何处理同分数的选手排名问题

解题思路

用结构体存储选手，内含编号、得分和排名三个成员变量。

输入得分顺便指定编号，按照得分降序sort一遍，赋给排名（注意：即使有多个第 $n$ 名并列，排在这些后面的仍然是 $n+1$ 名），然后再按照编号升序sort，输出即可。

11. 蛇行矩阵

个人难度评级：2

问题描述

蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形

输入形式

正整数N表示层数，N不大于100

输出形式

输出一个N行的蛇形矩阵，矩阵三角中同一行的数字用一个空格分开，行尾不要多余的空格。

样例输入

样例输出

1 3 6 10 152 5 9 144 8 137 1211

解题思路

首先构建第一列。容易观察得到，上下相邻的两个值有关系 $a_{i,1}=a_{i-1,1}+i-1 (2 \le i \le n)$。要是我还在上高中，也许能算出通项公式，但现在不一定了

然后对于每一行，根据第一列构建剩下的列，根据关系 $a_{i,j}=a_{i,j-1}+i+j-1(1 \le i \le n, 2 \le j \le n-i+1)$。

没必要真按照蛇形去构建，按照上面的方法可以直接打个表交上去，虽然完整的重新构建也不会超时就是了。

12. 疫情期间

个人难度评级：3 | TLE了测试点1

问题描述

正值新冠疫情期间，阿迪没法返回学校学习，他希望通过参加一些比赛来提高一下编程技能，同时做做运动。他收集了接下来的 $n$ 天里每一天的信息，包括健身房是否开放，或者互联网上是否有程序设计竞赛。

第 $i$ 天可以有以下四种情况之一：

该天健身房不开放，互联网上也没有竞赛
该天健身房不开放，但互联网上有竞赛
该天健身房开放，但互联网上没有竞赛
该天健身房开放，互联网上也有竞赛

每天阿迪要么休息，要么编写程序（如果该天有竞赛），要么做运动（如果该天健身房开放）。

现在有一个限制条件：不能连续两天都去做运动，或者连续两天都编写程序。阿迪对自己要求很高，希望尽量多写程序或者多做运动，使得休息的天数尽量最少，求出这个天数。

输入形式

输入的第一行为一个正整数 $n(1 \le n \le 100)$，表示接下来的天数。

第二行为一个用空格分隔的整数序列 $a_1$、$a_2$、…、$a_n$ $(0 \le a_i \le 3)$，这里

$a_i=0$，第 $i$ 天健身房不开放，互联网上也没有竞赛
$a_i=1$，第 $i$ 天健身房不开放，但互联网上有竞赛
$a_i=2$，第 $i$ 天健身房开放，但互联网上没有竞赛
$a_i=3$，第 $i$ 天健身房开放，互联网上也有竞赛

输出形式

输入阿迪可能休息的最小天数。注意限制条件：

不能连续两天去做运动
不能连续两天编写程序

样例输入1

4
1 3 2 0

样例输出1

样例输入2

7
1 3 3 2 1 2 3

样例输出2

样例输入3

2
2 2

样例输出3

样例说明

在第一个样例中，阿迪在第一天编写程序，在第三天做运动，因此他仅有两天可以休息。

在第二个样例中，阿迪可以在第1、3、5、7天编写程序，其他天做运动，因此没有哪天休息。

在第三个样例中，阿迪可以在第1天或第2天做运动，但不能连续两天运动，因此他有一天休息。

解题思路

暴搜90分。DFS传入天数、休息次数和上一天的行为，分为编程、运动和休息三种情况即可。

其实90分也不错了，对吧？

13.7，还是7

个人难度评级：1

问题描述

输出7和7的倍数，还有包含7的数字例如（17，27，37…70，71，72，73…）

输入形式

一个正整数 $N$。($N$ 不大于 $30000$)

输出形式

从小到大排列的不大于N的与7有关的正整数，每行一个。

样例输入

样例输出

解题思路

可以结合 to_string 和字符串 find 函数来找包含7的数字。

14. 组个最小数

个人难度评级：1

问题描述

给定数字0-9各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意0不能做首位）。例如：给定两个0，两个1，三个5，一个8，我们得到的最小的数就是10015558。

现给定数字，请编写程序输出能够组成的最小的数。

输入形式

每个输入包含1个测试用例。每个测试用例在一行中给出多个（不超过50个）数字（0~9之间），整数间用一个空格分隔，且至少拥有1个非0的数字。

输出形式

在一行中输出能够组成的最小的数。

样例输入

2 2 0 0 0 3 0 0 1 0

样例输出

1000000223

解题思路

输入时统计每个数出现次数，先输出一个非零数，然后剩下的从小到大输出。

15. 字频统计

个人难度评级：2

问题描述

在一个只有字母’a’ 和’b’ 组成的字符串中，统计子串 “ab” 和 “ba” 出现次数的差。

输入格式

有多组测试数据。

每组测试数据第一行是一个正整数 $N$，表示字符串长度，接下来一行是长度为 $N$ 的字符串，字符串中只有字母’a’ 和’b’。

$N=0$ 表示输入结束，并且不需要处理。

$40%$ 的数列元素个数 $N$ $1 \le N \le 100$；

$30%$ 的数列元素个数 $N$ $1 \le N \le 1000$；

$20%$ 的数列元素个数 $N$ $1 \le N \le 10000$；

$10%$ 的数列元素个数 $N$ $1 \le N \le 100000$；

输出格式

　　对于每组测试数据，输出一个整数：“ab” 和 “ba” 出现次数的差。

样例输入

7
aaaaaaa
4
abab
0

样例输出

0
1

解题思路

这个似乎用不了字符串的 find 成员函数，那就自己写呗。每个字符串遍历两遍，找就行了。

16. 逆序数

个人难度评级：1

问题描述

在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序。一个排列中逆序的总数就称为这个排列的逆序数。也就是说，对于 $n$ 个不同的元素，先规定各元素之间有一个标准次序（例如 $n$ 个不同的自然数，可规定从小到大为标准次序），于是在这 $n$ 个元素的任一排列中，当某两个元素的先后次序与标准次序不同时，就说有 $1$ 个逆序。一个排列中所有逆序总数叫做这个排列的逆序数。

比如：

数列1 7 3 5 4 8 9

其中 $(7,3)$，$(7,5)$，$(7,4)$，$(5,4)$ 构成逆序，所以其逆序数为 $4$。

对给定的数列，求出其逆序数。

输入格式

有多组测试数据。

每组测试数据第一行是一个正整数 $N$，表示数列中元素个数，接下来一行 $N$ 个用空格分隔开的正整数，表示数列的 $N$ 个元素，数列元素值小于 $32768$，并且一个数列中没有两个数值相同。

$N=0$ 表示输入结束，并且不需要处理。

$40%$ 的数列元素个数 $N$ $1 \le N \le 10$；

$30%$ 的数列元素个数 $N$ $1 \le N \le 100$；

$20%$ 的数列元素个数 $N$ $1 \le N \le 1000$；

$10%$ 的数列元素个数 $N$ $1 \le N \le 5000$；

输出格式

　　对于每组测试数据，输出一个整数：数列的逆序数。

样例输入

7
1 7 3 5 4 8 9
4
1 2 3 4
0

样例输出

4
0

解题思路

两层循环枚举组合解决。

17. 最小钱币数（贪心算法）

个人难度评级：1

问题描述

阿迪有很多钱。他在银行里有n元。出于安全考虑，他想用现金取款（此处不透露原因）。钞票的面额是1，5，10，20，100元。取出全部余额后能收到的最小钞票数是多少？

输入形式

输入一个正整数 $n$，$(1 \le n \le 10^9)$

输出形式

阿迪能收到的最小钞票数

样例输入1

样例输出1

样例输入2

样例输出2

样例输入3

1000000000

样例输出3

10000000

样例说明

本题可以直接使用贪心策略（优先尽可能多选择大面额的钞票）解决：主要原因是后一个的权值（这里就是纸币面值）是前一个的2倍或以上。

可以思考一下如果货币的类型是1,9,10元三种，要求凑出18元，你可能就会发现贪心算法出错了！

解题思路

上面说得这么明白了我还说啥啊，这题没了DP就没了灵魂了。

18. 身份证校验

个人难度评级：1

问题描述

我国国标〖GB 11643-1999〗中规定：公民身份号码是18位特征组合码，由十七位数字本体码和一位数字校验码组成。排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。其校验码 (最后一位) 计算方法和步骤为：

(1) 十七位数字本体码加权求和公式

$S = sum(A_i * W_i), i = 0, … , 16$ ，先对前17位数字的权求和

其中 $A_i$：表示第i位置上的身份证号码数字值

$W_i$：表示第i位置上的加权因子，前17位加权因子从左到右分别为

$W_i$：7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2

(2) 计算模

$Y = mod(S, 11)$

(3) 通过模Y查下表得到对应的校验码

$Y$	0	1	2	3	4	5	6	7	8	9	10
校验码	1	0	X	9	8	7	6	5	4	3	2

例如：某身份证前17位为11010519491231002

$i$	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17
$W_i$	7	9	10	5	8	4	2	1	6	3	7	9	10	5	8	4	2
	1	1	0	1	0	5	1	9	4	9	1	2	3	1	0	0	2
积	7	9	0	5	0	20	2	9	24	27	7	18	30	5	0	0	4

得到和为：167；则模为 $y=167%11=2$

查 (3) 得校验码为X（大写）

请按上面所述步骤编程，输入一个二代身份证号，检查该身份证是否正确。

输入形式

输入若干行，每行一个身份证号码，最后一行输入 - 1

输出形式

输出1代表正确，0代表错误

样例输入

120223198902021249
130132199210293822
130402198207290622
-1

样例输出

1
1
0

解题思路

如果会用 std::map，可以将校验码和余数对应，很方便。写一堆if倒也不是不能做。

18. 最长递增子序列

个人难度评级：2

问题描述

给出一个由 $n$ 个正整数组成的数组。您的任务是找到给定数组的递增子数组的最大长度。

递增子数组由数组中若干个连续元素组成，且子数组中的每个元素严格地大于前一个元素。

输入形式

第一行为一个正整数 $n(1 \le n \le 10^5)$，表示数组元素的个数

第二行给出 $n$ 个正整数 $a_1$ $a_2$……$a_n$ $(1 \le a_i \le 10^9)$ ，整数之间使用空格分隔

输出形式

输出最大递增子数组的长度

样例输入

5
1 7 2 11 15

样例输出

样例说明

1 7可以构成一个递增子数组

2 11 15可以构成一个递增子数组

所以本样例的输出结果为3

解题思路

贪心。遍历一遍，有递增的就计数，不递增了就重置。

20.Caesar密码

个人难度评级：1

问题描述

Julius Caesar生活在充满危险和阴谋的年代。为了生存，他首次发明了密码，用于军队的消息传递。假设你是Caesar军团中的一名军官，需要把Caesar发送的消息破译出来、并提供给你的将军。消息加密的办法是：对消息原文中的每个字母，分别用该字母之后的第5个字母替换（例如：消息原文中的每个字母A都分别替换成字母F），其他字符不变，并且消息原文的所有字母都是大写的。密码字母：A B C D E F G H I J K L M N O P Q R S T U V W X Y Z原文字母：V W X Y Z A B C D E F G H I J K L M N O P Q R S T U

输入形式

最多不超过100个数据集组成。每个数据集由3部分组成：起始行：START密码消息：由1到200个字符组成一行，表示Caesar发出的一条消息结束行：END在最后一个数据集之后，是另一行：ENDOFINPUT

输出形式

每个数据集对应一行，是Caesar的原始消息。

样例输入

START
NS BFW, JAJSYX TK NRUTWYFSHJ FWJ YMJ WJXZQY TK YWNANFQ HFZXJX
END
START
N BTZQI WFYMJW GJ KNWXY NS F QNYYQJ NGJWNFS ANQQFLJ YMFS XJHTSI NS WTRJ
END
START
IFSLJW PSTBX KZQQ BJQQ YMFY HFJXFW NX RTWJ IFSLJWTZX YMFS MJ
END
ENDOFINPUT

样例输出

IN WAR, EVENTS OF IMPORTANCE ARE THE RESULT OF TRIVIAL CAUSES
I WOULD RATHER BE FIRST IN A LITTLE IBERIAN VILLAGE THAN SECOND IN ROME
DANGER KNOWS FULL WELL THAT CAESAR IS MORE DANGEROUS THAN HE

解题思路

推荐使用getline函数输入数据，一次输入是一整行。

没必要前面提到的 std::map，因为这个太有规律了，对于大写字母，ASCII直接减5，如果小于’A’ 再加26即可。

21. 回文串

问题描述

“回文串”是一个正读和反读都一样的字符串，比如 “level” 或者 “noon” 等等就是回文串。给你一个字符串，问最少在字符串尾添加多少字符，可以使得字符串变为回文串。

输入格式

有多组测试数据。

每组测试数据第一行是一个正整数 $N$，表示字符串长度，接下来一行是长度为N的字符串，字符串中只有小写字母。

$N=0$ 表示输入结束，并且不需要处理。

$40 % $ 的数列元素个数 $N$ $1 \le N \le 100$；

$30 % $ 的数列元素个数 $N$ $1 \le N \le 1000$；

$20 % $ 的数列元素个数 $N$ $1 \le N \le 10000$；

$10 % $ 的数列元素个数 $N$ $1 \le N \le 100000$；

输出格式

　　对于每组测试数据，输出一个非负整数：添加最少的字符数，可以使得字符串变为回文串。

样例输入

3
aba
4
aaac
0

样例输出

0
3

解题思路

参考了 HNU 软件能力实训 4-21. 回文串 _Karltan 的博客 - CSDN 博客。

对于每个字符串，逐个截取前1、2、3…… 到N位并反转，连接到原串后面，然后检验是否为回文串即可。

熟练运用STL会让这道题非常简单（主要是 reverse 和 substr）。

湖南大学 2021 程序设计训练笔记 - 作业训练 3

Mon, 12 Jul 2021 00:00:00 +0000

所有代码均已上传至 homework/CSP-Training at master · cyp0633/homework (github.com)。不保证代码均正确，正确的也不保证为最优解，可以查看Commit详情进一步了解。

1. 部分A+B

个人难度评级：1

问题描述

正整数A的 “DA（为1位整数）部分” 定义为由A中所有DA组成的新整数PA。例如：给定A = 3862767，DA = 6，则A的“6部分”PA是66，因为A中有2个6；给定A = 3862767，DA = 1，则A的“1部分”PA是0，因为A中有0个1。

现给定A、DA、B、DB，请编写程序计算PA + PB。

输入形式

输入在一行中依次给出A、DA、B、DB，中间以空格分隔，其中0 < A, B < 1010。

输出形式

在一行中输出PA + PB的值。

样例输入

3862767 6 13530293 3

样例输出

解题思路

这个题都不会的话建议去面壁…… 没开long long导致WA掉的话情有可原。

2. 导弹拦截系统

来源：NOIP 1999普及组不知道第几题（洛谷 P1020）（有改动）

个人难度评级：3

问题描述

某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，并观测到导弹依次飞来的高度，请计算这套系统最多能拦截多少导弹。拦截来袭导弹时，必须按来袭导弹袭击的时间顺序，不允许先拦截后面的导弹，再拦截前面的导弹。

输入形式

每组输入有两行，

第一行，输入雷达捕捉到的敌国导弹的数量k（k<=25），

第二行，输入k个正整数，表示k枚导弹的高度，按来袭导弹的袭击时间顺序给出，以空格分隔。

输出形式

每组输出只有一行，包含一个整数，表示最多能拦截多少枚导弹。

样例输入

8
300 207 155 300 299 170 158 65

样例输出

解题思路

贪心就完事了，建议去翻洛谷的题解，那个更难，但估计讲得比我明白。

本题数据很弱，开O(n2) 的算法完全能过。

3. 魔咒词典

来源：HDU 1880（无法访问可移步 Vjudge）

个人难度评级：2

问题描述

哈利波特在魔法学校的必修课之一就是学习魔咒。据说魔法世界有100000种不同的魔咒，哈利很难全部记住，但是为了对抗强敌，他必须在危急时刻能够调用任何一个需要的魔咒，所以他需要你的帮助。

给你一部魔咒词典。当哈利听到一个魔咒时，你的程序必须告诉他那个魔咒的功能；当哈利需要某个功能但不知道该用什么魔咒时，你的程序要替他找到相应的魔咒。如果他要的魔咒不在词典中，就输出 “what?”

输入形式

首先列出词典中不超过100000条不同的魔咒词条，每条格式为：

[魔咒 ] 对应功能

其中 “魔咒” 和“对应功能”分别为长度不超过20和80的字符串，字符串中保证不包含字符 “[” 和“]”，且 “]” 和后面的字符串之间有且仅有一个空格。词典最后一行以 “@END@” 结束，这一行不属于词典中的词条。
词典之后的一行包含非负整数N（0=<N<=1000），随后是N个测试用例。每个测试用例占一行，或者给出 “[魔咒 ]”，或者给出 “对应功能”。

输出形式

每个测试用例的输出占一行，输出魔咒对应的功能，或者功能对应的魔咒。如果魔咒不在词典中，就输出 “what?”

【样例输入】

[expelliarmus] the disarming charm
[rictusempra] send a jet of silver light to hit the enemy
[tarantallegra] control the movement of one's legs
[serpensortia] shoot a snake out of the end of one's wand
[lumos] light the wand
[obliviate] the memory charm
[expecto patronum] send a Patronus to the dementors
[accio] the summoning charm
@END@
4
[lumos]
the summoning charm
[arha]
take me to the sky

样例输出

light the wand
accio
what?
what?

解题思路

咒语和效果都不一定只有一个词，所以需要使用getline一次读一行，然后再根据 ] 的位置分割（substr大法好）。别的应该没什么难的。

4. 打牌

个人难度评级：2

问题描述

牌只有1到9，手里拿着已经排好序的牌a，对方出牌b，用程序判断手中牌是否能够压过对方出牌。
规则：出牌牌型有5种
[1] 一张如4则5…9可压过
[2] 两张如44则55，66，77，…，99可压过
[3] 三张如444规则如 [2]
[4] 四张如4444规则如 [2]
[5] 五张牌型只有12345 23456 34567 45678 56789五个，后面的比前面的均大。

输入形式

输入有多行，第一行代表手中的牌，长度不超过200个数字。接下来的每一行代表每次对方出的牌。

输出形式

输出有多行，代表手中的牌是否能压过对方出的牌，压过输出YES，并列出所有可选项，可选项之间用空格分隔。否则输出NO。

样例输入

17624234556367
33
222
34567

样例输出

YES 44 55 66 77
YES 666
NO

解题思路

题意似乎没说牌放不放回…… 不过没说过出牌规则，应该是出牌后放回手牌的。

直接模拟即可，分几张牌的情况。五张牌情况不多，而且取起来也麻烦，建议直接对每种情况做特判。

（WA了一半多，不确定做法是否正确）

5. 最大报销额

来源：HDU 1864（无法访问可移步 Vjudge）

个人难度评级：3

问题描述

现有一笔经费可以报销一定额度的发票。允许报销的发票类型包括买图书（A类）、文具（B类）、差旅（C类），要求每张发票的总额不得超过1000元，每张发票上，单项物品的价值不得超过600元。现请你编写程序，在给出的一堆发票中找出可以报销的、不超过给定额度的最大报销额。

输入形式

测试输入包含若干测试用例。每个测试用例的第1行包含两个正数Q和N，其中Q是给定的报销额度，N（N<=30）是发票张数。随后是N行输入，每行的格式为：
m Type_1:price_1 Type_2:price_2 … Type_m:price_m
其中正整数m是这张发票上所开物品的件数，Type_i和price_i是第i项物品的种类和价值。物品种类用一个大写英文字母表示。当N为0时，全部输入结束，相应的结果不要输出。

输出形式

对每个测试用例输出1行，即可以报销的最大数额，精确到小数点后2位。

样例输入

200.00 32 A:23.50 B:100.001 C:650.003 A:59.99 A:120.00 X:10.001200.00 22 B:600.00 A:400.001 C:200.501200.50 32 B:600.00 A:400.001 C:200.501 A:100.00100.00 0

样例输出

123.501000.001200.50

解题思路

第一个困难其实是阅读理解。很容易能看出来这题是一个01背包问题，但背包里装的是什么呢？其实是发票。将发票各物品的 ** 总价值 ** 作为 ** 整一件 ** 物品的价值，而对于每组数据，有多张发票，那就是求如何取 ** 整张 ** 发票，能够让报销额尽可能接近报销上限而不超过。所以，只需要存储每张发票的总金额就可以了。

第二个困难是允许报销类型限制、每件物品金额限制和发票总金额限制。因为报销只能整张一起报，所以出现任何一个上述的例外情况，** 整张发票作废 **（可将金额存储为0）。

第三个困难是如何写DP。相信很多人已经背熟01背包了，但对于没背熟的人来说，这也许不算什么困难，毕竟当看到N<=30的时候，我相信你和我是一样的反应：直接暴力搜，管那么多干什么？确实，数据范围太菜，直接搜确实没问题。

第四个困难是初始化变量。老生常谈了，有多组数据的题要记得初始化。

6. 带通配符的数

个人难度评级：2

问题描述

给定一个可以带通配符问号的正整数W，问号可以代表任意一个一位数字。再给定一个正整数X，和W具有同样的长度。问有多少个整数符合W的形式并且比X大？

输入形式

多组数据，每组数据两行，第一行是W，第二行是X，它们长度相同，在 [1..10] 之间。

输出形式

每行一个整数表示结果。

样例输入

36?1?82364288?3910?5

样例输出

解题思路

通配符的数量不确定，那就dfs啊。

7. 愚人节的礼物

个人难度评级：1

问题描述

四月一日快到了，Vayko想了个愚人的好办法——送礼物。嘿嘿，不要想的太好，这礼物可没那么简单，Vayko为了愚人，准备了一堆盒子，其中只有一个盒子里面装了礼物。盒子里面可以再放零个或者多个盒子。假设放礼物的盒子里不再放其他盒子。用 () 表示一个盒子，B表示礼物，Vayko想让你帮她算出愚人指数，即最少需要拆多少个盒子才能拿到礼物。

输入形式

本题目包含多组测试，请处理到文件结束。每组测试包含一个长度不大于1000, 只包含 ‘(’,’)’ 和’B’ 三种字符的字符串，代表Vayko设计的礼物透视图。你可以假设，每个透视图画的都是合法的。

输出形式

对于每组测试，请在一行里面输出愚人指数。

样例输入

((((B)()))())
(B)

样例输出

4
1

解题思路

可别把它当括号匹配做啊，题目给出的括号串是完全合法的，不需要检验合法性，甚至用不到STL stack，只需要一个整型模拟栈的元素数量，统计左括号数量就行了。

8. ab串

个人难度评级：3

问题描述

给定一个由字符’a’ 和字符’b’ 组成的字符串，可以删除若干字符，使得剩下来的字符串满足前后段为a，中间段为b（aaa….aaabbbb…..bbbbaaa…..aaa）, 区段可以没有字符（ba,ab,b,aa都是合法的），求最长剩下字符串的长度。

输入形式

输入为一行一个长度不超过5000的非空字符串，字符串仅由字符’a’ 和字符’b’ 组成。

输出形式

输出为一个整数，表示符合要求的最长剩下字符串长度

样例输入1

abba

样例输出1

样例输入2

bab

样例输出2

解题思路

前缀和？什么是前缀和？影响我打暴搜吗？题目数据似乎很菜，分块不多，要不然真搜不完。

将原字符串分割为内部完全由a/b组成的小块，用 pair<int,string> 存储，比如aabaa可以分割成长度为2的a块、长度为1的b块、长度为2的a块。这里可以使用string的find函数减少工作量。遇到b开头的串其实也不用慌，完全可以先统计a块，最终会在最前面形成一个长度为0的a块，并不影响做题。

然后开始逐块进行深搜。将其化为三种阶段，前面的a串、中间的b串和后面的a串。具体的我再想想怎么讲，建议先去看看代码。大致上就是根据当前搜到a串还是b串来分，然后在此基础上再分1、2或3阶段分情况讨论。

9. 占座位

个人难度评级：4

问题描述

sun所在学校的教室座位每天都是可以预占的。
一个人可以去占多个座位，而且一定是要连续的座位，如果占不到他所要求的这么多座位，那么他就一个座位也不要了。为了降低难度，每次分配座位按座位号从小到大查找，采用最先适配法分配座位。

输入形式

输入有多组数据。
每组数据输入座位排数n，0<n<=100（座位的排列数相等，座位是按每行从左到右依次排序的, 第1行的最右边一个座位与第二行的第一个座位视为连续座位），m（0<m<=min(100,n*n) ）个人。
然后输入k（0<k<=100），最后输入k个命令。
命令只有两种：
1.in id num（代表id,0<=id<m, 要占num个座位，若占不到连续的num(0<num<=20) 个座位表示该命令无效）
2.out id（代表id要释放他之前占的所有座位）
注意：如果id之前占过座还没释放那么之后他的in命令都是无效的，
如果id之前没占过座位那么他的out命令也是无效的。

输出形式

对每个in命令输出yes或者no，如果命令有效则输出yes，无效则输出no。
在yes no后面只带有回车，不带其他任何字符。

样例输入

4 10
9
in 1 7
in 2 3
in 3 3
in 3 3
in 4 3
out 2
in 5 6
out 3
in 5 6

样例输出

yes
yes
yes
no
yes
yes
no
yes
yes

解题思路

这题几乎完全是内存管理一题的翻版…… 甚至还要简单些，因为阅读理解的困难变小了很多，并且没有碎片整理部分。

座位好几排？没有关系，前一行最后一个和下一行第一个视为连续座位，那不就和内存空间差不多了嘛……

顺便吐槽一下CG的样例，格式也太不标准了点。

10. Maya历法

个人难度评级：2

问题描述

在学术休假期间，M.A. Ya教授在古老的Maya历法上有一个惊人的发现。从一个古老的令人棘手的信息中，教授发现Maya文明以365天为一年，称为Haab，包含19个月。前18个月每月有20天，月份名字为：pop、no、zip、zotz、tzec、xul、yoxkin、mol、chen、yax、zac、ceh、mac、kankin、muan、pax、koyab、cumhu。每月的天数使用数字来表示，从0~19，而不是用名字。Haab的最后一个月叫做uayet，有5天，表示为0、1、2、3、4。玛雅人认为这个月是不吉利的，法院不开庭，贸易停止了，人们甚至停止清扫地板。

出于宗教的目的，Maya人使用另外一套历法，叫做Tzolkin（冬青年）。一年被分为13个期间，每个期间20天。每天被表示为由数字和日期名表示的数对。使用20个名字：imix、ik、akbal、kan、chicchan、cimi、manik、lamat、muluk、ok、chuen、eb、ben、ix、mem、cib、caban、eznab、canac、ahau，以及13个数字，双循环使用。

请注意，每一天都有一个明确的描述。例如，在年初的日子被描述如下：

1 imix, 2 ik, 3 akbal, 4 kan, 5 chicchan, 6 cimi, 7 manik, 8 lamat, 9 muluk, 10 ok, 11 chuen, 12 eb, 13 ben, 1 ix, 2 mem, 3 cib, 4 caban, 5 eznab, 6 canac, 7 ahau, 在下一个期间开始为8 imix, 9 ik, 10 akbal . . .

年份（包含Haab和Tzolkin) 用数字0、1、… 来表示，数字0是世界的开始。因此，第一天表示为：

Haab: 0. pop 0

Tzolkin: 1 imix 0

请帮M.A.Ya教授写一个程序，将Haab日历转换为Tzolkin日历。

输入形式

在Haab中日期用以下形式表示：

NumberOfTheDay. Month Year

输入文件的第一行包含文件中输入日期的数目。接下来的n行包含Haab日历格式的n个日期，年份小于5000。

输出形式

Tzolkin日期用一下格式：

Number NameOfTheDay Year

输出包括n行，按照与输入日期对应的顺序，输出tzolkin日历格式日期。

样例输入

310.zac 00.pop 010.zac 1995

样例输出

3 chuen 01 imix 09 cimi 2801

解题思路

阅读理解题，难度全在对两种历法的阅读理解上。如果觉得题目读不懂，可以阅读一下玛雅历 - 维基百科，自由的百科全书（需要魔法上网）。

还读不懂？不妨这样：

输入的历法叫Haab历，它一年有365天，其中包含19个月，前18个月每月20天，第19个月只有5天。这20个月用名字来表示，分别叫做pop、no、zip、zotz、tzec、xul、yoxkin、mol、chen、yax、zac、ceh、mac、kankin、muan、pax、koyab、cumhu。每个月的日期使用数字表示。

需要输出的历法叫Tzolkin历。它并没有传统意义上的 “月” 和“日”，而是用20个 “日名” 和13个 “日数” 的组合来确定一年中唯一的日期，比较像中国的天干地支纪年法。日名和日数各自独立循环使用。天干地支纪年法60年一个循环，那么Tzolkin历就是260天一个循环，也就是一”年“。日名循环的每一天分别叫做imix、ik、akbal、kan、chicchan、cimi、manik、lamat、muluk、ok、chuen、eb、ben、ix、mem、cib、caban、eznab、canac、ahau，而日数循环则直接用1-13的自然数表示。

顺便，注意 “0日” 和“13日”的转换。

11. 数码管

个人难度评级：1

问题描述

液晶数码管用七笔阿拉数字表示的十个数字，把横和竖的一个短划都称为一笔，即７有３笔，８有７笔等。对于十个数字一种排列，要做到两相邻数字都可以由另一个数字加上几笔或减去几笔组成，但不能又加又减。比如７→３是允许的，７→２不允许。任意输入一组数，判断是否符合上述规则，注意，1在右边。

输入形式

每行输入一个0~9的排列，数字之间用空格分隔，以 - 1作为输入结束

输出形式

输出YES或NO

样例输入

4 1 0 7 3 9 5 6 8 2
3 5 1 6 2 7 9 0 4 8
-1

样例输出

YES
NO

解题思路

打表神题，直接预先在纸上算出数字转换关系的邻接矩阵，用的时候直接读取即可。这个关系是对称的，也就是说a能转换为b则b也能转换为a。特别要注意打表的准确性，如果打错了那就完蛋了…… 建议打2遍。

bool isTransferrable[10][10] = {{1, 1, 0, 0, 0, 0, 0, 1, 1, 0},
                                {1, 1, 0, 1, 1, 0, 0, 1, 1, 1},
                                {0, 0, 1, 0, 0, 0, 0, 0, 1, 0},
                                {0, 1, 0, 1, 0, 0, 0, 1, 1, 1},
                                {0, 1, 0, 0, 1, 0, 0, 0, 1, 1},
                                {0, 0, 0, 0, 0, 1, 1, 0, 1, 1},
                                {0, 0, 0, 0, 0, 1, 1, 0, 1, 0},
                                {1, 1, 0, 1, 0, 0, 0, 1, 1, 1},
                                {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
                                {0, 1, 0, 1, 1, 1, 0, 1, 1, 1}};

可以使用stringstream承接一行一行的输入，然后逐个读取。

12. 多项式加法

个人难度评级：2

问题描述

一个多项式可以表示为一组数对，数对中第一个数始终为整数，且唯一，表示多项式的次数，另一数表示为对应的系数且不为0。输入两组数对，每组以0 0作为结束，实现对两个多项式的加法并按降幂输出结果数对

输入形式

每行输入一个数对，以空格为分隔符，以0 0结束

输出形式

每行输出一个数对，以空格为分隔符

样例输入

样例输出

解题思路

很容易想到使用数组来存放各个次数的系数，但次数只说了是整数，先不必说太大咋办，首先负系数就能把数组方案毙掉了（虽然还是能得大约60分）。这时候使用std::map就十分有必要了，不过这样的话要考虑相加之后系数为0的情况。

正常考试的时候应该会有数据范围的，只要能看到，就一般能想到不能用数组存。

13. 数字统计

个人难度评级：1

问题描述

给定一个k位整数N = dk-1*10k-1 + … + d1*101 + d0 (0<=di<=9, i=0,…,k-1, dk-1>0)，请编写程序统计每种不同的个位数字出现的次数。例如：给定N = 100311，则有2个0，3个1，和1个3。

输入形式

每个输入包含1个测试用例，即一个不超过1000位的正整数N。

输出形式

对N中每一种不同的个位数字，以D:M的格式在一行中输出该位数字D及其在N中出现的次数M。要求按D的升序输出

样例输入

样例输出

0:2
1:3
3:1

解题思路

这个有啥好讲的啊……

14. A除以B

个人难度评级：1

问题描述

本题要求计算A/B，其中A是不超过1000位的整数（A>=0），B是1位正整数。你需要输出商数Q和余数R，使得A = B * Q + R成立。

输入形式

输入在1行中依次给出A和B，中间以1空格分隔。

输出形式

在1行中依次输出Q和R，中间以1空格分隔。

样例输入

123456789050987654321 7

样例输出

17636684150141093474 3

解题思路

挺简单一道题，就是高精除低精。但是要注意两点：

去掉前导0；
不要把商为0当成前导0给去掉了（这个会卡测试数据3）。

15. 公交系统

个人难度评级：2

问题描述

城市公交系统有一个记录仪，用于记录每个站点的乘客人数的变化情况，例如：x表示到站前公交车上的乘客人数，y表示离站时公交车上的乘客人数，则该记录仪记录的该站的数字为y-x。

对于一辆公交车和n个车站，a1,a2,…,an为该公交车在各站的记录数据。

假定w为该公交车可容纳的最大乘客人数，编程求出在第一站停靠之前公交车上人数的可能数据有多少种？

输入形式

第一行包含两个数据n和w(1<=n<=1000, 1<=w<=109)，分别表示车站的数目和公交车可容纳的最大乘客人数。

第二行包含一个序列a1,a2,…,an，表示记录仪记录的各站的数据。

输出形式

输出一个整数，表示公交车在第一站停靠之前可能的乘客人数数据的个数，如果没有，则输出0。

样例输入1

3 5
2 1 -3

样例输出1

样例输入2

2 4
-1 1

样例输出2

样例输入3

4 10
2 4 1 2

样例输出3

样例说明

在第一个样例中，乘客数可能有0、1、2，共3种情况

在第二个样例中，乘客数可能有1、2、3、4，共4种情况

在第三个样例中，乘客数可能为0或1，共2种情况

解题思路

假定一开始车上有0个人，然后录入变动情况，记录车上的最大最小人数。

如果最大人数超过额定载客量，或者最大人数和最小人数的差大于额定载客量，则输出0。

在最小人数大于等于0的情况下，只需要满足最大人数 + 初始人数 <= 额定载客量即可；如果小于 0，则还需要满足最小人数 + 初始人数>=0。

满足以上条件的初始人数情况数，即为结果。

16. 成绩大派对

个人难度评级：1

问题描述

读入n名学生的姓名、学号、成绩，分别输出成绩最高和成绩最低学生的姓名和学号。

输入形式

每个测试输入包含1个测试用例，格式为

第1行：正整数n 第2行：第1个学生的姓名学号成绩第3行：第2个学生的姓名学号成绩 … … … 第n+1行：第n个学生的姓名学号成绩

其中姓名和学号均为不超过20个字符的字符串，成绩为0到100之间的一个整数，这里保证在一组测试用例中没有两个学生的成绩是相同的。

输出形式

对每个测试用例输出2行，第1行是成绩最高学生的姓名和学号，第2行是成绩最低学生的姓名和学号，字符串间有1空格。

样例输入

3
Joe Math990112 89
Mike CS991301 100
Mary EE990830 95

样例输出

Mike CS991301
Joe Math990112

解题思路

分别维护姓名、学号和成绩的临时变量、最大值、最小值，边输入边更新即可。

17. 字符串数字置换

个人难度评级：1

问题描述

从键盘接收用户输入的字符串, 对用户输入的每个字符串的处理是：将字符串内的每一个十进制数字字符置换成下列表格中右边所对应的一个字符串（所有其他字符不变），然后将转换的结果显示在屏幕上；并分别计算每个数字的置换次数。

十进制数字字符	置换成
0	(Zero)
1	(One)
2	(Two)
3	(Three)
4	(Four)
5	(Five)
6	(Six)
7	(Seven)
8	(Eight)
9	(Nine)

例如，若用户输入的字符串为

Page112-Line3，

则程序5的输出是：

Page(One) (One) (Two)-Line(Three),

数字0到9的置换次数分别是 0 2 1 1 0 0 0 0 0 0

输入形式

输入一行字符串，其中可包含字母、数字、空格或其他符号（英文）

输出形式

第一行为将字符串中的数字转换为表格中的内容后输出

第二行为数字0~9被转换的次数

样例输入

Page112-Line3

样例输出

Page(One)(One)(Two)-Line(Three)
0 2 1 1 0 0 0 0 0 0

解题思路

没什么好讲的

18. 写出来吧

个人难度评级：1

问题描述

读入一个自然数n，计算其各位数字之和，用汉语拼音写出和的每一位数字。

输入形式

每个测试输入包含1个测试用例，即给出自然数n的值。这里保证n小于10的100次方。

输出形式

在一行内输出n的各位数字之和的每一位，拼音数字间有1空格，但一行中最后一个拼音数字后没有空格。

样例输入

1234567890987654321123456789

样例输出

yi san wu

样例说明

友情提示汉语拼音

0~9：ling yi er san si wu liu qi ba jiu shi

解题思路

没什么好讲的，倒是这拼音提示挺侮辱智商的。

19. 到底买不买

个人难度评级：1

问题描述

小红想买些珠子做一串自己喜欢的珠串。卖珠子的摊主有很多串五颜六色的珠串，但是不肯把任何一串拆散了卖。于是小红要你帮忙判断一下，某串珠子里是否包含了全部自己想要的珠子？如果是，那么告诉她有多少多余的珠子；如果不是，那么告诉她缺了多少珠子。

为方便起见，我们用 [0-9]、[a-z]、[A-Z] 范围内的字符来表示颜色。例如在图1中，第3串是小红想做的珠串；那么第1串可以买，因为包含了全部她想要的珠子，还多了8颗不需要的珠子；第2串不能买，因为没有黑色珠子，并且少了一颗红色的珠子。

输入形式

每个输入包含1个测试用例。每个测试用例分别在2行中先后给出摊主的珠串和小红想做的珠串，两串都不超过1000个珠子。

输出形式

如果可以买，则在一行中输出 “Yes” 以及有多少多余的珠子；如果不可以买，则在一行中输出 “No” 以及缺了多少珠子。其间以1个空格分隔。

样例输入

ppRYYGrrYBR2258YrR8RrY

样例输出

Yes 8

解题思路

这是一个很好想很好写很好调但未必快的思路。

我们都知道char本质上是用ASCII码存储的，那么统计某个字符串中某字符出现数量，可以直接加到对应ASCII码下标的数组值里面。

遍历一遍待买的字符串和想要的字符串，分别加到两个数组里，然后分别统计少的和多的即可。

注意数组要开大点，ASCII码范围是0-127，我们需要的最大是z即122。

一个更好的方案是使用std::map来维护对应关系。

20. 挖掘机技术哪家强

个人难度评级：1

问题描述

为了用事实说明挖掘机技术到底哪家强，组织一场挖掘机技能大赛。现请你根据比赛结果统计出技术最强的那个学校。

输入形式

输入在第1行给出不超过105的正整数N，即参赛人数。随后N行，每行给出一位参赛者的信息和成绩，包括其所代表的学校的编号、及其比赛成绩（百分制），中间以空格分隔。

输出形式

在一行中给出总得分最高的学校的编号、及其总分，中间以空格分隔。题目保证答案唯一，没有并列。

样例输入

63 652 801 1002 703 403 0

样例输出

2 150

问题说明

建议练习使用STL中的map

解题思路

建议翻别人用map写的题解，我没用。毕竟总共105个学校，又不是不能用数组。

21. Web导航

个人难度评级：1

问题描述

标准的Web浏览器具有在最近访问的页面中前后移动的特性。实现这些特性的一种方法是使用两个堆栈来跟踪可以通过前后移动到达的页面。在这个问题中，我们要求实现这一点。

需要支持以下命令：

BACK：将当前页面压入前向堆栈的顶部；从后向堆栈的顶部弹出该页，使其成为新的当前页。如果后向堆栈为空，则该指令忽略。

FORWARD：将当前页面压入后向堆栈的顶部；从前向堆栈的顶部弹出该页，使其成为新的当前页。如果前向堆栈为空，则该指令忽略。

VISIT：将当前页面压入后向堆栈的顶部，将URL指定为新的当前页。前向堆栈被清空。

QUIT：退出浏览器。

假设浏览器最初在网址http://www.game.org / 上加载网页。

输入形式

输入是一个命令序列。命令关键字BACK、FORWARD、VISIT和QUIT都是大写。URL中无空格，最多有70个字符。假定在任何时候，每个堆栈中没有问题实例需要超过100个元素。输入的结尾由QUIT命令标识。

输出形式

除QUIT外的每个命令，如果命令没有被忽略，则在命令执行后输出当前页面的URL，否则，打印 “Ignored”。每个命令的输出独立打印一行。QUIT命令无输出。

样例输入

VISIT http://game.ashland.edu/VISIT http://game.baylor.edu/acmicpc/BACKBACKBACKFORWARDVISIT http://www.our.com/BACKBACKFORWARDFORWARDFORWARDQUIT

样例输出

http://game.ashland.edu/
http://game.baylor.edu/acmicpc/
http://game.ashland.edu/
http://www.game.org/
Ignored
http://game.ashland.edu/
http://www.our.com/
http://game.ashland.edu/
http://www.game.org/
http://game.ashland.edu/
http://www.our.com/
Ignored

解题思路

直接照着题上的提示写就行了，没有特殊情况。

湖南大学 2021 程序设计训练笔记 - 作业训练 5

Mon, 12 Jul 2021 00:00:00 +0000

所有代码均已上传至我的 GitHub 及我的 Gitea。不保证代码均正确（如不正确会在Commit详情标出），正确的也不保证为最优解。

1. Dijkstra?

来源：CF20C 数据已弱化

个人难度评级：3

问题描述

给定一个含权的无向图，顶点编号为 $1-n$，你的任务为找出顶点 $1$ 到顶点 $n$ 之间的最短路径。

输入形式

输入的第一行为两个整数 $n$ 和 $m(2 \le n \le 10^5,0 \le m \le 10^5)$，其中 $n$ 为顶点数，$m$ 是边数。

接下来的 $m$ 行包含用形式 $a_i$、$b_i$ 和 $w_i(1 \le a_i, b_i \le n,1 \le w_i \le 10^6)$，这 $a_i$、$b_i$ 是边的端点，而 $w_i$ 是边的长度。

该图可能包括环，或者一对顶点之间包含多条边。

输出形式

如果无路径，输出 $-1$，否则输出最短路径，如果有多个，则输出字典序最小的路径。

对于两个整数序列 $A(a_1、a_2、…)$ 和 $B(b_1、b_2、…)$，称序列 $A$ 字典序小于序列 $B$ 当且仅当，存在 $k \ge 1$，$i \le k$ 时，$a_i \le b_i$，$i=k$ 时，$a_i < b_i$ 。

样例输入

样例输出

1 4 3 5

解题思路

首先提前说一下，别看它 $10^7$ 的数据范围，其实并没有几条边，可以说是弱中弱了。如果想通过原题，可以试着看看洛谷等地的题解。

所以说这是个模板题，就像 Luogu P3371 一样？不是，起码不完全是。

它加入了路径输出，而且还要输出字典序最小的路径。我的解决方法是为每个点增加一个vector，存储从1号点到这里最短且字典序最小的路径，当检测到更短的路径时一律替换为更短的路径并更新dist数组，而当检测到同样长度的路径时，如果字典序更小，就替换路径。

如何比较vector的字典序？那当然是手撸比较函数。那string自带比较函数，为什么不用string存路径？因为它会认为 1 3 15 2 要比 1 3 5 2 字典序更小。

2. 0-1串

来源：Codeforces 327A Flipping Game

个人难度评级：2

问题描述

对于一个包含 $n$ 个整数元素的序列 $a_1$、$a_2$、…、$a_n$，每个元素的值或者是 $0$ 或者是 $1$，选择两个下标 $i$ 和 $j(1 \le i \le j \le n)$, 对于所有的此范围内的元素 $a_k(i \le k \le j)$，执行操作 $a_k=1-a_k$。

选择合适的 $i$ 和 $j$，执行上述操作一次之后，可以得到的新序列中包含 $1$ 的个数最多是多少？

输入形式

输入的第一行为一个整数 $n(1 \le n \le 100)$，接来的一行为 $n$ 个整数，每个整数或者是 $0$ 或者是 $1$。

输出形式

输出为一个整数，表示执行一次上述操作后可以获得的最大 $1$ 的个数。

样例输入1

5
1 0 0 1 0

样例输出1

样例输入2

4
1 0 0 1

样例输出2

样例说明

在第一个样例中，选择 $i=2, j=5$, 改变后的序列为 $[1 1 1 0 1]$，包含4个1，很显然无法改变为 $[1 1 1 1 1]$。

在第二个样例中，选择 $i=2, j=3$，改变后的序列为 $[1 1 1 1]$，包含4个1。

解题思路

CG上的题目标签中赫然写着”动态规划 “” 前缀和 “，但这毕竟是一道CF A题，出现了范围十分小的数据范围，O(n3) 的暴力枚举算法也能轻松通过，即使是CF原数据。枚举左端点和右端点，分别计算区间左边、中间和右边的和相加张，在各种情况中取最大值即可。注意左右端点可以重合，也可以延伸到尽头。

如果嫌左右加和太慢，似乎也可以写棵线段树？其实前缀和优化之后根本不需要对左右两边进行加和，只需要对翻转的部分进行操作。对此，你可以看洛谷的题解，有一些写得不错。

3. 良心树

来源：Codeforces 1143C

个人难度评级：4

问题描述

给定一颗有根树，顶点编号为 $1~n$，树是一个无环的连通图，有根树有一个特定的顶点，称为根。

顶点 $i$ 的祖先是从根到顶点i的路径上除顶点 $i$ 以外的所有顶点，顶点 $i$ 的父母是 $i$ 的祖先中最接近 $i$ 的顶点，每个顶点都是它父母的孩子。在给定的树中，顶点 $i$ 的父母是顶点 $p_i$，对于根，$p_i$ 为 $-1$。例如：

这是一个 $n=8$ 个顶点的树，根为 $5$，顶点 $2$ 的父母为 $3$，顶点1的父母为 $5$,$6$ 的祖先为 $4$ 和 $5$，$7$ 的祖先为 $8$、$3$ 和 $5$。

在树中，其中一些顶点不尊重其他一些顶点，实际上，如果 $c_i=1$，表示顶点 $i$ 不尊重它的所有祖先，而如果 $c_i=0$，则表示它尊重它所有的祖先。

你需要一个一个地删除一些顶点，在每一步中，选择一个非根顶点，它不尊重它的父母并且它的所有孩子顶点也不尊重它。如果有几个这样的顶点，你需要选择具有最小编号的顶点。当你删除了这样的一个顶点 $v$, 则 $v$ 的所有子顶点与 $v$ 的父母顶点相连。

上图是删除顶点 $7$ 的示例。

直到树中无满足删除标准的顶点，则上述过程停止。按顺序输出你删除的所有顶点，注意这个顺序的唯一的。

输入形式

输入的第一行为一个整数 $n(1 \le n \le 10^5)$，表示树的顶点数。

接下来的 $n$ 行描述了整颗树：第 $i$ 行包含两个整数 $p_i$ 和 $c_i(1 \le p_i \le n,0 \le c_i \le 1)$，这里 $p_i$ 是顶点 $i$ 的父母，若 $c_i=0$，表示顶点 $i$ 尊重它的父母，$c_i=1$，表示顶点 $i$ 不尊重它的父母，$p_i=-1$ 时，表示顶点 $i$ 是树的根，同时 $c_i=0$。

输出形式

如果树中至少有一个顶点被删除，则按照顺序输出顶点编号，否则输入 $-1$。

样例输入1

样例输出1

1 2 4

样例输入2

样例输出2

-1

样例输入3

样例输出3

样例说明

第一个样例的删除过程如下（在图中，$c_i=1$ 的顶点是黄色的）

首先删除顶点 $1$，因为它不尊重祖先并且它的所有孩子也不尊重它，而 $1$ 是这样的顶点中编号最小的
删除后顶点 $2$ 将连接到顶点 $3$
然后删除顶点 $2$，因为它不尊重祖先并且它的所有孩子也不尊重它。
顶点 $4$ 将连接到顶点 $3$
然后删除顶点 $4$，因为它不尊重祖先，并且它的所有孩子也不尊重它（无孩子）
无更多顶点可删

在第二个样例中，无需删除顶点

顶点 $2$ 和 $3$ 的孩子尊重它们
顶点 $4$ 和 $5$ 尊重它们的祖先

在第三个样例中显示如下

解题思路

CG系统上的翻译帮了倒忙，Codeforces的题目原文也不难懂，建议去看英文原文，能够对题面有更好的理解。

下面介绍的是一种思考有难度，而其他方面十分有优势的做法。不需要图论知识，不需要树论知识（需要的知识原题已讲明），更不需要DFS！推荐大家去看Luogu@songhongyi的题解，讲得非常清楚，切中要害：题解 CF1143C 【Queen】 - 一位编程爱好者 - 洛谷博客 (luogu.org)

这道题的一个条件十分重要：不尊重就是不尊重所有祖先，同样尊重的话也是尊重所有祖先。如果一个顶点被移除，那么它的所有子结点都不尊重它，它自己也不尊重父结点。这一支，以前是，把子结点连到父结点之后也是，都是不尊重父结点的。至于尊重的，根本就不会被移除，当然更没有影响。也就是说，移除顶点时，临近点的受尊重状态并不会随之改变。

这样，从小到大删除并输出符合条件的结点，就可以转化为仅从小到大输出符合条件的结点，而不用真正的删除，反正删不删造成的影响实际上并不重要；洛谷的题目翻译隐去了这部分推导过程，使得题目变得过于简单，所以我认为不甚合适。

基于以上原因，我们进一步的确定，根本不需要建树。将每个结点输入并将那两个条件计算即可。上述的那篇题解提供了非常好的办法：位运算，准确的说是位与。初始将每个结点都设为被所有子节点不尊重，然后对它每个子节点，如果有一个尊重它，按位与之后，就是0，即被尊重。

4. 最昂贵的旅行

个人难度评级：2

问题描述

这个国家有 $n$ 个城市，编号从 $0~n-1$，城市网络中没有任何环路，但可以从任意一个城市出发沿公路直接或间接到达其他城市。

有人住在编号为 $0$ 的城市里，他希望去其他的一个城市旅行，但他不想付出更多的成本，所以他想知道去哪个城市的成本是最高的。

输入形式

输入的第一行为一个整数 $n(3 \le n \le 100)$，接下来的 $n-1$ 行每行包括 $3$ 个整数 $u、v、c(0 \le u,v \le n-1,1 \le c \le 10^4)$，意为在城市 $u$ 和 $v$ 之间有公路直接相连，且旅行需要花费的成本为 $c$。

输出形式

输出为一个整数，表示从城市 $0$ 出发去到其他的某个城市，需要付出的最大成本。

样例输入1

样例输出1

样例输入2

样例输出2

样例输入3

样例输出3

解题思路

题意：求单源最短路径中的最大值。

其实基本就是dijkstra模板题，如果你会了第1题，没有理由不会这道题。

一个小坑：道路是双向的，这体现在样例2中，如果是单向道路，那么城市1就不能到达，而题中保证了所有城市都可以到达。

5. 猫与餐厅的故事

来源：Codeforces 580C（数据差别很大）

个人难度评级：4

问题描述

公司今天发薪，阿迪想与朋友们去餐厅庆祝一下。

他住在一个非常神奇的公园里，这个公园是一个根在顶点 $1$，且由 $n$ 个顶点组成的有根树，顶点1也就是他的住所。然而不幸的是，公园也有许多的猫，阿迪已经找出了所有包含猫的顶点。

公园的叶子顶点都有餐厅，阿迪想选择一家他可以去的餐厅，但很不幸，他非常害怕猫，因而如果从餐厅去往他家的路径上有连续包含猫的数量超过 $m$ 时，他将不能去往这家餐厅。

你的任务是帮助他确认他能去的餐厅的数量。

输入形式

输入的第一行包含两个整数 $n$ 和 $m(2 \le n \le 10^5, 1 \le m \le n)$，分别表示树的顶点数以及对于阿迪来说可以忍受的最大的包含猫的连续顶点数。

第二行包含 $n$ 个整数 $a_1$、$a_2$、…、$a_n$，这里的每个 $a_i$ 或者为 $0$（顶点 $i$ 无猫），或者为 $1$（顶点 $i$ 有猫）。

接下来的 $n-1$ 行包含用形式 “$x_i$ $y_i$”（$1 \le x_i,y_i \le n, x_i \neq y_i$）表示的树的边，表示顶点 $x_i$ 和顶点 $y_i$ 之间有边相连。

输出形式

输出为一个整数，表示从阿迪家去往叶子顶点的路径上至多包含 $m$ 只猫的叶子顶点的数量。

样例输入1

样例输出1

样例输入2

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

样例输出2

样例说明

很显然，树是具有 $n$ 个顶点 $n-1$ 条边的连通图，有根树是有一个称为根的特殊顶点的树。

在样例一中

包含猫的顶点变为红色，餐厅在顶点2、3、4，阿迪不能去到在顶点2的餐厅。

在样例二中

餐厅在顶点4、5、6、7，阿迪不能去到6和7。

解题思路

这题我CF全过了，但CG全部WA，扫了一眼，似乎CG的样例比CF还猛（以至于无法显示整个样例）…… 翻译质量倒是还凑合，起码比英语读着舒服了。

此题的数据结构是树，但不是二叉树，所以并不建议使用二叉树的表示方式记录，而应该使用图的方式（毕竟树也是图嘛）。你可以使用邻接矩阵或者邻接表存储，但我更推荐链式前向星，下面的思路也是基于链式前向星展开的。

需要注意结点的编号从1开始。考虑到链式前向星，我建议边的下标也从1开始。为了防止输入边的方向并不是从根节点向叶子结点，可以考虑存成无向图，两种方向都存进去，不会MLE。

在构建完成整张图之后，使用DFS从结点1开始搜索，除了要维护当前结点编号之外，还要维护当前路径已经连续有猫的数量。一旦后者大于m，直接return。

除此之外，我们都知道到了叶子结点就要计数。但是如何判断叶子结点呢？我们用 $head[currPos]$ 表示当前结点第一条边的终点下标，而 $next[i]==1$ 第i条边不再有下一条同起点边。叶子结点只连着一条边，所以需要 $next[head[currPos]]==1$ ，来表示currPos只连了一条边（即父节点）。同时为了防止无父节点的根节点被误判，还需要加入 $currPos!=1$ 。

访问过的结点打上visited标记，因存的是无向图，这样可以防止重复访问。visited的结点也可以直接return。

之后就是对当前结点连接的结点的遍历了，如果有猫则当前连续猫数 + 1，否则清空。

6. 旅行的期望值

来源：Codeforces 839C

个人难度评级：4

问题描述

在古代阿拉伯王国，有 $n$ 座城市有 $n-1$ 条道路，每条道路连接两座城市，人们可以从任意城市出发到达另外一座城市。

西蒙住在第一个城市，骑着马沿着马路去旅行，但是这个国家非常多雾，他也看不清楚马把他带向了哪里，当他们到达一个城市时（包括第一个城市），接下来可以去往与该城市相连的任意一个城市，然而他的马有些奇特，就是只会去往以前从未到达过的城市，且对于下一个城市的选择是等概率的，直到没有可以去往的城市为止。

设每条道路的长度为1，从第一个城市开始旅行，那么这次旅行的期望长度（旅行距离的期望值）的多少？

如果你对期望值（平局值）的定义不太了解，可以查阅相关资料。

输入形式

输入的第一行为一个整数 $n(1 \le n \le 100000)$，表示城市的数量。

接下来的 $n-1$ 行，每行包含两个整数 $u_i$ 和 $v_i(1 \le u_i,v_i \le n,u_i \neq v_i)$，表示由第 $i$ 条道路连接的城市。

输入保证能从一个城市到达其他任意一个城市。

输出形式

输出一个数，表示此次旅行的距离的期望值，旅行从城市1开始。

答案的绝对或相对误差不能超过 $10^{-6}$，也就是说，如果你的答案为 $a$，正确答案为 $b$，则如果 $\frac{|a-b|}{max(1,b)} \le 10^{-6}$ 则检查程序会认为你的答案是正确的。

样例输入1

样例输出1

1.500000000000000

样例输入2

样例输出2

2.000000000000000

样例说明

在第一个样例中，旅行可以在等概率在城市3或4结束，城市3的距离为1而城市4的距离为2，因此，期望长度为1.5.

在第二个样例中，旅行可以在城市4或5结束，两个距离都是2，因此期望长度为2。

解题思路

又是奇奇怪怪但不影响做题的翻译。原题还贴了 “期望” 的Wikipedia 链接（英文），CG由于众所周知的原因已经去掉了。

这张图仍然是一棵树，和上题的遍历方法差不太多。每个结点遍历时都要传入一个double类型概率值，代表遍历到此点的概率。因为向子节点走是等概率的，所以子节点的概率要除子节点数量，而这个数量需要提前算。

计算期望，可以选择逐点加上遍历到此点的概率，也可以额外传一个深度的变量，遍历到叶子结点时乘上到此结点的概率一起加到期望里。

题目要求相对误差不超过 $10^{-6}$ 即可，Codeforces确实是这么判的，它的测试数据和样例一样，留了15位小数；而CG似乎严格按照7位小数比对判断，所以直接输出7位小数就可以了。

7. 有效的BFS

来源：Codeforces 1037D

个人难度评级：5

问题描述

在图的BFS（广度优先搜索）中，通常采用队列来保存当前顶点的邻接点，但对对应邻接点的存入顺序没有要求，因此对于一个图的BFS结果可以有多个，在本问题中，从顶点1开始，请验证一个给定的顶点序列是否为一个有效的BFS序列？

输入形式

输入的第一行为一个整数 $n (1 \le n \le 2 \times 10^{5})$ ，表示树中节点的数量。

接下来 $n-1$ 行描述了树的边，每行包含两个整数 $x$ 和 $y(1 \le x,y \le n)$，表示对应边的两个端点，输入保证给定的图构成一颗树。

最后一行为 $n$ 个互不相同的整数 $a_{1}$、$a_2$、……、$a_n (1 \le a_i \le n)$ ，代表待检验的顶点序列。

输出形式

如果待检验的序列是一个正确的BFS序列，输出 “Yes”，否则输出 “No”。

样例输入1

样例输出1

Yes

样例输入2

样例输出2

No

解题思路

个人认为这个图用邻接链表方便点，那就不用前向星了。

BFS中，属于同一个父节点的子节点，访问的顺序是任意的，但惟需保证先访问谁就要先访问谁的儿子。整体的思路就是模拟题中的BFS过程，如果发现按照题中的序列并不能完成BFS，那么就输出no然后 return。

维护一个访问序列的队列 $visitSeq$，就是正常DFS模拟过程中的访问序列；以及一个待检查队列 $reqSeq$，来自题目要求的BFS队列。

可以想到，对于遍历到的每一个BFS结点，它的 $childNum$ 个子节点必须全部放置于 $reqSeq$ 的队首，而队首的 $n$ 个元素也必须全部是这些子节点，否则就不是一个合法的BFS序列（根据先访问谁就先访问谁的子节点）。具体一点，就是逐个检查队首的前 $childNum$ 个元素是否包含在当前元素子节点的集合中，如果包含，则此处的遍历顺序是合法的，将这个元素推入待访问队列；否则，它就不合法。

更具体地来讲，给访问过的结点打上一个 $visited$ 标记，以分辨父节点和子节点。遍历每个结点的时候，将所有 $visited==0$ 的结点扔进一个子节点的 set，它的大小就是 $childNum$。然后检查 $reqSeq$ 的前n个结点是否在set内，如果在，则将其推入 $visitSeq$，同时 reqSeq.pop()；否则，直接输出no然后 return。

对于子节点非常多的测试数据（如Codeforces原题数据48），装进set是一个非常明智的提速方法，$O(log n)$ 查找起来嗖嗖的快。同时也要注意树的遍历第一个结点必须是1，忽视这一点会卡在原题数据39。

8. 数组跳远

来源：Codeforces 1472C

个人难度评级：5

问题描述

对于一个具有 $n$ 个元素的数组 $a$, 执行以下操作：

首先，选择下标 $i(1 \le i \le n)$—— 设置为数组的开始位置，放一个标记在 $i$ 处（在值 $a_i$ 的地方）
当 $i \le n$ 时，你的得分将增加 $a_i$，且将标记向右移动 $a_i$ 个位置，也就是说用 $i+a_i$ 替换 $i$，继续这个过程
如果 $i>n$，则结束操作

例如，如果 $n=5$ 且 $a=[7, 3, 1, 2, 3]$，则可以进行以下操作

选择 $i=1$，操作过程为 $ i = 1 \overset{+7}{\longrightarrow} 8 $，最后得分为 $ a_1 = 7 $
选择 $ i = 2 $，操作过程为 $ i = 2 \overset{+3}{\longrightarrow} 5 \overset{+3}{\longrightarrow} 8 $, 最后得分为 $ a_2 + a_5 = 6 $
选择 $ i = 3 $，操作过程为 $ i = 3 \overset{+1}{\longrightarrow} 4 \overset{+2}{\longrightarrow} 6 $, 最后得分为 $ a_3 + a_4 = 3 $
选择 $ i = 4 $，操作过程为 $ i = 4 \overset{+2}{\longrightarrow} 6 $, 最后得分为 $ a_4 = 2 $
选择 $ i = 5 $，操作过程为 $ i = 5 \overset{+3}{\longrightarrow} 8 $, 最后得分为 $ a_5 = 3 $

请选择合适的开始位置，使得经过上述操作后可获得最大的分数。

输入形式

输入的第一行为一个整数 $ t $ ($ 1 \leq t \leq 10^4 $)，表示测试用例的组数。

每个测试用例的第一行为一个整数 $ n $ ($ 1 \leq n \leq 2 \cdot 10^5 $)，表示数组 $a$ 的元素个数

接下来一行包含 $n$ 个整数 $ a_1, a_2, \dots, a_n $ ($ 1 \leq a_i \leq 10^9 $)，表示数组 $a$ 的元素

输出形式

对于每个测试用例，输出独立一行，表示选择合适的开始位置后经过上述操作可以获得的最大分数。

样例输入

4
5
7 3 1 2 3
3
2 1 4
6
2 1000 2 3 995 1
5
1 1 1 1 1

样例输出

解题思路

借鉴自洛谷 @Melon_Musk 的题解。讲得清楚明白，我觉得我没必要再写了。

因为 $a[i]$ 是按照位置顺序输入的，$a[i]$ 数组没必要全存起来，随输入随处理即可，可以极大幅度节省内存消耗；此人写了一个快读，输入大量数据时能够节省时间消耗，但本题时间限制为2s，scanf实测能过，甚至cin应该也可以。

9. 踩点上课

来源：Codeforces 1520G

个人难度评级：5

问题描述

阿迪通常开着闹钟睡觉，这样他才不至于上课迟到。

他想知道能否赶上第一节课，为了不迟到，他需要知道从家到学校所需要的最少时间是多少。

阿迪生活的城市是一个 $n\times{m}$ 的矩形区域，其中每个单元 $ (i, j) $ 由一个数字 $ a_{ij} $ 来表示

数字为 $-1$ 时表示该单元被占用，禁止通行
数字为 $0$ 时表示该单元是空闲的，阿迪可以穿过
数字为 $ x $ ($ 1 \le x \le 10^9 $) 时表示该单元包含入口，需要耗费的时间成本为 $x$，包含入口的单元也是空闲的，可以自由通行

从任何包含入口的单元出发，阿迪可以去往任何包含入口的其他单元，从入口 $(i,j)$ 到入口 $(x,y)$ 的时间成本总和为 $ a_{ij} + a_{xy} $。

除了在两个包含入口的单元之间移动，他也可以在具有相邻边的未被占用的单元之间移动，耗费的时间为 $w$。实际上，他也可以进入一个包含入口的单元而不使用它。

开始时，阿迪处在左上角单元 $(1, 1)$，而学校位于右下角 $(n,m)$。

输入形式

输入的第一行包含三个整数 $n$、$m$ 和 $ w $ ($ 2 \le n, m \le 2 \cdot 10^3 $ , $ 1 \le w \le 10^9 $)，此处 $n$ 和 $m$ 是城市的大小，$w$ 是在未被占用的单元之间移动所需要的时间。

接下来的 $n$ 行每行包含 $m$ 个数 ($ -1 \le a_{ij} \le 10^9 $ )，表示对单元的描述。

输入保证单元 $(1, 1)$ 和 $(n,m)$ 是空闲的。

输出形式

输出为一个数，表示阿迪去往学校需要花费的最少时间，如果他不能去到学校，则输出 $-1$。

样例输入

5 5 1
0 -1 0 1 -1
0 20 0 0 -1
-1 -1 -1 -1 -1
3 0 0 0 0
-1 0 0 0 0

样例输出

样例说明

第一组样例的说明如下：

解题思路

英语基础还可以的同学可以去看：Codeforces Round #719 (Div. 3) Editorial - Codeforces。

简单来说，首先如果用传送门，必只能用一次以达到花费最小，这样只需要考虑用传送门和不用两种情况。不用传送门，就是找起点到终点的最短路径；而如果用传送门，则需要分别找到与起点和终点间成本最小的点（不只有 $w \times {dist(D,i)}_{min}$，还要加上该传送门的权值 $a_i$，才能代表使用该传送门的成本），然后相加。将两者比较，即可得到最小成本。

具体一点来说，就是分别从起点和终点开始两次BFS，若到达另一端则更新起点终点距离，若遇到传送门则算出成本并更新最小成本值。

注意使用long long存储与距离有关的变量；各种初始值也要设定大一些，否则无法通过Codeforces测试数据（可能会卡在 #122左右，后面几个全是大数据）。

未曾设想的道路

有一种奇怪的想法：结点数和每个结点的边数不算很多，猜想可以建图，对于每个点，与相邻能通过的点之间有长为 $w$ 的边连接；如果此点是传送门点，则与其他传送门点均有长为 $a_i+a_j$ 的边连接。然后使用Dijkstra等单源最短路算法直接算出起点到终点的距离。

10. 树的优化

来源：Codeforces 682C

个人难度评级：6

问题描述

在一个原始森林里，有人发现了一颗根编号为 $1$ 的神奇树，它的每个顶点以及每条边上都标有一个数字。

然而，他发现这颗树上有些顶点有瑕疵，也称为瑕疵点。一个顶点 $v$ 被称为瑕疵点是指在它的子树中存在点 $u$，使得 $dist(v,u)>a_u$，这里 $a_u$ 是标注在顶点 $u$ 上的数字，而 $dist(v,u)$ 是所有标注在从顶点 $v$ 到顶点 $u$ 的路径上边的数字之和。

如果一个顶点只有一条路径相连，则这个顶点是树的叶子节点。但是树的根节点是叶子节点，当且仅当数树仅有一个单一顶点，即根节点。

这人决定删除一些叶子节点，直到整颗树不存在任何瑕疵点。那么，需要删除的叶子节点的最少数是多少？

输入形式

输入的第一行为一个整数 $n$ $(1 \le n \le 10^5 )$。

接下来一行为 $n$ 个整数 $a_1$、$a_2$、…、$a_n$ $(1 \le a \le 10^9)$，这里 $a_i$ 是标注在顶点 $i$ 上的数字。

接下来的 $n-1$ 描述了树中边的情况，第 $i$ 行有两个整数 $p_i$ 和 $c_i$ $(1 \le p_i \le n, -10^9 \le c_i \le 10^9)$，这意味着在顶点 $i+1$ 和 $p_i$ 之间有边相连，其上标有数字 $c_i$

输出形式

输出一个整数，表示需要删除的最少叶子节点数。

样例输入

9
88 22 83 14 95 91 98 53 11
3 24
7 -8
1 67
1 64
9 65
5 12
6 -80
3 8

样例输出

提示

以下是可能的处理过程

解题思路

这个题我做的时候觉得挺难的，主要是没读懂，而且这个题的弯绕得很多，所以给了6级。参考了【Codeforces 682C】Alyona and the Tree - AWCXV - 博客园 (cnblogs.com)。

我们设结点 $u$ 是在结点 $v$ 子树的叶子结点，如果 $dist(v,u)>a_u$，即它们之间的边权和大于 $u$ 点的点权，那么下面的 $u$ 就会让上面的 $v$ 伤心（原题说法，即瑕疵，这里习惯了不改了）。这时候，就要把下面的 $v$ 叶子移除，来让 $u$ 不因它伤心。

能让 $u$ 结点伤心的，并不一定是叶子结点，而是任何能满足边权和大于 $v$ 点权的 $v$ 结点，即使 $v$ 在中间；而只要让 $u$ 伤心，就必须移除 $v$。题面要求我们只能移除叶子结点，这样的话，如果子树中的中间结点 $v$ 让 $u$ 伤心，必须移除 $v$ 为根节点的整棵子树。这样是完全可行的，因为上面的结点伤不伤心，跟 $v$ 的子节点一点关系都没有，爱怎么移除怎么移除，不把下面的移除干净，导致伤心的 $v$ 的还没办法移除。

也正是由于 $v$ 下面的结点和上面结点是否伤心无关，我们可以知道：设结点对 $<u,v>$ 代表下面的 $v$ 让上面的 $u$ 伤心，如果 $<u,v>$ 相比 $<p,q>$ 更靠树的根部（也就是靠上），我们可以直接删除 $v$ 的子树，如果 $<p,q>$ 的关系因删除而不再存在，也并不需要在意，正好一起切没了。

这个时候，就可以想出一个并不是非常高效的算法（但应该能应付CG，没实现，不保证）：

先使用一次DFS，求出根节点和各结点之间的边权和 $dist(1,u)$，存储，因为 $dist(u,v)=dist(1,v)-dist(1,u)$。然后使用第二轮DFS，将每个遍历到的结点作为 $u$，然后再以它为根节点向下进行一层DFS，枚举它的根节点作为 $v$。检验 $u$ 是否会被 $v$ 搞伤心，如果会，直接删除通向 $v$ 的边，代表删除下面的整棵树，不会的话则继续搜索。最后再一轮DFS得到没被删除的结点数量，计算得到删掉的数量（或者在删除结点时，以被删掉的 $v$ 为起点DFS得到被删除的结点数量），输出。

注意到一个问题：对于任意结点 $v$，不管它造成了从 $1$ 到 $v$ 之间哪个结点不高兴，$v$ 为根的树都要被删除。如果我们记录从 $1$ 到 $v$ 以 $v$ 结尾的 ** 最大 ** 边权和，就不需要判上游的特定_某个_结点是否会被搞伤心（上面算法的思想），只需要一次判断，就可以得出上游_是否会有_结点被 $v$ 搞得不伤心，从而直接决定删不删掉 $v$。

那如何得出最大边权和呢？整个过程可以直接整合进一次DFS中，就是这个算法的核心。给DFS函数传入两个变量，当前结点 $u$ 的编号和最大边权和。如果最大边权和大于该节点的权值直接返回，不再搜索下去也不计数，代表这个点被删除。否则，没被删除的点计数 + 1，然后继续DFS，分两种情况：如果当前最大边权和小于0，则传入的最大边权和就是 $u$ 与子节点间的边权；否则，传入当前最大边权和 + 上述边权。这里使用了贪心的思想，来保证边权和最大，且以当前结点 $u$ 结尾。这一段结合代码来讲，就是这样：

cpp

        if (dist> 0) //dist 是当前最大边权和
        {
            dfs(to[i], dist + weight[i]); // 链式前向星存边，边号 i，to[i] 是边的终点，weight[i] 是这条边的边权
        }
        else
        {
            dfs(to[i], weight[i]);
        }

题中数据的输入方式已经表明了谁是更靠近根的节点，我们只需要存储有向边，不会出现下面的结点连往上面结点的边，也就不再需要打标记证明哪个结点访问过。

湖南大学 2021 程序设计训练笔记 - 作业训练 2

Wed, 07 Jul 2021 00:00:00 +0000

1. 字符串反转2

个人难度评级：2

问题描述

给定一个句子（只包含字母和空格），将句子中的单词位置反转，单词用空格分割, 单词之间只有一个空格，前后没有空格。比如： “hello xiao mi”-> “mi xiao hello”

输入形式

输入数据有多组，每组占一行，包含一个句子 (句子长度小于1000个字符)

输出形式

对于每个测试示例，要求输出句子中单词反转后形成的句子

样例输入

hello xiao miI am a student

样例输出

mi xiao hello
student a am I

解题思路

对于每一行，逐个输入单词压入栈，cin.peek到回车 或者文件末尾（用EOF表示，可以用 ^Z触发）就全部输出，因为输入内容最后没有回车，只判断回车是会WA掉大部分点的。

2. 487-3279

来源：UVa 696 测试数据可能不同

个人难度评级：2

问题描述

每个人都喜欢有令人难忘的电话号码。要想让电话号码变得令人难忘的一种方法是拼出一个令人难忘的单词或短语。例如，你可以拨打滑铁卢大学的电话，拨打令人难忘的电话号码TUT-GLOP。

有时只有一部分号码被用来拼写一个单词，例如，你可以拨打310-gino从Gino’s订购披萨。

要使电话号码令人难忘的另一种方法是以一种令人难忘的方式对数字进行分组。你可以从比萨饼小屋中订购比萨饼，方法是拨打他们的 “3个10”，即号码3-10-10-10。

电话号码的标准格式是七位的十进制数字，第三和第四位之间包含连字符（例如888-1200）。电话的键盘提供字母到数字的映射，如下所示：

A, B, C映射到2

D, E, F映射到3

G, H, I映射到4

J, K, L映射到5

M, N, O映射到6

P, R, S映射到7

T, U, V映射到8

W, X, Y映射到9

Q和Z没有映射。连接符不拨号，必要时可加上或去除。TUT-GLOP的标准格式是888-4567，310-GINO的标准格式是310-4466，3-10-10-10的标准格式是310-1010。

当两个电话号码有相同的标准格式时是等价的（拨同样的号码）。

你的公司正在编制本地企业的电话号码目录，作为质量控制的一部分，你需要检查没有两个（或多个）企业具有相同的电话号码。

输入形式

输入包括一个案例。输入的第一行为一个正整数，指定目录中电话号码的数目 (最多100，000)。其余的各行列出目录中的电话号码，每个号码单独占一行。每个电话号码都是一个由十进制数字、大写字母(不包括Q和z) 和连字符组成的字符串。字符串中的七个字符或是数字或是字母。

输出形式

对于出现超过一次的每个号码，按照标准格式每个输出一行，然后是空格，接着输出出现的次数。只出现1次的电话号码不输出。

样例输入

124873279ITS-EASY888-45673-10-10-10888-GLOPTUT-GLOP967-11-11310-GINOF101010888-1200-4-8-7-3-2-7-9-487-3279

样例输出

310-1010 2487-3279 4888-4567 3

解题思路

将每个电话号码转换成int之后存储，sort一遍，然后加上横线再输出重复出现的电话号码和次数即可。

3. 缺席考试的是谁？

个人难度评级：2

问题描述

程序设计考试结束了，传来个不好的消息：有一个学生没参加考试! 需要尽快知道缺席考试的人是谁，以便尽快做出处理。

糟糕的是，尽管有签到表，但由于人数较多，签到情况比较混乱：有的签到表签在一张白纸上，有的虽然签在名册上，但并不是签在自己姓名旁，更有学生签到了别的签到表上……

现在只能根据这2n-1个姓名（名册上有n个学生姓名，签到有n-1个姓名，签到姓名和名册姓名可能混在一起了），来找到缺席考试的人是谁。唯一一个有利的条件是所有参加考试的人都签了名，且只签一次，签名也都正确无误。

现在任务交给你：编写一个程序，找出缺席考试的是谁。

输入形式

有多组测试数据。

每组测试数据开始一行，是一个正整数n，表示总人数，n=0意味着输入结束并且不需要处理。

以下2n-1行，每行一个字符串，长度不超过20，表示一个人的姓名。姓名有大小写的英文字母、常用汉字组成 (注意每个汉字占2个字节，中英文姓名都不排除有重名情况)。

40% 的测试数据1 ≤ n≤ 10；

30% 的测试数据1 ≤ n≤ 100；

20% 的测试数据1 ≤ n≤ 103；

10% 的测试数据1 ≤ n≤ 104；

提示：大量输入数据，C/C++ 输入推荐使用scanf函数

输出形式

对于每组测试数据，输出一行，只包含一个字符串，表示缺席的人的姓名。

样例输入

2
张三
张三
李四
0

样例输出

李四

解题思路

这个题很蛋疼的两个地方是：

不排除有重名的情况，所以不能简单地用bool存储是否签到2次；
签到姓名和名册姓名混在了一起，所以不能采取” 先存后删” 的策略。

但是有一点不会变：没来的人，他的名字出现次数是奇数（因为缺且仅缺了一次）。所以我建立一个pair<string,int> 数组，first存放姓名，second存放名字出现次数。直接读入2n-1行，统计每个名字出现次数，那么出现了奇数次的名字一定存在缺考情况。

中文应该不需要特殊考虑。但如果你用getline函数读取名字，记得也要用getline吸收cin读取n后的回车！用getchar会WA掉。

4. 电话号码

来源：CodeForces 898C

个人难度评级：3

问题描述

Vasya有几本电话簿，记录了他的朋友们的电话号码，每一个朋友都可以有一或几个电话号码。

Vasya决定整理关于朋友电话号码的信息。给定n个字符串，来自于Vasya的电话簿中的条目。每一条都以朋友的姓名开头，然后跟着当前条目中的电话号码个数，然后是本人的电话号码。有可能几个相同的电话被记录在同一个记录中。

Vasya还认为，如果电话号码a是电话号码b的后缀（也就是说，号码b以a结尾），这两个号码被当作同一个电话号码，那么a被认为是无城市代码，它不应该被考虑。

输出整理后Vasya朋友的电话号码信息。有可能两个不同的人有相同的号码。如果一个人有两个电话号码x和y，x是y的后缀（即y以x结尾），则不输出x。

如果Vasya的电话簿中的某些朋友记录了几次，那么只需要记录一次。

输入形式

输入第一行一个整数n(1<=n<=20)，Vasya的电话簿上的条目数。

以下n行后面是描述中的格式记录。朋友的姓名中不包含空字符，长度不超过10位，由小写英文字母组成。电话号码个数在1~~10之间。每个电话号码的长度范围在1~~10之间，可以包含前导0。

输出形式

输出Vasya的朋友的电话号码的有序信息。首先输出电话簿中的朋友数目m。

接下来的m行，包含以格式 “姓名电话号码个数电话号码1 … 电话号码k" 的条目，号码间以空格分隔。每个记录包含当前朋友的所有电话号码。

每个条目输出按照姓名字母序进行排序，电话号码按照从小到大的顺序排列（注意电话号码比较规则：“1”<“01”、“12”<“012”，依此类推）

样例输入

4ivan 3 123 123 456ivan 2 456 456ivan 8 789 3 23 6 56 9 89 2dasha 2 23 789

样例输出

2dasha 2 23 789ivan 4 2 123 456 789

解题思路

定义一个结构体，内含名字、此人的电话数目和一个电话号码数组（字符串类型）。

注意人名有重复，同样的人名要加到一起去；电话号码有后缀情况，要逐个比对，可以考虑善用substr函数。

然后是两层排序，人名和电话号码的排序。注意电话号码不能简单使用std::string重载运算符，短的电话号码被看作小的。

注意所有（最多20）个人名实际上可以都是一个人，再加上每个人名条目都最多10个号码，要过CodeForces的样例，需要把电话号码的数组开大点，不过CG上的样例非常宽松。

5. 点球大战

个人难度评级：1

问题描述

在足球比赛中，有不少赛事，例如世界杯淘汰赛和欧洲冠军联赛淘汰赛中，当比赛双方经过正规比赛和加时赛之后仍然不分胜负时，需要进行点球大战来决定谁能够获得最终的胜利。点球大战的规则非常简单，两方轮流派出球员罚点球，每方各罚5个。当5轮点球结束以后如果仍然不分胜负，则进入一轮定胜负的阶段。两方各派一名球员罚点球，直到有一方罚进而另一方没有进为止。

在北美职业冰球联赛中，也有点球大战。与足球的规则不同的是，它只先罚3轮点球，随后就进入一轮定胜负的阶段，而其他的规则完全一样。

在本题中，输入将给出每次点球是否罚进，而你的任务则是输出一个 “比分板”。

输入形式

输入包含多组数据。每组数据的第一行包含一个整数N(1<=N<=18)，表示双方总共罚了多少个点球，N=0表示输入结束。随后有N行，每行是一个如下形式的字符串：

XXXX good：表示这个点球罚进

或者XXXX no good：表示这个点球没有罚进

其中XXXX表示球员名字（全部由字母和空格组成，保证不会出现歧义）

每一行保证不超过100个字符。

XXXX和good以及XXXX和no、no和good之间保证有且只有1个空格。

good、no good都是小写。本题是大小写相关的。

数据不保证点球大战一定结束，也不保证在结束以后立即结束这组数据（即：不用判断点球大战是否结束，只用把罚进的点球往比分上加即可）。

输出形式

对每组数据，输出一个比分板。一个点球如果罚进，则在对应的地方标上’O’，如果没有进则标上’X’。先罚球的队伍的信息在上面，后罚的在下面。最右边标上两队的比分。具体格式参考样例输出。注意如果一轮点球只罚了一个，则后面那个点球对应的地方写上’-’。

样例输入

6Riise goodBallack goodGerrard no goodLampard no goodFernando Torres goodMalouda good9Christiano Ronaldo no goodMessi no goodGiggs goodAbidal no goodCarrick goodRonaldinho goodRooney goodHenry no goodTevez good0

样例输出

1 2 3 ScoreO X O 2O X O 21 2 3 4 5 ScoreX O O O O 4X X O X - 1

解题思路

如果你知道了string的find函数，那么这个题非常简单，我觉得不需要说思路。

6. 飞行棋

来源：HDU 2240（很可能无法访问）

个人难度评级：2

问题描述

大家当年一定都下过飞行棋吧。现在Lele和Yueyue要下的棋和这个很相似，只是更简单一点而已。

棋盘由N个格子组成，分别标记为第0格到第N-1格。格子分为两种，一种是普通格子，即表示在该格可以停留。否则是特殊的格子，一旦走到上面，就要根据上面标记的数飞到相应的格子上。如果飞到一个特殊的格子上，则可以继续飞。

除了第0格外，其他格子都只能容纳一个玩家。即一旦A玩家已经在某个格子上，B玩家又走到这里，A玩家则会被踢回第0格，而B玩家留在这个格子上面。

第N-1个格子是终点，一旦一个玩家走到这个格子上，该玩家获胜，游戏结束。

刚刚开始时，两个玩家都站在第0格上，依次扔骰子，根据骰子显示的点数走相应的格子数。比如，玩家在第0格，扔出了5点，则会走到第5个格子上。如果玩家走得超出了棋盘的范围，则要往回走一定的步数。比如，棋盘一共有7(0~6) 个格子, 玩家在第4格上，扔出了6点，最终他会走到第2格上 (4->5->6->5->4->3->2)。

根据观察，骰子扔出来的数也是有规律的。
对于每一盘棋，扔出的第一个点数为F0=(A*C+B)%6+1, 第二个点数为F1=(A*F0+B)%6+1, 第三个点数为F2=(A*F1+B)%6+1 …. 依此类推。

每一盘棋都是由Lele先走，现在就请你当裁判，看谁能获胜。

输入形式

      本题目包含多组测试，请处理到文件结束。
      每组数据占两行。
      第一行有4个整数N,A,B,C(含义见题目描述，6<N<200,0<=A,B,C<=2^31)。
      第二行有N个字符串，分别表示棋盘上第0个到第N-1个格子的内容。两个字符串之间用一个空格分隔开。

如果字符串为 “N”, 则表示这个格子为普通格子。否则字符串为 “GX”(X为0到N-1之间的整数) 的形式，其中X表示玩家走到这个格子时，要马上飞到第X个格子。
数据保证第0个和第N-1个格子一定为 “N”。

输出形式

对于每组数据，在一行内输出结果。
如果Lele能赢这盘棋，则输出 “Lele”, 如果Yueyue赢的话，就输出 “Yueyue”。

样例输入

7 1 0 6N G3 N N N N N7 1 0 6N G4 N N N N N

样例输出

LeleYueyue

样例说明

测试用例保证能有确定结果。

解题思路

模拟就完事了，模拟每一步的走法即可。原题是有是否进行不完的判断的，如果有余力可以思考一下。

7. 棋盘

问题描述

棋盘是指一个行和列编号从1~N的NxN的二进制矩阵，当行号和列号之和为偶数时该矩阵对应位置为黑色的 (1)，否则为白色的 (0)。以下图（没了）示为N=1、2、3时的棋盘。

給出一个NxN的二进制矩阵，请找出位于该矩阵内的最大尺寸的完整棋盘，以及最大尺寸棋盘的数量（棋盘可以交叠）。

输入形式

每个测试用例的第一行是一个正整数N(1<=N<=2000)，表示給定矩阵的行数和列数，接下来的N行描述了这个矩阵：每行有N个字符，既可以是 “1”（代表黑块），也可以是“0”（代表白块）。矩阵至少包含一个“1” 字符。

输出形式

输出最大尺寸棋盘的行列的大小，以及最大棋盘的个数，以空格分隔。

样例输入

50010111010001010101011101

样例输出

3 3

解题思路

棋盘用bool二维数组存储即可，反正只有0和1两种值。

枚举棋盘左上角起始点，不是黑的直接跳过。对于黑，先得出一个边长上限，就是起始点距离右边和下边的距离最小值。然后枚举边长，大可以先从2开始，毕竟起始点本身是黑的就一定是个棋盘。由于每次增加边长，相比上一个边长增加的只有最右边和最下边一条，所以在上个边长能够成立的情况下，只需要检查新增加的两条边是否合理即可；相反，不能成立的话，直接break即可，边长小的都不成立那大的更不行了。

验证颜色是否正确的时候，需要注意 “当行号和列号之和为偶数时 “中求和时，以 ** 验证中的棋盘起始点 ** 作为原点，而真正使用的坐标是以 ** 整个大棋盘的 (0,0)** 作为原点。看不懂的话，建议直接去翻我代码……

8 .Engine

来源：HDU 2532（若无法访问，可以看 Vjudge）

个人难度评级：3

问题描述

谷歌、百度等搜索引擎已经成为了互连网中不可或缺的一部分。在本题中，你的任务也是设计一个搜索论文的搜索引擎，当然，本题的要求比起实际的需求要少了许多。
本题的输入将首先给出一系列的论文，对于每篇论文首先给出标题，然后给出它被引用的次数。然后会有一系列的搜索询问，询问标题中包含特定关键词的论文有哪些。
每一个询问可能包含多个关键词，你需要找出标题包含所有关键词的论文。
“包含” 必须是标题中有一个词正好是给定的关键词，不区分大小写。
对每个询问，都按被引用的次数从多到少输出满足条件的论文的标题。如果有被引用的次数相同的论文，则按照论文在输入中的顺序排列，先给出的论文排在前面。

输入形式

输入包含多组数据。
每组数据首先有一行包含一个整数N(1<=N<=1000)，表示论文的数目，N=0表示输入结束。每组论文的信息第一行是论文的标题，由字母（大小写均可）和空格组成，不超过10个词，每个词不超过20个字符，标题总共不超过250个字符。第二行是一个整数K(0<=K<=108)，表示它被引用的次数。在论文信息结束以后，有一行包含一个整数M(1<=M<=100)，表示询问的数目。接下来有M行，每行是一个询问，由L(1<=L<=10) 个空格分开的词构成，每个词不超过20个字符。

输出形式

对每个询问，按照题目给定的顺序输出满足条件的论文的标题；如果没有满足条件的论文，就不输出。在每组询问的输出之后输出一行 “***”，在每组数据的输出之后输出一行 “—”。

样例输入1

6Finding the Shortest Path120Finding the k Shortest Path80Find Augmenting Path in General Graph80Matching in Bipartite Graph200Finding kth Shortest Path50Graph Theory and its Applications406shortest pathk shortest pathgraphpathfindapplication0

样例输出1

Finding the Shortest Path
Finding the k Shortest Path
Finding kth Shortest Path
***
Finding the k Shortest Path
***
Matching in Bipartite Graph
Find Augmenting Path in General Graph
Graph Theory and its Applications
***
Finding the Shortest Path
Finding the k Shortest Path
Find Augmenting Path in General Graph
Finding kth Shortest Path
***
Find Augmenting Path in General Graph
***
***
---

样例输入2

1
Finding the Shortest Path
120
2
Path

Pat
0

样例输出2

Finding the Shortest Path
***
***
---

解题思路

首先要说明的是，样例2原题里是没有的，而个人认为中间的空行是多余的，删掉之后才能得到期望输出。

这题就是个大模拟，思路其实不是很难找，但是要写好还是很费精力和时间的。

我定义了一个paper类，包含名字、关键词数组、关键词个数和引用次数，还包含一个成员函数，负责将名字转换成关键字。所有的这些都是public。分隔符是空格，那么使用字符串流来转换很方便，只需要调用自行实现的全部转小写的函数将名字转换后推入流，再一个个推出即可。

比对关键字的时候，查找的关键字要全部在某一文献的关键字列表里，才能算找到了合适的结果，不能够使用string的find() 成员函数查找子串。

将论文全部输入之后直接使用stable_sort和自定义比较函数排序，就不需要找到符合条件的论文之后存储起来再排序了。

此题数据特别多，要格外注意各数据的初始化问题！

9. 字符串压缩

来源：Codeforces 1120C

个人难度评级：6

问题描述

给定一个由n个小写字母组成的字符串s，需要使用最少数量的钱币来压缩它。

压缩该字符串，必须将s表示为多个相互连接的非空字符串: s=t1t2…tk，其中第i个字符串按照下列两种方法之一编码：

如果 | ti|=1，也就是说 ti为单个字符组成的字符串，编码时需要支付a个钱币
如果ti是t1t2…ti-1的子串，编码时需要支付b个钱币

你的任务是计算压缩给定的字符串需要花费的最小钱币数。

输入形式

输入的第一行包含3个用空格分隔的正整数：n、a和b(1≤n、a、b≤5000)，第二行为一个长度为n的小写字符串。

输出形式

输出一个整数，表示你需要为压缩s所需要支付的最小钱币数。

样例输入1

3 3 1
aba

样例输出1

样例输入2

4 1 1
abcd

样例输出2

样例输入3

4 10 1
aaaa

样例输出3

解题思路

不会，DP题谁会做谁做去。

10. 拼写检查

来源：POJ 1035

个人难度评级：2

问题描述

       作为一个新的拼写检查程序开发团队的成员，您将编写一个模块，用已知的所有形式正确的词典来检查给定单词的正确性。
       如果字典中没有这个词，那么可以用下列操作中的一个来替换正确的单词（从字典中）：
       1. 从单词中删除一个字母；
       2. 用一个任意字母替换单词中的一个字母；
       3. 在单词中插入一个任意字母。
       你的任务是编写一个程序，为每个给定的单词找到字典中所有可能的替换。

输入形式

输入的第一部分包含所有字典中的词，每个单词占用一行，以一个单一字符 “#” 作为结束。所有单词都不相同，字典中至多1000个单词。

接下来的部分包含所有需要进行检查的单词，同样每个单词占用一行。这部分也以一个单一字符 “#” 作为结束。至多有50个单词需要检查。

在输入中所有的单词（字典中的和需要检查的）都仅由小写字母组成，每个最多包含15个字符。

输出形式

对于每个在输入中出现的单词，按照它们在输入的第二部分出现的顺序输出一行。如果该单词是正确的（也就是说它包含在字典中）则输出信息：“is correct”；如果该单词不正确，则首先输出该单词，然后输入符号 ‘:’（冒号），之后空一格，写出它所有可能的替代，以空格分隔。这些替代的单词按照它们在字典中（输入的第一部分）出现的顺序写出。如果没有可替代的单词，则在冒号后面直接输出换行。

样例输入

iishashavebemymorecontestmetooifaward#meawaremcontesthavooorifimre#

样例输出

me is correctaware: awardm: i my mecontest is correcthav: has haveoo: tooor:i is correctfi: imre: more me

解题思路

先把字典中的词语存到数组里，然后再逐个询问比对即可。难点在于删除和增加字母的检查。增删字母的判断函数可以共用，只需将函数的两个参数对调即可。修改的要求是长度相同，而增删的长度差只能为1。

11. 最小的k个数

个人难度评级：1

问题描述

输入n个整数，找出其中最小的k（k<=n）个不同数。例如输入4,5,1,6,1,7,3,8这8个数字，则最小的4个数字是1,3,4,5。

输入形式

每个测试案例包括2行：

第一行为2个整数n，k(1<=n，k<=200000)，表示数组的长度。

第二行包含n个整数，表示这n个数，数组中的数的范围是 [0,1000 000 000]。

输出形式

对应每个测试案例，输出最小的k个数，并按从小到大顺序打印 (如果不存在k个不同的数，则按照实际数量进行输出)。

样例输入

8 4
4 5 1 6 2 7 3 8

样例输出

1 2 3 4

训练提示

1、数的范围从0到1000000000，使用数组记录那些数出现过就不是太合适

2、需要去除重复的数，需要从小到大排序 —-set就是一个不错的选择

解题思路

没必要专门去重，更没必要用什么set，直接存数组sort一遍过。只需要检查上一个数是否与要输出的数相等，相等即跳过，就顺便完成了去重。

12. 绩点计算

个人难度评级：1

问题描述

学校对本科生的成绩施行绩点制（GPA）。将学生的实际考分根据不同学科的不同学分按一定的公式进行计算。规定如下：

实际成绩绩点

90-100 4.0

85-89 3.7

82-84 3.3

78-81 3.0

75-77 2.7

72-74 2.3

68-71 2.0

64-67 1.5

60-63 1.0

60以下 0

1. 一门课程的学分绩点 = 该课绩点 * 该课学分

2. 总评绩点 = 所有学科绩点之和 / 所有课程学分之和

现要求你编程求出某人的总评绩点 (GPA)

输入形式

第一行总的课程数n

第二行相应课程的学分（两个学分间用空格隔开）

第三行对应课程的实际得分

此处输入的所有数字均为整数

输出形式

输出有一行，总评绩点，保留两位小数

样例输入

5
4 3 4 2 3
91 88 72 69 56

样例输出

2.52

解题思路

不讲了，太简单。

要是得绩点也能像这道题这么简单就好了。

13. xxx定律

个人难度评级：1

问题描述

对于一个正整数n，如果是偶数，就把n砍掉一半；如果是奇数，把n变成3*n+ 1后砍掉一半，直到该数变为1为止。
请计算需要经过几步才能将n变到1，具体可见样例。

输入形式

测试包含多个用例，每个用例包含一个整数n, 当n为0时表示输入结束。（1<=n<=10000）

输出形式

对于每组测试用例请输出一个数，表示需要经过的步数, 每组输出占一行。

样例输入

3
2
0

样例输出

5
1

解题思路

太水了…… 这题我连打表都懒得打。

14. 数的距离差

个人难度评级：1

问题描述

给定一组正整数，其中最大值和最小值分别为Max和Min, 其中一个数x到Max和Min的距离差定义为：

$ | | x-Max | -(x-Min) | $

其中abs() 为求一个数的绝对值

输入形式

包括两行，第一行一个数n，表示第二行有n个正整数

输出形式

输出一个数x，该数在所有n个数中的距离差最小；如果有两个数的距离差都是最小，输出较小的哪个

样例输入1

5
3 1 7 5 9

样例输出1

样例输入2

3
1 3 2

样例输出2

解题思路

没啥难的，录进来sort一遍，逐个算距离差再比较即可。

有一个不成熟的猜想：距离差最小的，并不是中位数，而是与绝对值相差最小的数。

15. 亲和数

来源：HDU 2040（无法访问请看 Vjudge 或者Wayback Machine）

个人难度评级：1

问题描述

古希腊数学家毕达哥拉斯在自然数研究中发现，220的所有真约数 (即不是自身的约数) 之和为：

$ 1+2+4+5+10+11+20+22+44+55+110＝284 $

而284的所有真约数为1、2、4、71、142，加起来恰好为220。人们对这样的数感到很惊奇，并称之为亲和数。一般地讲，如果两个数中任何一个数都是另一个数的真约数之和，则这两个数就是亲和数。
你的任务就编写一个程序，判断给定的两个数是否是亲和数。

输入形式

输入若干行数据（大于0），每行一个实例, 包含两个整数A,B；其中0 <= A,B <= 600000 ;

输出形式

对于每个测试实例，如果A和B是亲和数的话输出YES，否则输出NO

样例输入

220 284
100 200

样例输出

YES
NO

解题思路

没啥难的，不说了

16. 金币

来源：NOIP 2015 普及组第一题（数据已加强）（卧槽竟然是NOIP的题…… 要不是当年我做过我还真想不到）

个人难度评级：2

问题描述

国王为他的忠诚的骑士支付金币。在他服役的第一天，骑士收到一枚金币。在接下来2天（第二天和第三天的服务），骑士每天收到2金币。在未来三天（第五，第四，和第六天的服务），骑士每天收到三金币。在未来四天（第七，第八，第九，和第十天的服务），骑士每天收到四金币。这一模式的付款方式将继续下去：在接下来的n天骑士每天将收到n枚金币，而在接接下来的n+1天每天将收到n+1枚金币，这里n是正整数。你的程序将确定在任何给定的天数（从第1天开始）支付给骑士的金币总数。

输入形式

输入包含至少一行，但不超过21行。输入的每一行包含一个测试案例的数据，即一个整数（1~10000），代表天数。

输出形式

每一行输出对应一个测试用例，由天数和支付给骑士的金币总数量组成，中间用空格分隔。

样例输入

样例输出

10 30
6 14
10000 942820
1000 29820
21 91
22 98

解题思路

就是个模拟题，按照题意模拟下去即可，不需要花里胡哨的方法即可解决。

17. 小A的计算器

个人难度评级：1

问题描述

以往的操作系统内部的数据表示都是二进制方式，小A新写了一个操作系统，系统内部的数据表示为26进制，其中0-25分别由a-z表示。
现在小A要在这个操作系统上实现一个计算器，这个计算器要能实现26进制数的加法运算。你能帮小A实现这个计算器吗？

输入形式

输入的第一行包括一个整数N(1<=N<=100)。
接下来的N行每行包括两个26进制数x和y，它们之间用空格隔开，每个数的位数最多为10位, 我们可以保证相加的结果的位数最多也是10位。每个数会用小A所设计的操作系统中的表示方法来表示，如：bsadfasdf。即每个数的各个位均由26个小写字母a-z中的一个来表示。

输出形式

输出x和y相加后的结果，结果也要用题目中描述的26进制数来表示。

样例输入

4
ba cd
c b
b c
ba c

样例输出

dd
d
d
bc

解题思路

高精度加法 + 进制转换。

先用string输入，然后将 ** 每一位 ** 转换为十进制数之后倒序导入vector存储。位数不足的记得补0。设置一个进位的临时数组，然后按照竖式计算方法计算，之后再转换回26进制倒序导入string输出。

18. 小丑排序

来源：ACM/ICPC 2004（贝勒大学原题面存档）

个人难度评级：1

问题描述

你在信天翁马戏团（是的，它是由一群小丑组成）从事管理工作，你刚刚写完一个程序的输出是将他们的姓名按长度为非递减的方式排列，名称列表（使每名至少只要它之前的）。然而，你的老板不喜欢这种输出方式，而是希望输出出现更对称，较短的字符串在顶部和底部，而较长的字符串在中间。他的规则是，每一对名称都是在该列表的相对的两端，并且在该组中的第一个名字总是在列表的顶部。比如在下面的第一个例子中，Bo和Pat是第一对，Jean和Kevin是第二对，等等。

输入形式

输入由1到多个字符串集合组成，最后一行为0表示输入结束，每个集合开始于一个整数n，表示该集合字符串的个数，接下来n行由n个字符串按长度非递减的方式排列，每个集合至少包含一个但不超过15个字符串，每个字符串不超过25个字符。

输出形式

对于每个集合，第一行输出 “set-n”, n从1开始，接下来的若干行对应输入每个集合重新排列的结果，如样例所示。

样例输入

7
Bo
Pat
Jean
Kevin
Claude
William
Marybeth
6
Jim
Ben
Zoe
Joey
Frederick
Annabelle
5
John
Bill
Fran
Stan
Cece
0

样例输出

set-1
Bo
Jean
Claude
Marybeth
William
Kevin
Pat
set-2
Jim
Zoe
Frederick
Annabelle
Joey
Ben
set-3
John
Fran
Cece
Stan
Bill

解题思路

看不懂题面？哦上帝，这该死的翻译，我真想用隔壁约翰叔叔的靴子狠狠踢他的屁股！说真的，这直译还不如看英文原版。

这不是排序题，题目顺序已经排好了！只要隔一个压一个栈，剩下的原样输出即可。

19. 数圈

个人难度评级：1

问题描述

以1为中心，用2,3,4, …, n, …, n*n的数字围绕着中心输出数圈，如若n=4，则

7 8 9 10

6 1 2 11

5 4 3 12

16 15 14 13

输入形式

一个整数n(1<=n<=10)

输出形式

数圈矩阵

样例输入

样例输出

21 22 23 24 25
20 7 8 9 10
19 6 1 2 11
18 5 4 3 12
17 16 15 14 13

解题思路

打表专用题，这题打表不光评测的时候输出快，而且写代码也又快又省力，我觉得打表才是这题的正解（逃）。

每个n对应的圈，实际上都可以看作n=10的子圈，所以把n=10的情况打成表如下，然后再记录每个n要把哪一块切下来输出即可。附上完整数表：

int numCircle[10][10] = {
    {73, 74, 75, 76, 77, 78, 79, 80, 81, 82},
    {72, 43, 44, 45, 46, 47, 48, 49, 50, 83},
    {71, 42, 21, 22, 23, 24, 25, 26, 51, 84},
    {70, 41, 20, 7, 8, 9, 10, 27, 52, 85},
    {69, 40, 19, 6, 1, 2, 11, 28, 53, 86},
    {68, 39, 18, 5, 4, 3, 12, 29, 54, 87},
    {67, 38, 17, 16, 15, 14, 13, 30, 55, 88},
    {66, 37, 36, 35, 34, 33, 32, 31, 56, 89},
    {65, 64, 63, 62, 61, 60, 59, 58, 57, 90},
    {100, 99, 98, 97, 96, 95, 94, 93, 92, 91}};

20. 锤子剪刀布

个人难度评级：1

问题描述

大家应该都会玩 “锤子剪刀布” 的游戏。现给出两人的交锋记录，请统计双方的胜、平、负次数，并且给出双方分别出什么手势的胜算最大。

输入形式

输入第1行给出正整数N（<=105），即双方交锋的次数。随后N行，每行给出一次交锋的信息，即甲、乙双方同时给出的的手势。C代表 “锤子”、J代表 “剪刀”、B代表 “布”，第1个字母代表甲方，第2个代表乙方，中间有1个空格。

输出形式

输出第1、2行分别给出甲、乙的胜、平、负次数，数字间以1个空格分隔。第3行给出两个字母，分别代表甲、乙获胜次数最多的手势，中间有1个空格。如果解不唯一，则输出按字母序最小的解。

样例输入

10
C J
J B
C B
B B
B C
C C
C B
J B
B C
J J

样例输出

5 3 2
2 3 5
B B

解题思路

这种水题挺讨厌的，完全没难度，但很占用时间（我写了1.7KiB，有这时间干啥不好？）。

21. 新型冠状病毒（COVID19）传播

个人难度评级：4

问题描述

在以习近平同志为核心的党中央的正确领导下，我国新冠疫情得到了有效控制。防控新冠病毒，必须时刻引起大家的足够重视，特别是人员集中活动场所，保持好社交距离。

然而，在大洋彼岸的 $M$ 国，人们对COVID19并未引起足够重视，他们的领导人川建国同志甚至对居家隔离、戴口罩以及保持社交距离等措施非常不屑，该国疫情已经完全失控。

在一个风景秀丽的小镇，一天早上，有 $N$ 名晨跑爱好者（编号 $1-N$）沿着优雅的江边景观道朝同一方向进行晨跑，第 $i$ 名跑者从位置 $S_i$ 处起跑，且其速度为 $V_i$。换句话说，对所有的实数 $t \ge 0$，在时刻 $t$ 时第 $i$ 名跑者的位置为 $S_i+V_i \cdot t$。

很不幸的是，其中一名跑者在 $t=0$ 的时刻感染了病毒，且是无症状感染者，这种病毒只会在同一时刻处在同一位置的跑者之间传播，新感染了病毒的跑者也会感染其他人，很显然，等待足够长的时间，那么病毒会感染一些特定的跑者。

事后发现其中有一名跑者感染了新冠病毒，如果此人就是在 $t=0$ 时刻的那名感染者，那么，在 $N$ 名晨跑爱好者中会有多少人感染新冠病毒？

输入形式

输入包含三行：

第一行包含为两个整数 $N$ 和 $K$，分别表示运动员的人数以及开始时感染了病毒的跑者编号。
第二行包含 $N$ 个正整数 $S_1$、$S_2$、…、$S_N$，用空格隔开，分别表示跑者的起始位置。
第三行包含 $N$ 个正整数 $V_1$、$V_2$、…、$V_N$，用空格隔开，分别表示跑者的速度。

输出形式

输出为一个整数，表示最终被感染人数。

样例输入

6 3
3 9 8 5 7 5
6 6 5 4 6 3

样例输出

评分标准

对于50% 的评测用例，$0 \lt K \le N \le 102$

对于70% 的评测用例，$0 \lt K \le N \le 104$

对于90% 的评测用例，$0 \lt K \le N \le 106$

对于100% 的评测用例，$0 \lt K \le N \le 107$

详细题解

这题似乎有点意思，是道自创题，值得好好说一说。不过由于本人数学过于弱鸡，这里并没有严格的数学证明。

起初的想法是，对于每一个人的行动路线，可以画出一条一次函数_yi=si+vi*t_。只要遍历一遍其他跑者，与被感染者直线在y轴右侧会相交（下文”相交 “均指y轴右侧）的，就是被感染的人，是一个O(n) 的算法。因为相遇距离设定可以是无限远，所以不能枚举距离模拟跑的过程。得了20分。

核心是用下面的函数判断两条直线是否相交，也就是是否会被感染。Pos 指的是初始位置，也就是y轴截距，而 Speed 代表速度，也就是斜率。

cpp

bool checkInfection(const int &sourcePos, const int &sourceSpeed, const int &targetPos, const int &targetSpeed)
{
    if ((sourcePos> targetPos && sourceSpeed <targetSpeed) || (sourcePos < targetPos && sourceSpeed> targetSpeed) || (sourcePos == targetPos))
    {
        return true;
    }
    else
    {
        return false;
    }
}

然后重新看题面，发现有一句话：新感染了病毒的跑者也会感染其他人。于是就想到一轮一轮感染，每轮都将每个没感染的人与每个已经感染的人对应的直线作比较，如果相交则将其加入已感染的集合；以此循环，直到某一轮没有人被传染。有Floyd-Warshall算法的感觉，是不是？看了眼数据范围，好家伙，107，我这O(n3) 的算法还是迟早歇着吧。不过粗略来看，应该能过50% N<=100的数据。

于是开始研究一层循环就能搞定的方法，将时间复杂度压缩到O(n)。我们刚刚提到，一个人的直线只要与感染者所在的直线相交，那么他肯定会被感染。那么，一个跑得快的感染者也可以感染遇到的跑得比香港记者还快更快的感染者，一个跑得慢的感染者也可以感染遇到的跑得更慢的感染者。最终，就体现在被感染的人中，有一个跑得最快的，和一个跑得最慢的，他们在_x-t_图上组成了类似于上界和下界的一个区域，如下图。

那两条蓝线代表了不断传染最快和最慢的人的过程，落实到程序上也就是维护两个speed和position的下标值，分别代表跑得最快和最慢的人，初始值均为0号患者（即初始被感染的人），如果有能和最快的人对应直线相交且speed更大的人，说明能够传染他，将值更新为这个人对应的下标值，正如图中上方曲线的两次弯折；对跑得最慢的人也是同样的处理办法。

发现什么了吗？这个上界和下界，就是会不会被传染的界限。不过，既然直线可以无限延伸，那么我们可以去掉中间逐渐感染的过程，直接感染最快和最慢的那两个人，就变成了这样：

前后两种方式，虽然过程不同，但感染的结果是等效的。代表最快最慢的直线，一定会与0号感染者直线相交，那么只需要一直选取和0号感染者直线相交，而且比最快更快 / 比最慢更慢的人来更新最快 / 最慢下标值即可，而不需要每次都比较”和最快直线相交 “且” 比最快更快 “，或者” 和最慢直线相交 “且” 比最慢更慢“，省下一次比较。

判断是否穿过这两条折线共三条直线，分两种情况：

第一种是判断是否与0号感染者的直线相交；
第二种是判断是否与后面2条直线相交。

满足一种就会被传染。我们刚刚需要一次循环来找最快最慢的跑者，判断这些直线是否与0号直线相交，那么对于相交的直线可以直接打上infected标记，顺便进行第一种情况判断，无需进行第二种判断（直接continue）。第二步的标准又可以转化为”不在上界直线的上方 “且” 不在下界直线的下方“，其中上方和下方指的是在y轴右侧，函数值永远更大 / 更小，自然也不会相交。

还记得刚刚那个判断函数吗？我将它改成了下面的样子：

cpp

int checkInfection(const int &sourcePos, const int &sourceSpeed, const int &targetPos, const int &targetSpeed) // 返回值：1 - 在上方 0 - 相交 -1 - 在下方
{
    if ((sourcePos> targetPos && sourceSpeed <targetSpeed) || (sourcePos < targetPos && sourceSpeed> targetSpeed) || (sourcePos == targetPos))
    {
        return 0;
    }
    if ((targetPos> sourcePos) && (targetSpeed>= sourceSpeed))
    {
        return 1;
    }
    return -1;
}

这样在一个函数里，可以一次判断target直线位于source直线上方、下方还是相交。关于它的理解，可以画个图。

然后统计被打上标记的人数量（可以合在第二种情况判断的函数一起完成），输出即可。

总共四次循环，都为1层，也就是O(n) 的复杂度，其中两层循环还是输入数据用的。

湖南大学 2021 程序设计训练笔记 - 作业训练 1

Mon, 05 Jul 2021 00:00:00 +0000

作业训练1

1. 众数

个人难度评级：1

问题描述

一组数据中出现最多的数，称为众数。比如

1 2 3 3

众数为3。一组数据中也可能有多个众数，以最先出现的作为众数。比如

2 2 3 3

众数为2。

问题是一组按升序排好的数据，指出它的众数。

输入形式

有多组测试数据（不超过100组测试数据）。

每组测试数据占两行，第一行是正整数N：表示这组测试数据中数据项数。

第二行是N个用空格隔开的正整数，表示这组测试数据的数据元素。每个数据元素都不大于10000。

N=0，表示输入结束，并且不需要处理。

40% 的测试数据N 1 ≤N≤ 10；

30% 的测试数据N 10 < N≤ 100；

20% 的测试数据N 100 < N≤ 1000；

10% 的测试数据N 1000 < N≤ 10000；

输出形式

对于每组测试数据，输出一行包含一个正整数：对应的众数。

样例输入

text

样例输出

text

1
2

3
2

解题思路

使用桶排序的思想，设一个数组，存储每个数的出现次数。再遍历这个数组，取最大值。

数据是按升序排好的，所以也许一遍循环能走完，而且能省下桶排的数组空间？

2. 错误的里程碑

个人难度评级：2

问题描述

三月八日，小明买了台新车。但很快小明发现汽车的里程表有问题：里程表上每一位都不显示数字3和数字8，也就是说直接从数字2跳到数字4，直接从数字7跳到数字9。小明纳闷：这车到底行驶里程是多少。

现在，小明向你求助：根据里程表显示的数字，给出真实的行驶里程。

输入形式

输入有多组测试数据。

输入第一行正整数T，表示有多少组测试数据。

后面有T行，每行一个非负整数，表示里程表显示数字，里面不含有数字3和8。该数字不超过10位。

40% 的测试数据组数T 10≤T≤ 102；

30% 的测试数据组数T 102≤T≤ 103；

20% 的测试数据组数T 103≤T≤ 104；

10% 的测试数据组数T 104≤T≤ 105；

输出形式

对于每组测试数据，输出一个整数占一行：真实的行程里程。

样例输入

text

样例输出

text

解题思路

实际上这是一个8进制里程表，因为只有0、1、2、4、5、6、7、9，也就相当于0、1、2、3、4、5、6、7。做一个八进制转十进制即可。可能需要使用long long类型。

3. 拳王阿里

此题有些问题，暂不处理。

4. 欧洲冠军联赛

个人难度评级：2

问题描述

欧洲冠军联赛常被誉为全世界最具影响力的俱乐部级赛事。在比赛的小组赛阶段，欧洲的各个足球俱乐部被分为八个小组，每个小组中四支球队。每个小组中的球队按照如下规则排序：

球队会根据比赛结果获得积分。一场比赛的双方被称为主队和客队。如果其中一方进球数多于另一方，那么进球较多的一方获得3分，另一方获得0分。如果双方打成平手，则各得1分。
球队的净胜球数是其进球数减去失球数（不考虑该球队在比赛中作为主队还是客队）。
积分较高的球队排名更加靠前。
如果两支球队积分相同，那么净胜球数较多的球队排名靠前。

小组的各队伍进行循环赛，即每两支球队之间进行两场比赛，双方交替作为主队。给定一个小组内12场比赛的结果，请求出小组的出线队伍：即排名第一和第二的两支球队。

保证答案唯一。

输入形式

输入的第一行包含一个整数T，代表测试数据的组数。接下来是T组数据。

每组数据共有12行，每行描述一场比赛，格式为：“主队队名主队进球数vs. 客队进球数客队队名”，其中 “主队队名” 和“客队队名”为字符串，“主队进球数”和 “客队进球数” 为两球队在本场比赛中各自的进球数量。

1 ≤ T ≤ 50
球队队名仅包含小写英文字母
球队队名长度不超过10个字符
0 ≤ 进球数 ≤ 100

输出形式

对于每组数据，输出一行，包含两个字符串，代表排名第一和第二的球队的队名。

样例输入

text

2
manutd 8 vs. 2 arsenal 
lyon 1 vs. 2 manutd 
fcbarca 0 vs. 0 lyon 
fcbarca 5 vs. 1 arsenal 
manutd 3 vs. 1 fcbarca 
arsenal 6 vs. 0 lyon 
arsenal 0 vs. 0 manutd 
manutd 4 vs. 2 lyon 
arsenal 2 vs. 2 fcbarca 
lyon 0 vs. 3 fcbarca 
lyon 1 vs. 0 arsenal
fcbarca 0 vs. 1 manutd
a 3 vs. 0 b 
a 0 vs. 0 c 
a 0 vs. 0 d 
b 0 vs. 0 a 
b 4 vs. 0 c 
b 0 vs. 0 d 
c 0 vs. 0 a 
c 0 vs. 0 b 
c 1 vs. 0 d 
d 3 vs. 0 a 
d 0 vs. 0 b 
d 0 vs. 0 c

样例输出

text

1
2

manutd fcbarca 
d b

样例说明

第一组数据：每支球队的积分与净胜球数分别为：

manutd：16分，净胜球数12。
manutd：8分，净胜球数4。
manutd：5分，净胜球数 −5。
manutd：4分，净胜球数 −11。

第二组数据：每支球队的积分与净胜球数分别为：

d：7分，净胜球数2。
b：7分，净胜球数1。
a：7分，净胜球数0。
c：7分，净胜球数 −3。

所有球队的积分相同，但是净胜球数较多的队伍排名更加靠前。

解题思路

使用结构体存储球队的名称、净进球数和得分，使用一个结构体数组存储所有球队信息。

注意找不到已记录球队就新建球队的操作。

5. 合法的括号串

个人难度评级：3

问题描述

一个合法的括号串，是指只包含括号的串，如果满足如下条件：

（1）<> () [] {} 这四对括号是合法的；

（2）如果r是合法括号串，则 <r> (r) [r] {r} 也是；

（3）如果r，s是合法括号串，则rs也是；

所以 «» , [<>{}(())],[({<>})] 是合法的括号串，而)(,[( ])就不是。

输入形式

输入第一行正整数t (10 ≤ n ≤ 100)，表示有多少组测试数据。

后面有t行，每行一个只包含8种括号符号的括号串。

40% 的括号串的长度L 2 ≤ L≤ 20；

30% 的括号串的长度L 2 ≤ L≤ 200；

20% 的括号串的长度L 2 ≤ L≤ 2000；

10% 的括号串的长度L 2 ≤ L≤ 20000；

输出形式

对于每组测试数据，如果括号串是合法的，输出 “Yes”（输出没有引号）占一行，否则，输出 “No”（输出没有引号）占一行。

样例输入

text

6
<<>> 
)(
[<>{}(())]
[({<>})]
[(])
<([{

样例输出

text

Yes
No
Yes
Yes
No
No

解题思路

括号配对是老例题了。使用栈来存储前面未配对的左括号，遇到右括号检验一下是否匹配，然后弹栈。惟需注意：

整组数据算完之后将栈清空，否则下一组即使匹配，最后也会栈内还有元素而不匹配；
弹栈之前检测栈空，这个应该很容易看出来，一般样例就能反映。

6. 世界杯来了

个人难度评级：3

问题描述

2018年俄罗斯世界杯结束了，法国获得冠军，全世界球迷度过了一个非常愉快的夏天。作为中国球迷，不能总是看别人踢球，这不福利来了，根据FIFA（国际足联）及全体成员协会的一致决定，2118年世界杯将在中国举办，作为东道主，中国队将无需参加预选赛而直接参加决赛阶段的比赛。

比赛规则如下：

总共n（n为偶数）个球队参加比赛
按照分组赛积分排名，前n/2的球队进入淘汰赛
积分排名的规则如下：球队获胜得3分，平局得1分，失利得0分，按照积分递减、净胜球递减以及进球数递减方式排名编写一个程序，根据给出的参赛队伍名单和所有比赛的结果，找出成功进入淘汰赛阶段的球队名单。

输入形式

第一行输入包含唯一整数n(1<=n<=50)，参加世界杯决赛的球队数量。接下来的n行是各球队的名字，为长度不超过30个字符的英文字符。接下来的n*(n-1)/2行，每行格式name1-name2 num1:num2（0<=num1, num2<=100），表示对阵球队及比分.

输出形式

输入n/2行，表示进入淘汰赛阶段的球队，按照字典序进行排列，每个球队名字占一行

样例输入

text

`1`	`4ABCDA-B 1:1A-C 2:2A-D 1:0B-C 1:0B-D 0:3C-D 0:3`

样例输出

text

AD

解题思路

跟第4题整体思路差不多，增加了一点难度主要在字符串的分割上。只要掌握根据分隔符将字符串分割成两半的方法就行。

7.F1方程式冠军

个人难度评级：3

问题描述

一级方程式F1锦标赛由一系列称为大奖赛的分站赛组成。每一场比赛的车手都根据他们的最后位置获得积分。只有前10名车手按以下顺序获得分数：25、18、15、12、10、8、6、4、2、1。在锦标赛结束时，得分最多的车手是冠军。如果有平分，则冠军是赢的最多的人（即排位第一）。如果还是平分，则选择得到排位第二最多的人，依此类推，直到没有更多的排位进行比较。

后来又提出了另一个得分制度，其中冠军是赢的最多的。如果有平手，冠军是得分最多的。如果仍然存在平手，则按原来的得分制度进行，即比较第二、第三、第四、… 排位的次数。

在本赛季，你会得到所有比赛的结果，你将根据两个得分系统来分别确定冠军。数据保证两套系统都能得到唯一的冠军。

输入形式

第一行一个整数t（1<=t<=20），t是分站赛的场次数。之后是每个分站赛的最终排位情况，每个的第一行一个整数n(1<=n<=100) 表示排位车手人数，之后n行按排位列出车手的名字，排位从第一到最后，车手的名字为长度不超过50的英文字符，大小写区分。

输出形式

输出为两行，第一行为按照原始规则确定的冠军，第二行是按照可选规则确定的冠军。

样例输入

text

`1`	`33applebananapear2pearbanana2applebanana`

样例输出

text

`1`	`bananaapple`

解题思路

和第4题差不多的壳，但主要考察的是结构体的排序，手写不同的比较函数是重点。

注意比较的时候最多可能比较到得到10-20名的次数，所以得到某名次计数的数组要开得大些。

8. 买房与选房

个人难度评级：7

问题描述

在 X 国许多一线城市住房非常紧张，政府部门制定了相关的政策，重点满足住房刚性需求（住房面积为0，社保缴纳必须超过2年），然后才能照顾改善性需求（住房面积大于0）。

具体的原则为：

对于刚性需求，缴纳社保月数多者优先
对于改善性需求，现有自有住房面积小者优先

由于房源有限，为公平起见，开发商在不违背上述原则下特意指定同等条件下申报时间同时作为排队的条件，时间越早优先级越高。

最近有一批新楼盘准备开盘，总共有 m （≤1000）套房，所有的网上申报工作都已经完成并保存到二进制文件house.bin中，申请者提交了自己的基本材料，格式为：身份证号（18位，加1位空字符 ‘\0’，共19位）、社保缴纳月数、自有住房面积、申报时间 (格式为：MM-DD-YYYY，10位字符串，加1位空字符’\0’，共11位)，社保缴纳月数、自有住房面积均为整数，文件最后为总报名人数 n（≤105）。

申请者可以通过身份证号查询最终的结果。

输入形式

输入的第一行为两个正整数 m（≤1000）和 T （ **T_ ≤ n**_ ），分别表示本次开盘的楼盘可供申请的套数以及查询的组数

接下来的 T 行，每行为一个18位的字符串，表示需要查询的身份证号

输出形式

输出为 T 行，对应每个查询的输出结果：

1. 申请者不符合购房条件或排位超出了所推出的房源数量不能中签，则输出 “Sorry”;

2. 申请者符合购房条件，且该名次人数为1人，则直接输出一个整数，表示选房顺序号;

3. 申请者符合购房条件，且该名次人数有多人，同时人数不大于所剩房源数量，则直接输出用空格分隔的两个整数，表示选房顺序号区间;

4. 申请者符合购房条件，且该名次人数有多人，同时人数大于所剩房源数量，则输出用 / 分隔两个整数，如 A/B，表示 B 人中选 A 人，选房顺序为排名倒数 A 名范围。

样例输入

text

9 6
350102200609166049
350102200609163286
250342323545313434
130502201805070787
110101196003074525
430102201102181455

样例输出

text

2
3 4
Sorry
6
2/3
Sorry

代码框架

** 建议复制以下代码框架，在此基础上完成本题需求。此建议不是必须，你可以忽略。**

cpp

#include <iostream>

using namespace std;

struct people

{

    char id[19];                  /* 身份证号码 */

    int social;                     /* 社保缴纳月数 */

    int area;                       /* 现有住房面积 */

    char date[11];              /* 申报日期 */

};

people* getMess(int &n);

int main()

{

    people *person;          /* 指向所有报名人的基本资料首地址，通过调用函数 getMess 获取 */     

    int n;                            /* n 为报名人数，通过调用函数 getMess 获取 */

    person=getMess(n);



    // ...



    return 0;

}

people* getMess(int &n)            /* 将文件数据读入内存 */

{

    FILE *fp;

    fp=fopen("house.bin","rb");

    fseek(fp,-1*(long)sizeof(int), 2);

    fread(&n, sizeof(int),1, fp);

    rewind(fp);

    people *tmp=new people[n];

    fread(tmp, sizeof(people), n, fp);

    fclose(fp);

    return tmp;

}

测试用例说明

10% 的用例无同等条件的数据，30% 的用例只有刚性需求，20% 的用例只有改善性需求。

文件下载

请下载压缩文件（见CG平台）并在存放源程序文件的文件夹下解开，其中二进制文件house.bin包含了相关的测试数据，test.txt是相关测试数据的文本格式，可用于程序测试。

解题思路

我引入了一个”优先级 “整型变量来决定排到房源的优先级，使这个变量必满足刚性需求社保久> 刚性需求社保少>改善需求小房子>改善需求大房子>没有购房资格，在此顺序绝对成立的基础上，申请早的优先级高。这个可以从我的代码里详细了解。

然后，将其与对应的people结构体组成pair并使用stable_sort排序，按优先级从大到小。这样就可以很容易地得到某个人的名次和同名次人的范围。

我的代码一个点都没过，但我觉得我的思路是对的……

9. 二叉树遍历，从前序、中序到后序

个人难度评级：4

问题描述

二叉树是一种非常重要的数据结构，非常多其他数据结构都是基于二叉树的基础演变而来的。对于二叉树，深度遍历有前序、中序以及后序三种遍历方法。

三种基本的遍历思想为：

前序遍历：根结点 —> 左子树 —> 右子树

中序遍历：左子树 —> 根结点 —> 右子树

后序遍历：左子树 —> 右子树 —> 根结点

比如，求以下二叉树的各种遍历

前序遍历：1 2 4 5 7 8 3 6

中序遍历：4 2 7 5 8 1 3 6

后序遍历：4 7 8 5 2 6 3 1

需要你编写程序解决的问题是：已知一个二叉树的前序遍历和中序遍历的结果，给出该二叉树的后序遍历的结果。

输入形式

有多组测试数据，每组测试数据三行，每组测试数据第一行只有一个正整数n，表示二叉树节点的数目，n=0意味着输入结束并且不需要处理。

每组测试数据第二行是二叉树的前序遍历的结果，是一个长度为n的字符串，每个节点由一个字符表示，字符是大小写英文字母及10个数字, 不同的节点用不同的字符表示，也即无论前序遍历和中序遍历的字符串中没有重复的字符。

每组测试数据第二行是二叉树的中序遍历的结果，也是一个长度为n的字符串。

40% 的测试数据1 ≤ n≤ 10；

30% 的测试数据1 ≤ n≤ 20；

20% 的测试数据1 ≤ n≤ 40；

10% 的测试数据1 ≤ n≤ 62；

输出形式

对于每组测试数据，输出一行，是一个长度为n的字符串，表示二叉树后序遍历的结果。

样例输入

text

8
12457836
42758136
4
abcd
abcd
4
abcd
dcba
0

样例输出

text

1
2
3

47852631
dcba
dcba

解题思路

使用递归方法。对于每个子树（输入数据本身也算一棵子树），先得到根节点，然后利用其分别分割左子树和右子树并分别传入递归，最后输出根节点。

部分参考了 9. 二叉树遍历，从前序、中序到后序 (递归即可解决)_yogdzewa 的博客 - CSDN 博客。

10. 内存管理

来源：Codeforces 7B

个人难度评级：4

问题描述

离第一个操作系统HNU-OS发布已经没有多少时间了，但它的一些组件还没有完成，内存管理器就是其中之一。根据开发人员的计划，在第一个版本中，内存管理器将非常简单和直观。它将支持三个操作：

alloc n —— 分配n个字节内存，返回已分配块的正整数标识符x(x初始值为0，每次分配增长1)
erase x —— 删除标识符x所在的块
defragment —— 整理空余内存碎片，将所有块尽量靠近内存的开始位置，并保持各自的顺序

在此情况下，内存模型非常简单，它是一个m字节的序列，为了方便起见，从第一个字节到第m字节进行编号。

第一个操作alloc n有一个参数n，表示被分配的内存块大小。在处理此操作时，内存中将分配n个连续字节的空闲块。如果这些块的数量超过一个，则优先选择最接近内存开始 (即第一个字节) 的块。所有这些字节都被标记为非空闲，内存管理器返回一个32位整数数字令牌，代表该块的标识符。如果不可能分配这样大小的空闲块，则返回NULL。

第二个操作erase x以x为参数，表示某个块的标识符。此操作释放系统内存，将此块的字节标记为空闲以供进一步使用。如果此标识符没有指向先前分配的块 (该块尚未被释放)，则返回ILLEGAL_ERASE_ARGUMENT。

最后一个操作defragment没有任何参数，只会使占用的内存部分更接近内存的开始，而不会更改它们各自的顺序。

在当前的实现中，将使用从1开始的连续整数作为标识符。每个成功的alloc操作过程都应该返回接下来的编号。不成功的alloc操作不影响计数。

编写内存管理器的实现，为每个alloc命令输出返回的值，为所有失败的erase命令输出ILLEGAL_ERASE_ARGUMENT。

输入形式

输入数据的第一行包含两个正整数t和m（1<=t<=500, 1<=m<=105)，其中t表示需要内存管理器来处理的操作个数，m表示有效的内存字节大小。接下来的t行每一行代表一个操作。

输出形式

输出有多行，每行或者是alloc操作的结果，或者是失败的erase操作的结果ILLEGAL_ERASE_ARGUMENT。其顺序与输入的操作次序一致。

样例输入

text

`1`	`6 10alloc 5alloc 3erase 1alloc 6defragmentalloc 6`

样例输出

text

12NULL3

解题思路

定义memblock结构体存储内存块，包含标识符、开始点和结束点，和一个是否已经被释放的bool标记。

借鉴了堆的思想，将靠前的内存块前置，靠后的内存块后置，已经释放的内存块则放到最后面去。在插入和释放完成后进行排序，因为相对位置已经改变。

分配新内存块时，先寻找块间的剩余空间，如果不够再尝试从尾部插入，然后排序。释放时将编号对应的块记为已经释放，然后排序。碎片整理操作则是挨个移动已经有序的各个块即可。

11. 平均方差

个人难度评级：1

问题描述

一个数列的平均方差是指数列中的每个元素与数列的平均值的差的平方和的平均值，比如下面数列：

1 2 3 4 5 6 7

其平均值为4，每个元素与平均值的差的平方为

9 4 1 0 1 4 9

其平方和为28，所以该数列的平均方差为4。

对给定的数列，求出其平均方差。

输入形式

有多组测试数据。

每组测试数据第一行是一个正整数N，表示数列中元素个数，接下来一行N个用空格分隔开的正整数，表示数列的N个元素，每个元素的值都是不大于500的正整数。

N=0表示输入结束，并且不需要处理。

40% 的数列元素个数N 1 ≤ N≤ 10；

30% 的数列元素个数N 1 ≤ N≤ 100；

20% 的数列元素个数N 1 ≤ N≤ 1000；

10% 的数列元素个数N 1 ≤ N≤ 10000；

输出形式

对于每组测试数据，输出一个整数：平均方差。平均方差不是整数的，输出其向下取整的整数。比如平均方差是4.5，输出4。

样例输入

text

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

样例输出

text

1
2

4
1

解题思路

这玩意有啥解题思路？算就是了。记得适时用double。

12. IP地址

个人难度评级：2

问题描述

一个IP地址由32位二进制的数组成，比如：

111111111111111111111111000000002

为了便于记忆，我们将8个二进制位用一个十进制数表示，一个IP地址由四个十进制数表示，上述的IP地址表示为：

255.255.255.0

现在给你一个上述形式的IP地址，请回答IP地址的32个二进制位中，有多少位是1。

如IP地址为255.255.255.0，其中24位是1。

输入形式

有多组测试数据。

测试数据第一行是一个正整数T，表示测试数据组数。

每组测试数据是一个IP地址，形式为：

IP1.IP2.IP3.IP4

其中0 ≤IP1,IP2,IP3,IP4≤ 255, 用十进制表示。每个IP地址不保证是实用IP地址。

40% 的测试数据组数T 10≤T≤ 102；

30% 的测试数据组数T 102≤T≤ 103；

20% 的测试数据组数T 103≤T≤ 104；

10% 的测试数据组数T 104≤T≤ 105；

输出形式

对于每个IP地址，输出一行包含一个非负整数：该IP地址的32个二进制位中，1的位数。

样例输入

text

5
255.255.255.0
127.0.0.1
0.0.0.1
1.2.3.4
0.0.0.0

样例输出

text

提示：样例中32位的IP地址为：

111111111111111111111111000000002

011111110000000000000000000000012

000000000000000000000000000000012

000000010000001000000011000001002

000000000000000000000000000000002

解题思路

核心在于进制转换的思想，以及第6题分割字符串的方法。先分割再转换进制，不就很简单了吗？

13. 开关与灯

来源：CodeForces 985B（我湖不愧是9B5）

个人难度评级：2

待完善

14. 可删除的点

个人难度评级：1

问题描述

平面上有n个不同的点，没有在Y轴的点，检查是否存在这样一个点，将其删除后其余所有的点均位于Y轴的同一边。

输入形式

输入第一行包含一个正整数n(2<=n<=105)。

接下来的n行，包含所有点的坐标，第i行包含两个整数xi和yi(|xi|、|yi|<=109，xi<>0)。

输出形式

如果存在这样的点，则输入 “Yes”，否则输出 “No”。

样例输入

text

`1`	`31 1-1 -12 -1`

样例输出

text

Yes

解题思路

有一个坑点，就是如果所有点本来就在一边，也是符合要求的，别的没什么好说的。

15. 字符串反转3

个人难度评级：3

问题描述

给出一个字符串，请将其每个单词反转后输出。

输入形式

输入第一行为一个正整数N，表示测试用例数，接下来的N行，每行一个字符串。

输出形式

输出N行，每行对应一个反转后的字符串。

样例输入

text

`1`	`3olleh !dlrowm'I morf .unhI ekil .tae`

样例输出

text

`1`	`hello world!I'm from hnu.I like eat.`

解题思路

这题蛋疼就蛋疼在数据5规模相当大，用C++ 的库函数似乎很容易在第5个点超时（没错我也超了）。据大佬说，写一个仅基于C的版本能够大幅度提升效率。如果不是难以预计的TLE（数据规模都没给），这个题并不是很难。

16. n，还是n

个人难度评级：2

问题描述

输出包含n或者是n的倍数的所有数

输入形式

正整数m,n（0<m，n<1000000）

输出形式

从小到大排列的不大于m的特殊正整数（包含n，或者是n的倍数）。

样例输入1

text

20 7

样例输出1

text

7 14 17

样例输入2

text

200 11

样例输出2

text

`1`	`11 22 33 44 55 66 77 88 99 110 111 112 113 114 115 116 117 118 119 121 132 143 154 165 176 187 198`

样例说明

包含n的数可以考虑使用字符串查找解决

解题思路

数据规模不大，倍数这个条件直接 % 就行。包含这个条件可以用字符串find成员函数处理。

17. 字符串排序

个人难度评级：1

问题描述

定义一个字符串的无序度为所有位置后面的字母比该位置的字母小的总数之和。比如 “DAABEC’‘这个字符串的无序度是5，因为D后面有4个位置比它小（AABC），E后面有1个比它小（C），其它位置后面没有比自己小的。” AACEDGG “的无序度为1（E后面有一个D比它小）。” ZWQM " 的无序度为6，每个位置后面所有的字母都比它小。
现在你的任务是给定一些字符串（只由大写字母组成），把他们按照无序度从小到大排序，如果无序度一样，那么就按照输入的相对顺序排序。

输入形式

单组测试数据。
第一行有两个整数n(0 < n <= 50) 和m (0 < m <= 100)，分别表示输入的字符串的长度和字符串的个数。
接下来m行，每一行包含一个长度为n的字符串，只由大写字母组成。

输出形式

输出m行，表示排序之后的字符串。

样例输入

text

`1`	`10 6AACATGAAGGTTTTGGCCAATTTGGCCAAAGATCAGATTTCCCGGGGGGAATCGATGCAT`

样例输出

text

`1`	`CCCGGGGGGAAACATGAAGGGATCAGATTTATCGATGCATTTTTGGCCAATTTGGCCAAA`

解题思路

照着题目要求算无序度即可。我建议用pair类型分别存储字符串和无序度两个键值，然后用stable_sort自定义排序函数排序，以保持原有输入顺序。没必要排序的时候再算无序度，会很慢。

18. 三角形的面积

个人难度评级：1

问题描述

已知三角形的三个顶点的坐标，求该三角形的面积。

输入形式

有多组测试数据。

每组测试数据占一行，6个用空格分隔开的浮点数：x1,y1,x2,y2,x3,y3。表示三角形三个顶点的坐标。

一行6个0（形如0 0 0 0 0 0），表示输入结束，并且不需要处理。

40% 的顶点坐标 -10 ≤ xi,yi≤ 10；i=1,2,3

30% 的顶点坐标 -100 ≤ xi,yi≤ 100；i=1,2,3

20% 的顶点坐标 -1000 ≤ xi,yi≤ 1000；i=1,2,3

10% 的顶点坐标 -10000 ≤ xi,yi≤ 10000；i=1,2,3

输出形式

对于每组测试数据，输出对应三角形面积，保留小数点后6位。

样例输入

text

1
2
3

1 2 3 4 -2 8
0 0 0 1 1 0
0 0 0 0 0 0

样例输出

text

1
2

9.000000
0.500000

Tips：如果使用浮点数，请注意精度问题，推荐使用double

解题思路

数论题，如果会了海伦公式，很简单。

19. 循环数

来源：POJ 1047

个人难度评级：3

问题描述

循环数是n位长度的整数，当乘以从1到n的任何整数时，产生原始数字的 “循环”。也就是说，如果考虑最后一个数字之后的数字“绕” 回到第一个数字，两个数字中的数字序列将是相同的，尽管它们可能从不同的位置开始。例如，数字142857是循环的，如下表所示：

        142857 *1 = 142857
        142857 *2 = 285714
        142857 *3 = 428571
        142857 *4 = 571428
        142857 *5 = 714285
        142857 *6 = 857142

编写一个程序来确定数字是否是循环数。

输入形式

输入一个数，长度在2到60位之间 (请注意，前面的零不应该被删除，它们被认为是确定n的大小和计数的一部分，因此，“01” 是一个两位数的数字，与 “1” 是一个一位数的数字不同。) 。

输出形式

对于每个输入，输出一行 (Yes或No) 标识它是否是循环数。

样例输入

text

样例输出

text

Yes

解题思路

主要的麻烦是如何判断一个数和另一个是可以绕回来，以及如何处理60位数字的乘法问题。

事实上，如果一个序列可以分成两部分，调换顺序之后与另一个序列相等（或者进一步地，两个部分都是另一个序列的子串），那就可以” 绕回来 “。我枚举了分界线，使用std::string的substr成员函数分割字符串，并使用上文提到的find成员函数判断子串。

如此长数字的乘法，属于高精乘低精的问题，可以仿照竖式计算的方法计算。

20. 电能消耗

来源：Codeforces 10A

个人难度评级：1

问题描述

汤姆对他最喜欢的笔记本电脑的耗电量很感兴趣。他的笔记本电脑有三种模式。在正常模式下，笔记本电脑每分钟消耗P1瓦。在汤姆最后一次移动鼠标或触摸键盘后的T1分钟，屏幕保护程序启动，每分钟的功耗变化为P2瓦。最后，从屏幕保护程序启动到T2分钟后，笔记本电脑切换到 “睡眠” 模式，每分钟消耗P3瓦。当笔记本电脑处于第二或第三模式时，如果汤姆移动鼠标或触摸键盘，则切换到第一种 (正常) 模式。汤姆使用笔记本电脑工作的时间可以分为n个时间间期 [l1, r1]、[l2, r2]、…、[ln, rn]。在每个间期，汤姆连续移动鼠标并按下键盘。在间期之间，汤姆什么都不做。请找出在间期 [l1, rn]笔记本电脑的总耗电量。

输入形式

第一行包含6个整数n、P1、P2、P3、T1、T2(1<=n<=100，0<=P1、P2、P3<=100，1<=T1、T2<=60)。接下来的n行包含了汤姆工作的期间，第i行是两个用空格分隔的整数li和ri(0<=li<=ri<=1440, 当i<n时ri<li+1）, 表示工作期间的开始时间和结束时间。

输出形式

输出总的耗电量。

样例输入

text

`1`	`2 8 4 2 5 1020 3050 100`

样例输出

text

解题思路

如果要说有难点的话，就是L1和Rn的选取存储。我的办法是将第一组特殊处理，具体的可以直接看我代码。

21. 计算校验码

个人难度评级：3

问题描述

传送一个B（B≤16）进制的数值N时，最后加上一个一位（B进制的）校验码，使得N加上校验位后能被B-1整除。比如十进制的数值12310，其校验码就是3，因为十进制数值123310能被9整除。16进制的数7816，其校验码为0，因为16进制的78016是15的倍数。超过十进制后，用字母a表示10，字母b表示11，字母c表示12，字母d表示13，字母e表示14，字母f表示15。

告诉你进制B，以及一个B进制的正整数N，要求你计算正整数N在B进制下的校验码。

输入形式

输入第一行正整数t (10 ≤ n ≤ 100)，表示有多少组测试数据。

后面有t行，每行两个正整数B，N（2≤ B≤16），中间用一个空格隔开，B是10进制整数，N用B进制形式表示。测试数据保证没有非法的B进制数N（也即N中每一位都是在0到B-1之间，没有前导0）。

40% 的测试数据N的位数L 1 ≤ L≤ 10；

30% 的测试数据N的位数L 1 ≤ L≤ 102；

20% 的测试数据N的位数L 1 ≤ L≤ 103；

10% 的测试数据N的位数L 1 ≤ L≤ 104；

输出形式

对于每组测试数据，输出一位占一行：正整数N在B进制下的校验码。（如果校验码可以为B-1，也可以为0，输出0）。

样例输入

text

样例输出

text

样例说明

第一行的4表示有4组测试数据，下面四行，每行一组测试数据。

第一组测试数据10进制数123最后添加检验码3，10进制数1233是9（=10-1）的倍数

第二组测试数据16进制数78最后添加检验码0，16进制数780是15（=16-1）的倍数

第三组测试数据16进制数1234321最后添加检验码e（=14），16进制数1234321e是15（=16-1）的倍数

第四组测试数据12进制数ab最后添加检验码1，12进制数ab1是11（12-1）的倍数

【Tips】

B进制的数能被B-1整除，当且仅当各位数字和能被B-1整除。

第一组测试数据10进制数123最后添加检验码3，10进制数1233各位数字和是9，是9的倍数

第二组测试数据16进制数78最后添加检验码0，16进制数780各位数字和是15，是15的倍数

第三组测试数据16进制数1234321最后添加检验码e，16进制数1234321e各位数字和是30，是15的倍数

第四组测试数据12进制数ab最后添加检验码1，12进制数ab1各位数字和是22，是11的倍数

解题思路

获取校验码的过程，本质上是一个高精度除法，大数除小数。先将每一位用十进制整数表示（即使转换完大于10也算作一位），然后再使用竖式计算的方式算出余数，要求将其乘以10再加上校验码，除以进制 - 1能够整除。这样可以枚举从0到n-1的整数作校验码。

每一组数据完成后，一定要清空按位存储原数字的数组，否则会遗留除法计算结果，影响下一组数据计算！

不建议使用itoa函数将数字转换为二进制字符串，更推荐自己实现（反正只需要转一位，即将整型校验码转为char），因为它是GNU C++ 标准的函数，不被许多ISO C++ 的编译器支持。

此外，朋友提供了一种数论的办法：将整个数的每一位相加，再加上一个0到n-2的数，如果能够被n整除，则加上的这个数就是校验码。

2021 程序设计训练 on cyp0633's Blog

CCF CSP 202109 @ HNU 游记

关于考场

第一题

第二题

第三题

第四题

第五题

总结

湖南大学 2021 程序设计训练笔记 - 作业训练 4

1. 在霍格沃茨找零钱

问题描述

输入形式

输出形式

样例输入1

样例输出1

样例输入2

样例输出2

解题思路

2. 最简单的计算机

问题描述

输入形式

输出形式

样例输入

样例输出

解题思路

3. 相同生日

问题描述

输入形式

输出形式

样例输入

样例输出

解题思路

4. 日历问题

问题描述

输入形式

输出形式

样例输入

样例输出

解题思路

5. 小希的数表

问题描述

输入形式

输出形式

样例输入

样例输出

解题思路

6. 数塔

问题描述

输入形式

输出形式

样例输入

样例输出

解题思路

7. 斯诺克台球（不做了）

问题描述

输入形式

输出形式

样例输入

样例输出

样例说明

解题思路

8. 最少钱币数

问题描述

输入形式

输出形式

样例输入

样例输出

解题思路

9. 相等的多项式

问题描述

** 输入格式 **

** 输出格式 **

** 样例输入 **

** 样例输出 **

解题思路

10. 选美比赛

问题描述

输入形式

输出形式

输入格式

输出格式

样例输入

样例输出

问题描述

输入格式

输出格式

样例输入

样例输出

问题描述

输入格式

输出格式

样例输入

样例输出