未来科学家（高级组-冠亚季军选拔赛）
冠军题库 亚军题库 季军题库 在线练习
❀ 冠 军 题 库 ❀ 返回最前
试题1：拼图游戏中的“撤销”与“重做”
【题目描述】
拼图游戏中，玩家可以移动拼图块改变游戏状态。请使用两个栈（撤销栈和重做栈）实现拼图状态的撤销（Undo）和重做（Redo）功能。初始状态为 A，依次进行以下操作：
- 移动拼图到新状态
A-B - 移动拼图到新状态
A-B-C - 移动拼图到新状态
A-B-C-D - 撤销一次
- 撤销一次
- 重做一次
- 移动拼图到新状态
A-B-C-E - 连续撤销直到无法撤销
- 连续重做到无法重做
每次操作后输出当前状态或相应提示。
【题目要求】
编写程序模拟上述过程，输出每一步后的结果。要求使用列表模拟栈，append() 压栈，pop() 弹栈。撤销时将当前状态压入重做栈，重做时从重做栈弹出并压回撤销栈。输出格式严格参照示例。
【输出示例】
当前拼图状态: A 移动拼图到新状态: A-B 移动拼图到新状态: A-B-C 移动拼图到新状态: A-B-C-D 撤销到状态: A-B-C 撤销到状态: A-B 重做到状态: A-B-C 移动拼图到新状态: A-B-C-E 撤销到状态: A-B-C 撤销到状态: A-B 撤销到状态: A 无法撤销，已经是最初状态 重做到状态: A-B 重做到状态: A-B-C 重做到状态: A-B-C-E 没有可重做的操作
试题2：班级值日生轮换表
【题目描述】
使用循环队列实现班级值日生的公平轮换。初始队列容量为5，依次添加值日生：小明、小红、小刚、小丽、小强。模拟以下过程：
- 尝试添加第6位同学小华（队列已满，应提示无法加入）。
- 显示当前值日生轮换顺序（从队首开始循环）。
- 模拟每周值日：每周开始时队首同学值日，然后该同学出队并重新入队（表示轮换到队尾），连续执行7周。
- 在第4周后，新加入两位同学小华、小敏（队列有空位）。
- 继续执行后续周次的值日。
要求输出每一步的关键信息。
【题目要求】
实现循环队列，使用列表和取模运算模拟。需包含入队、出队、判满、判空、显示队列等操作。输出格式参照示例。
【输出示例】
小明 已加入值日表
小红 已加入值日表
小刚 已加入值日表
小丽 已加入值日表
小强 已加入值日表
小华 无法加入，值日表已满！
当前值日生轮换顺序: 小明 → 小红 → 小刚 → 小丽 → 小强 → (循环)
第1周:
本周值日生是: 小明
当前值日生轮换顺序: 小红 → 小刚 → 小丽 → 小强 → (循环)
第2周:
本周值日生是: 小红
当前值日生轮换顺序: 小刚 → 小丽 → 小强 → (循环)
第3周:
本周值日生是: 小刚
当前值日生轮换顺序: 小丽 → 小强 → (循环)
第4周:
本周值日生是: 小丽
当前值日生轮换顺序: 小强 → (循环)
新同学加入:
小华 已加入值日表
小敏 已加入值日表
当前值日生轮换顺序: 小强 → 小华 → 小敏 → (循环)
第5周:
本周值日生是: 小强
当前值日生轮换顺序: 小华 → 小敏 → (循环)
第6周:
本周值日生是: 小华
当前值日生轮换顺序: 小敏 → (循环)
第7周:
本周值日生是: 小敏
当前值日生轮换顺序: (循环)
试题3：班级通讯录
【题目描述】
使用字典实现一个班级通讯录，键为学号（或姓名），值为包含姓名、电话、邮箱的字典。初始数据如下：
- 张三：学号1，电话13800138001，邮箱zhangsan@school.com
- 李四：学号2，电话13800138002，邮箱lisi@school.com
- 王五：学号3，电话13800138003，邮箱wangwu@school.com
要求依次执行以下操作：
- 查找学生“李四”的信息并输出。
- 查找不存在的学生“赵六”。
- 更新学生“王五”的电话为13800555555。
- 尝试更新不存在的学生“赵六”的电话。
- 删除学生“李四”。
- 尝试删除不存在的学生“钱七”。
- 输出当前通讯录所有学生信息。
- 对比列表查找和字典查找的效率（查找“王五”时分别用列表遍历和字典直接访问，输出耗时）。
【题目要求】
实现通讯录类，包含增删改查方法。输出每一步操作的结果，并对比两种查找方式的耗时（可用 time 模块）。输出格式参照示例。
【输出示例】
已添加学生: 张三
已添加学生: 李四
已添加学生: 王五
查找测试:
找到学生 李四:
学号: 2
电话: 13800138002
邮箱: 李四@school.com
未找到学生: 赵六
更新测试:
已更新 王五 的电话
更新失败，未找到学生: 赵六
删除测试:
已删除学生: 李四
删除失败，未找到学生: 钱七
班级通讯录:
张三: 学号1, 电话13800138001
王五: 学号3, 电话13800555555
共 2 位同学
效率对比演示:
找到学生 王五:
学号: 3
电话: 13800555555
邮箱: 王五@school.com
列表查找耗时: 0.000002秒
字典查找耗时: 0.000055秒
试题4：好友关系网
【题目描述】
使用图（邻接表）表示班级同学的好友关系。同学名单：小明、小红、小刚、小丽、小强、小花。好友关系（双向）如下：
- 小明-小红
- 小明-小刚
- 小红-小丽
- 小刚-小强
- 小丽-小花
- 小强-小花
要求：
- 输出每个同学的好友列表。
- 判断小明和小红是否是朋友，小明和小丽是否是朋友。
- 找出小明的所有间接好友（朋友的朋友，不包括直接好友）。
- 找出小明的三级好友（朋友的朋友的朋友）。
- （可选）计算每个人的好友数量，找出“社交达人”。
【题目要求】
实现图结构，包含添加节点、添加边、获取邻居、广度优先遍历（BFS）等方法。按照上述要求输出结果。输出格式参照示例。
【输出示例】
全班同学的好友关系: 小明的好友: 小红, 小刚 小红的好友: 小明, 小丽 小刚的好友: 小明, 小强 小丽的好友: 小红, 小花 小强的好友: 小刚, 小花 小花的好友: 小丽, 小强 查询测试: 小明和小红是朋友吗? True 小明和小丽是朋友吗? False 查找间接好友(朋友的朋友): 小明的二级好友: ['小红', '小刚', '小丽', '小强'] 查找三级好友(朋友的朋友的朋友): 小明的三级好友: ['小红', '小刚', '小丽', '小强', '小花']
试题5：课程优先级安排
【题目描述】
某些课程有先修要求，必须学完先修课才能学习后续课程。
给定以下课程依赖关系：
- “高等数学” 需要先修 “数学基础”
- “数据结构” 需要先修 “编程入门”
- “算法分析” 需要先修 “数据结构”
- “机器学习” 需要先修 “算法分析”
请使用拓扑排序算法输出一个合理的学习顺序。
【题目要求】
实现拓扑排序（Kahn算法或DFS），输出课程学习顺序。如果存在循环依赖则提示。输出格式参照示例。
【输出示例】
推荐的学习顺序: 1. 数学基础 2. 编程入门 3. 高等数学 4. 数据结构 5. 算法分析 6. 机器学习
试题6：迷宫游戏地图
【题目描述】
设计一个100×100的迷宫，只有少量墙壁（约10%），其余为可通行空地。要求使用稀疏矩阵（defaultdict）存储墙壁位置，以节省内存。初始玩家位置设为 (50,30)（坐标从0开始）。
要求：
- 生成一个随机迷宫（或给定固定墙壁集），墙壁用
#表示，空地用.表示。 - 打印玩家周围10×10区域的地图（以玩家为中心截取）。
- 输出密集矩阵存储和稀疏矩阵存储所需的空间（元素个数）对比，并计算空间节省百分比。
- 查询玩家所在位置是否为墙壁，输出结果。
【题目要求】
实现稀疏矩阵存储，墙壁坐标作为键，值可设为 '#'。打印区域时，若坐标在稀疏矩阵中则输出 #，否则输出 .。输出格式参照示例。
【输出示例】
迷宫地图 (仅显示10×10区域，共100×100) .######### ....#..... ....... ... .......#... ........... .#...P..... ........... ...........# ........... ...........# 密集矩阵需要存储 10000 个格子 稀疏矩阵实际存储 853 个格子 节省了 91.47% 的空间 (50,30)是墙壁吗? False
试题7：手机通讯录联系人查找系统
【题目描述】
已排序的通讯录姓名列表如下：
["张三", "李四", "王五", "赵六", "张伟", "李娜", "王芳", "张丽", "李明", "王强"]
对应的电话号码字典为：
{"张三": "13800138000",
"李四": "13900139000",
"王五": "13700137000",
"赵六": "13600136000",
"张伟": "13500135000",
"李娜": "13400134000",
"王芳": "13300133000",
"张丽": "13200132000",
"李明": "13100131000",
"王强": "13000130000"}
要求实现一个查找系统，支持：
- 精确查找：输入姓名，返回电话。
- 前缀查找：输入姓氏（如“张”），返回所有该姓氏的联系人及其电话。
程序应循环接收用户输入，输入 q 退出。
【题目要求】
使用二分查找实现精确查找，使用二分查找定位前缀范围实现前缀查找。输出每次查找的结果。输出格式参照示例。
【输出示例】
=== 通讯录查找演示 ===
请输入要查找的姓名或姓氏（输入q退出）: 张三
找到联系人: 张三，电话: 13800138000
请输入要查找的姓名或姓氏（输入q退出）: 张
找到3个姓氏为'张'的联系人:
张丽: 13200132000
张三: 13800138000
张伟: 13500135000
请输入要查找的姓名或姓氏（输入q退出）: 李
找到3个姓氏为'李'的联系人:
李明: 13100131000
李娜: 13400134000
李四: 13900139000
请输入要查找的姓名或姓氏（输入q退出）: 不存在的名字
未找到姓名包含'不存在的名字'的联系人
请输入要查找的姓名或姓氏（输入q退出）: q
退出通讯录查找系统
试题8：超市水果价格排序
【题目描述】
给定5种水果的价格（元）：
- 苹果：5
- 香蕉：3
- 橙子：4
- 葡萄：6
- 梨子：2
请使用选择排序按价格从低到高排序，输出排序前和排序后的水果顺序。
【题目要求】
实现选择排序算法，输出排序前后的水果列表。输出格式参照示例。
【输出示例】
排序前的水果顺序:
苹果: 5元
香蕉: 3元
橙子: 4元
葡萄: 6元
梨子: 2元
排序后的水果顺序:
梨子: 2元
香蕉: 3元
橙子: 4元
苹果: 5元
葡萄: 6元
试题9：考试成绩分段统计
【题目描述】
使用计数排序对50个0-100的整数成绩进行排序，并统计各分数段人数。成绩由随机数生成（可固定随机种子确保可复现）。
分段规则：
- 优秀：90-100
- 良好：80-89
- 中等：70-79
- 及格：60-69
- 不及格：0-59
要求：
- 输出原始成绩的前10个（示例）。
- 输出计数数组（每个分数的人数，仅显示出现过的分数）。
- 输出排序后的成绩列表的前10个。
- 输出各分数段人数统计。
【题目要求】
实现计数排序算法，计数数组大小为101。输出格式参照示例。
【输出示例】
原始成绩列表（前10个）： [86, 52, 77, 80, 86, 50, 63, 79, 81, 67]
计数数组（分数:人数）：
50分: 2人 | 52分: 4人 | 54分: 1人 | 58分: 3人 | 60分: 1人 | 61分: 1人 | 62分: 1人 | 63分: 1人 | 65分: 3人 | 66分: 1人 | 67分: 1人 | 68分: 1人 | 69分: 2人 | 70分: 1人 | 72分: 1人 | 73分: 2人 | 74分: 2人 | 76分: 2人 | 77分: 1人 | 78分: 1人 | 79分: 3人 | 80分: 1人 | 81分: 2人 | 83分: 1人 | 86分: 2人 | 87分: 1人 | 88分: 1人 | 89分: 1人 | 91分: 1人 | 92分: 1人 | 93分: 2人 | 97分: 1人 | 99分: 1人 |
排序后的成绩列表（前10个）： [50, 50, 52, 52, 52, 52, 54, 58, 58, 58]
成绩分段统计结果：
优秀(90-100): 6人
良好(80-89): 9人
中等(70-79): 13人
及格(60-69): 12人
不及格(0-59): 10人
试题10：课程表时间冲突检测
【题目描述】
给定一组课程，每门课程有名称、开始时间和结束时间（用分钟表示，如540=9:00）。课程安排如下：
- 钢琴课：540-630（9:00-10:30）
- 绘画课：600-690（10:00-11:30）
- 编程课：720-810（12:00-13:30）
- 舞蹈课：780-870（13:00-14:30）
- 围棋课：900-990（15:00-16:30）
请检测哪些课程时间存在冲突，并输出冲突的课程对。
【题目要求】
将时间转换为分钟整数，按开始时间排序后线性扫描，判断相邻课程是否重叠（结束时间 > 下一个开始时间）。输出所有冲突的课程信息。输出格式参照示例。
【输出示例】
课程表安排:
钢琴课: 09:00-10:30
绘画课: 10:00-11:30
编程课: 12:00-13:30
舞蹈课: 13:00-14:30
围棋课: 15:00-16:30
⚠️ 发现课程时间冲突:
钢琴课: 09:00-10:30
绘画课: 10:00-11:30
编程课: 12:00-13:30
舞蹈课: 13:00-14:30
试题11：班级座位表随机排列
【题目描述】
有30名学生，需随机分配到6列×5行的座位上。
要求：
- 近视学生优先安排在前排。
- 相邻座位（上下左右）的性别尽量均衡（避免同性别扎堆）。
- 座位随机化，但需满足上述约束。
学生数据:
students = [
Student("张伟", "M", False, 165),
Student("李芳", "F", True, 158), # 近视
Student("王娜", "F", False, 162),
Student("赵秀英", "F", True, 160), # 近视
Student("刘敏", "F", False, 155),
Student("陈静", "F", True, 163), # 近视
Student("杨丽", "F", False, 159),
Student("黄强", "M", False, 172),
Student("周磊", "M", True, 168), # 近视
Student("吴军", "M", False, 175),
Student("孙伟", "M", False, 170),
Student("钱芳", "F", True, 156), # 近视
Student("郑敏", "F", False, 161),
Student("冯娜", "F", False, 164),
Student("朱秀兰", "F", True, 157), # 近视
Student("秦静", "F", False, 159),
Student("许丽", "F", False, 162),
Student("何强", "M", True, 171), # 近视
Student("吕磊", "M", False, 176),
Student("曹军", "M", False, 173),
Student("金伟", "M", False, 169),
Student("魏芳", "F", True, 158), # 近视
Student("蒋敏", "F", False, 160),
Student("沈娜", "F", False, 163),
Student("韩秀兰", "F", False, 161),
Student("董静", "F", False, 162),
Student("潘丽", "F", False, 164),
Student("崔强", "M", False, 174),
Student("钟磊", "M", True, 167), # 近视
Student("彭军", "M", False, 178)
]
【题目要求】
实现随机化快速排序对随机生成的排列进行排序？实际上此题需要设计算法满足多目标约束，但题目要求用随机化快速排序作为基础。可简化：先生成随机顺序，再调整近视学生到前排，再局部调整性别均衡。输出座位表及统计。输出格式参照示例。
【输出示例】
=== 完整学生名单（30人）===
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. 彭军(男)
=== 最终座位表（6列×5行）===
李芳 女※ 赵秀英女※ 何强 男※ 周磊 男※ 魏芳 女※ 陈静 女※
钟磊 男※ 钱芳 女※ 朱秀兰女※ 冯娜 女 黄强 男 潘丽 女
吴军 男 秦静 女 崔强 男 刘敏 女 蒋敏 女 沈娜 女
张伟 男 许丽 女 曹军 男 杨丽 女 王娜 女 董静 女
吕磊 男 彭军 男 孙伟 男 金伟 男 韩秀兰女 郑敏 女
=== 座位分布统计 ===
近视学生座位分布：
第1排：6名近视学生
第2排：3名近视学生
第3排：0名近视学生
第4排：0名近视学生
第5排：0名近视学生
性别分布：
男生：12人，女生：18人
每排性别分布：
第1排：2男 4女
第2排：2男 4女
第3排：2男 4女
第4排：2男 4女
第5排：4男 2女
试题12：电子实验记录本版本管理
【题目描述】
给定一组实验版本号（遵循语义化版本，如 v1.0.0、v2.1.0-alpha），要求按正确顺序从小到大排序。版本号列表：
["v1.0.0",
"v2.3.1",
"v1.2.0",
"v1.11.0",
"v2.1.0-alpha",
"v2.1.0",
"v2.1.0-beta",
"v1.0.1",
"v0.9.9"]
排序规则：
- 先按主版本号、次版本号、修订号依次比较（数字部分）。
- 若有预发布标识符（如
-alpha,-beta），则不带标识符的版本大于带标识符的，且alpha<beta<rc< 无标识符。
请实现版本号解析与比较函数，然后排序输出。
【题目要求】
编写 parse_version 函数将版本字符串转换为可比较的元组，然后使用Python内置排序。输出排序前后的版本列表。
【输出示例】
=== 原始版本顺序 ===
v1.0.0
v2.3.1
v1.2.0
v1.11.0
v2.1.0-alpha
v2.1.0
v2.1.0-beta
v1.0.1
v0.9.9
=== 排序后版本顺序 ===
v0.9.9
v1.0.0
v1.0.1
v1.2.0
v1.11.0
v2.1.0
v2.1.0-alpha
v2.1.0-beta
v2.3.1
试题13：用太阳系行星轨道学习加权图
【题目描述】
将太阳和八大行星视为节点，太阳与每个行星之间的平均距离（天文单位 AU）作为边的权重，构建加权无向图。
数据如下：
# 添加太阳和行星[2,10](@ref)
celestial_data = [
("太阳", "star"),
("水星", "planet"), ("金星", "planet"), ("地球", "planet"),
("火星", "planet"), ("木星", "planet"), ("土星", "planet"),
("天王星", "planet"), ("海王星", "planet")
]
# 添加距离关系（基于平均轨道距离，单位：AU）[2,10](@ref)
# 注意：这里简化模型，将太阳系视为链式结构，实际是太阳与各行星直接相连
distance_data = [
("太阳", "水星", 0.39), ("太阳", "金星", 0.72), ("太阳", "地球", 1.00),
("太阳", "火星", 1.52), ("太阳", "木星", 5.20), ("太阳", "土星", 9.54),
("太阳", "天王星", 19.18), ("太阳", "海王星", 30.06)
]
要求：
- 输出邻接表表示。
- 生成距离矩阵（用
INF表示不直接相连）。 - 判断网络是否连通。
- 找出地球到木星的最短路径（由于是星型结构，路径唯一：地球-太阳-木星），并输出路径总距离。
- 统计每个节点的度（连接数）。
【题目要求】
实现加权图，使用字典存储邻接表。使用Dijkstra算法求最短路径（或直接计算）。输出格式参照示例。
【输出示例】
添加天体: 太阳(star)
添加天体: 水星(planet)
添加天体: 金星(planet)
添加天体: 地球(planet)
添加天体: 火星(planet)
添加天体: 木星(planet)
添加天体: 土星(planet)
添加天体: 天王星(planet)
添加天体: 海王星(planet)
添加距离关系: 太阳 ←0.39AU→ 水星
添加距离关系: 太阳 ←0.72AU→ 金星
添加距离关系: 太阳 ←1.0AU→ 地球
添加距离关系: 太阳 ←1.52AU→ 火星
添加距离关系: 太阳 ←5.2AU→ 木星
添加距离关系: 太阳 ←9.54AU→ 土星
添加距离关系: 太阳 ←19.18AU→ 天王星
添加距离关系: 太阳 ←30.06AU→ 海王星
太阳系行星轨道网络（加权图表示）:
太阳 连接: 水星(0.39AU), 金星(0.72AU), 地球(1.0AU), 火星(1.52AU), 木星(5.2AU), 土星(9.54AU), 天王星(19.18AU), 海王星(30.06AU)
水星 连接: 太阳(0.39AU)
金星 连接: 太阳(0.72AU)
地球 连接: 太阳(1.0AU)
火星 连接: 太阳(1.52AU)
木星 连接: 太阳(5.2AU)
土星 连接: 太阳(9.54AU)
天王星 连接: 太阳(19.18AU)
海王星 连接: 太阳(30.06AU)
太阳系距离矩阵（单位: AU）:
太阳 水星 金星 地球 火星 木星 土星 天王星 海王星
太阳 0.00 0.39 0.72 1.00 1.52 5.20 9.54 19.18 30.06
水星 0.39 0.00 INF INF INF INF INF INF INF
金星 0.72 INF 0.00 INF INF INF INF INF INF
地球 1.00 INF INF 0.00 INF INF INF INF INF
火星 1.52 INF INF INF 0.00 INF INF INF INF
木星 5.20 INF INF INF INF 0.00 INF INF INF
土星 9.54 INF INF INF INF INF 0.00 INF INF
天王星 19.18 INF INF INF INF INF INF 0.00 INF
海王星 30.06 INF INF INF INF INF INF INF 0.00
--- 太阳系连通性分析 ---
太阳系网络是否连通: True
地球 到 木星 的最短路径: 地球 → 太阳 → 木星
路径总距离: 6.20 AU
各天体的连通度（邻居数量）:
太阳: 8 个连接
水星: 1 个连接
金星: 1 个连接
地球: 1 个连接
火星: 1 个连接
木星: 1 个连接
土星: 1 个连接
天王星: 1 个连接
海王星: 1 个连接
试题14：带电粒子碰撞轨迹模拟
【题目描述】
在一个二维平面上有6个目标点，坐标如下：
# 定义目标点位置（模拟带负电的目标）
targets = [
(0, 0), # T0: 起点
(2, 1), # T1
(4, 0), # T2
(3, 2), # T3
(1, 3), # T4
(5, 3) # T5: 终点
]
粒子从 T0 出发，每次可以从当前点移动到另一个点，移动规则为：如果两点之间的欧氏距离小于等于3，则认为可以碰撞（即可达）。请使用深度优先搜索找出所有从 T0 到 T5 的可能路径（不重复经过同一点）。输出所有路径。
【题目要求】
构建有向图（无向图），节点间距离≤3则连边。使用DFS回溯搜索所有路径，输出每条路径的节点序列。输出格式参照示例。
【输出示例】
目标点位置:
T0: (0, 0)
T1: (2, 1)
T2: (4, 0)
T3: (3, 2)
T4: (1, 3)
T5: (5, 3)
碰撞关系图（邻接表）:
T0 -> ['T1', 'T2']
T1 -> ['T2', 'T3']
T2 -> ['T5']
T3 -> ['T5']
T4 -> ['T3']
找到 3 条碰撞路径：
路径1: T0(0,0) → T1(2,1) → T2(4,0) → T5(5,3)
路径2: T0(0,0) → T1(2,1) → T3(3,2) → T5(5,3)
路径3: T0(0,0) → T2(4,0) → T5(5,3)
试题15：星座观测路径优化
【题目描述】
星座网络中，每个星座有星等亮度（数值越小越亮），星座之间的连接权重为相邻星座的星等平均值（或简单累加）。给定星座图数据（见文档），要求从“北斗七星”到“天琴座”找到一条总星等和最小的路径（即观测条件最好的路径）。分别用 Dijkstra 算法和 BFS 算法（按跳数最少）求解，并对比结果。
图数据（节点及邻居）：
# 测试数据
constellation_graph = {
'北斗七星': {'星等': 2.0, '邻居': {'大熊座α': 1.5, '仙后座': 3.0}},
'大熊座α': {'星等': 1.5, '邻居': {'北斗七星': 2.0, '小熊座β': 2.5}},
'仙后座': {'星等': 3.0, '邻居': {'北斗七星': 2.0, '天鹰座': 2.8}},
'小熊座β': {'星等': 2.5, '邻居': {'大熊座α': 1.5, '北极星': 1.0}},
'天鹰座': {'星等': 2.8, '邻居': {'仙后座': 3.0, '天琴座': 2.2}},
'北极星': {'星等': 1.0, '邻居': {'小熊座β': 2.5}},
'天琴座': {'星等': 2.2, '邻居': {'天鹰座': 2.8}}
}
（边权重为两节点星等之和？题目中邻居列表中的数字可能是星等？需明确。原文中邻居字典是星等值，但可能是节点自己的星等？实际上每个节点有自己的星等，边权应为两端星等之和或平均值。为简化，本题可设定路径总星等为经过节点的星等之和，包括起点和终点。但原文示例中“总星等和: 7.00”暗示了累加。我们按节点星等累加计算。）
【题目要求】
实现 Dijkstra 算法求最小星等和路径，实现 BFS 求最少跳数路径。输出两种算法的路径和总星等和，并对比说明为什么 Dijkstra 更优。
【输出示例】
=== 星座观测路径优化系统 ===
星等说明：数值越小，恒星越亮（观测条件越好）
星座观测系统 - 各星座信息：
----------------------------------------
北斗七星: 星等=2.0, 邻居=['大熊座α', '仙后座']
大熊座α: 星等=1.5, 邻居=['北斗七星', '小熊座β']
仙后座: 星等=3.0, 邻居=['北斗七星', '天鹰座']
小熊座β: 星等=2.5, 邻居=['大熊座α', '北极星']
天鹰座: 星等=2.8, 邻居=['仙后座', '天琴座']
北极星: 星等=1.0, 邻居=['小熊座β']
天琴座: 星等=2.2, 邻居=['天鹰座']
寻找从 [北斗七星] 到 [天琴座] 的最优观测路径：
1. Dijkstra算法结果（星等亮度最优）：
路径: 北斗七星 → 大熊座α → 小熊座β → 北极星
总星等和: 7.00
经过星座数: 4
2. BFS算法结果（星座数量最少）：
路径: 北斗七星 → 仙后座 → 天鹰座 → 天琴座
总星等和: 8.00
经过星座数: 4
3. 算法对比分析：
✓ Dijkstra路径更优：总星等和更小，观测条件更好
亮度改善: 12.5%
亮度差异分析：
Dijkstra路径经过了较亮恒星: 北极星
试题16：引力弹弓效应与最小能耗路径规划
【题目描述】
航天器从地球（Earth）飞向土星（Saturn），途中可利用金星（Venus）、火星（Mars）、木星（Jupiter）进行引力加速。简化模型中，每对天体间的转移能耗与距离成正比，但若经过行星引力加速，后续路径的能耗会按一定比例减少（动态权重）。
给定天体坐标（假设在一维直线上）：
"""创建简化太阳系模型"""
# 天体数据：名称、位置(x,y,z)、质量（相对质量）
# 位置为简化坐标（天文单位），质量为相对质量因子
celestial_bodies = {
'Earth': {'position': (1.0, 0.0, 0.0), 'mass': 1.0},
'Venus': {'position': (0.7, 0.0, 0.0), 'mass': 0.8},
'Mars': {'position': (1.5, 0.0, 0.0), 'mass': 0.1},
'Jupiter': {'position': (5.2, 0.0, 0.0), 'mass': 300.0}, # 木星质量大，引力弹弓效果好
'Saturn': {'position': (9.5, 0.0, 0.0), 'mass': 100.0},
'Uranus': {'position': (19.2, 0.0, 0.0), 'mass': 14.0},
}
引力弹弓效应：若经过大质量行星（质量越大效果越强），则后续路径的能耗乘以系数 1 - 质量因子（质量因子 = 行星质量 / 100，质量数据见文档）。请设计算法找到从 Earth 到 Saturn 的最小能耗路径，考虑引力弹弓的动态权重调整。
【题目要求】
实现动态权重的 Dijkstra 算法，其中路径总能耗为各段距离乘以动态衰减因子。输出最优路径和总能耗，并与直接飞行的能耗对比。
【输出示例】
=== 引力弹弓效应轨道计算与最小能耗路径规划 ===
太阳系天体数据：
Earth: 位置(1.0, 0.0, 0.0), 相对质量1.0
Venus: 位置(0.7, 0.0, 0.0), 相对质量0.8
Mars: 位置(1.5, 0.0, 0.0), 相对质量0.1
Jupiter: 位置(5.2, 0.0, 0.0), 相对质量300.0
Saturn: 位置(9.5, 0.0, 0.0), 相对质量100.0
Uranus: 位置(19.2, 0.0, 0.0), 相对质量14.0
计算从【Earth】到【Saturn】的最小能耗路径：
考虑引力弹弓效应的动态权重调整...
✓ 路径规划成功！
最优路径: Earth → Saturn
预估总能耗: 0.10
路径详细信息：
段1: Earth→Saturn(角度:0.00)
对比分析：
直接飞行能耗: 0.10
引力弹弓路径节能: 0.0%
试题17：射电望远镜阵列布局
【题目描述】
有8个射电望远镜（编号0-7），需要选择一些连接构成通信网络，使得所有望远镜连通且总信号延迟最小。每个可能的连接有延迟（微秒），部分连接因地形或干扰被禁止，且单条连接延迟不得超过4.0微秒。
8个望远镜连接数据：
# 输入：8个望远镜，编号0-7
n = 8
# 所有可能的连接及其信号延迟（单位：微秒）
all_connections = [
(0, 1, 2.1), (0, 2, 1.5), (0, 3, 4.2), (0, 4, 3.8),
(1, 2, 2.8), (1, 5, 3.1), (1, 6, 5.2), (2, 3, 2.0),
(2, 7, 4.5), (3, 4, 1.8), (3, 7, 3.2), (4, 5, 2.5),
(4, 6, 4.8), (5, 6, 2.2), (5, 7, 3.7), (6, 7, 2.9)
]
# 禁止连接：望远镜0-6（因山脉阻挡），望远镜1-7（因干扰源）
forbidden_connections = {(0, 6), (1, 7)}
# 单条连接最大允许延迟
max_single_delay = 4.0
禁止连接：(0,6) 和 (1,7)。单条连接最大允许延迟：4.0微秒。请使用 Kruskal 算法求解满足约束的最小生成树，输出所选连接及总延迟。
【题目要求】
实现带约束的 Kruskal 算法，排除禁止连接和超过延迟上限的连接。输出最小生成树的边列表和总延迟。输出格式参照示例。
【输出示例】
射电望远镜阵列布局优化
==================================================
望远镜编号：0-7
禁止连接：{(1, 7), (0, 6)}
单条连接最大允许延迟：4.0微秒
所有可能的连接及信号延迟：
连接1: 望远镜0-望远镜1, 延迟: 2.1微秒 [可用]
连接2: 望远镜0-望远镜2, 延迟: 1.5微秒 [可用]
连接3: 望远镜0-望远镜3, 延迟: 4.2微秒 [禁用]
连接4: 望远镜0-望远镜4, 延迟: 3.8微秒 [可用]
连接5: 望远镜1-望远镜2, 延迟: 2.8微秒 [可用]
连接6: 望远镜1-望远镜5, 延迟: 3.1微秒 [可用]
连接7: 望远镜1-望远镜6, 延迟: 5.2微秒 [禁用]
连接8: 望远镜2-望远镜3, 延迟: 2.0微秒 [可用]
连接9: 望远镜2-望远镜7, 延迟: 4.5微秒 [禁用]
连接10: 望远镜3-望远镜4, 延迟: 1.8微秒 [可用]
连接11: 望远镜3-望远镜7, 延迟: 3.2微秒 [可用]
连接12: 望远镜4-望远镜5, 延迟: 2.5微秒 [可用]
连接13: 望远镜4-望远镜6, 延迟: 4.8微秒 [禁用]
连接14: 望远镜5-望远镜6, 延迟: 2.2微秒 [可用]
连接15: 望远镜5-望远镜7, 延迟: 3.7微秒 [可用]
连接16: 望远镜6-望远镜7, 延迟: 2.9微秒 [可用]
最优阵列布局（最小延迟连接方案）：
连接1: 望远镜0-望远镜2, 延迟: 1.5微秒
连接2: 望远镜3-望远镜4, 延迟: 1.8微秒
连接3: 望远镜2-望远镜3, 延迟: 2.0微秒
连接4: 望远镜0-望远镜1, 延迟: 2.1微秒
连接5: 望远镜5-望远镜6, 延迟: 2.2微秒
连接6: 望远镜4-望远镜5, 延迟: 2.5微秒
连接7: 望远镜6-望远镜7, 延迟: 2.9微秒
总信号延迟: 15.0微秒
UV覆盖评分: 0.702（越高越好）
连通性验证: 所有望远镜形成一个整体
试题18：宇宙事件因果网络
【题目描述】
宇宙事件之间存在因果依赖关系，必须遵循时间顺序。给定以下事件及依赖（有向边表示前因后果）：
测试数据：
# 添加宇宙事件（基于真实天文过程）
cosmic_events = [
(1, "恒星形成", "大质量恒星在星系中形成"),
(2, "恒星演化", "恒星经历完整生命周期"),
(3, "超新星爆发", "大质量恒星坍缩引发超新星爆发"),
(4, "黑洞形成", "超新星残骸坍缩形成恒星质量黑洞"),
(5, "黑洞配对", "两个黑洞在矮星系中形成配对系统[6](@ref)"),
(6, "轨道衰变", "黑洞对通过引力波辐射损失角动量[6](@ref)"),
(7, "黑洞合并", "两个黑洞最终合并形成更大黑洞[7](@ref)"),
(8, "引力波产生", "合并过程产生强烈引力波信号"),
(9, "引力波传播", "引力波以光速在宇宙中传播"),
(10, "LISA探测", "激光干涉仪太空天线探测到引力波[6](@ref)")
]
# 添加合理的因果关系（无环情况）
reasonable_causalities = [
(1, 2), # 恒星形成 → 恒星演化
(2, 3), # 恒星演化 → 超新星爆发
(3, 4), # 超新星爆发 → 黑洞形成
(4, 5), # 黑洞形成 → 黑洞配对
(5, 6), # 黑洞配对 → 轨道衰变
(6, 7), # 轨道衰变 → 黑洞合并
(7, 8), # 黑洞合并 → 引力波产生
(8, 9), # 引力波产生 → 引力波传播
(9, 10) # 引力波传播 → LISA探测
]
# 添加循环因果关系（违反因果律的情况）
cyclic_causalities = [
(10, 1), # LISA探测 → 恒星形成（时间倒流！）
(7, 3) # 黑洞合并 → 超新星爆发（因果颠倒）
]
请进行拓扑排序，输出合理的事件顺序。若添加循环依赖（如10→1, 7→3），检测并报告存在因果环。
【题目要求】
实现 Kahn 算法进行拓扑排序和环检测。分别测试无环依赖和有环依赖两种情况，输出结果。
【输出示例】
=== 宇宙事件因果网络分析 ===
测试1 - 合理的黑洞合并事件链:
检测到因果环: False
合理的事件发生顺序:
1. 恒星形成 - 大质量恒星在星系中形成
2. 恒星演化 - 恒星经历完整生命周期
3. 超新星爆发 - 大质量恒星坍缩引发超新星爆发
4. 黑洞形成 - 超新星残骸坍缩形成恒星质量黑洞
5. 黑洞配对 - 两个黑洞在矮星系中形成配对系统
6. 轨道衰变 - 黑洞对通过引力波辐射损失角动量
7. 黑洞合并 - 两个黑洞最终合并形成更大黑洞
8. 引力波产生 - 合并过程产生强烈引力波信号
9. 引力波传播 - 引力波以光速在宇宙中传播
10. LISA探测 - 激光干涉仪太空天线探测到引力波
测试2 - 有循环因果的宇宙事件:
检测到因果环: True
发现违反因果律的事件序列！
涉及循环的事件: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
这表示存在时间倒流或因果悖论，在物理学上不可能发生
测试3 - '黑洞合并'到'LISA探测'的因果链:
因果链: [7, 8, 9, 10]
详细路径:
↳ 黑洞合并
↳ 引力波产生
↳ 引力波传播
↳ LISA探测
试题19：Prim算法构建古村落通信网
【题目描述】
有6个古村落（编号0-5），它们之间可能的连接线路及距离如下：
# 测试数据：古村落通信网络
# 村落编号：0-5代表6个古村落
villages_connections = [
(0, 1, 10), # 村落0到村落1，距离10公里
(0, 2, 20), # 村落0到村落2，距离20公里
(1, 2, 15), # 村落1到村落2，距离15公里
(1, 3, 25), # 村落1到村落3，距离25公里
(2, 4, 30), # 村落2到村落4，距离30公里
(3, 4, 20), # 村落3到村落4，距离20公里
(3, 5, 15), # 村落3到村落5，距离15公里
(4, 5, 10) # 村落4到村落5，距离10公里
]
请使用 Prim 算法（从0开始）找出连接所有村落的最小总成本网络，输出选择的线路及总成本。
【题目要求】
实现 Prim 算法（可用优先队列优化），输出最小生成树的边及总距离。输出格式参照示例。
【输出示例】
=== 古村落通信网络最小成本规划 === 村落连接关系及距离： 村落0 ↔ 村落1 : 10公里 村落0 ↔ 村落2 : 20公里 村落1 ↔ 村落2 : 15公里 村落1 ↔ 村落3 : 25公里 村落2 ↔ 村落4 : 30公里 村落3 ↔ 村落4 : 20公里 村落3 ↔ 村落5 : 15公里 村落4 ↔ 村落5 : 10公里 ================================================== 📡 最小成本通信网络规划结果： 选择的连接线路： 线路1: 村落0 ↔ 村落1 : 10公里 线路2: 村落1 ↔ 村落2 : 15公里 线路3: 村落1 ↔ 村落3 : 25公里 线路4: 村落3 ↔ 村落5 : 15公里 线路5: 村落5 ↔ 村落4 : 10公里 总成本: 75公里 连接村落数量: 6个 ✅ 成功连接所有村落！
试题20：传统文化中的数字排列——单调递增数字
【题目描述】
给定一个正整数 n，求小于或等于 n 的最大整数，且该整数的各位数字从左到右单调不减（即每个数字不小于前一个数字）。例如 322 应返回 299。
# 测试案例：传统文化中的吉祥数字
test_cases = [
10, # 示例1：10 → 9
1234, # 示例2：1234 → 1234 (本身就是单调递增)
332, # 示例3：332 → 299
100, # 示例4：100 → 99
4321, # 示例5：4321 → 3999
2876, # 示例6：2876 → 2799
]
【题目要求】
实现贪心算法：从高位到低位扫描，找到第一个递减位置，将该位减1，后面所有位设为9。注意处理前导0（实际不会出现，因数字本身可能减小位数？但如100应得99）。输出每个用例的转换结果。
【输出示例】
传统文化中，单调递增的数字象征着顺利和吉祥 让我们分析几个数字的转化过程： 案例1: 原始数字 = 10 转换结果 = 9 案例2: 原始数字 = 1234 转换结果 = 1234 案例3: 原始数字 = 332 转换结果 = 299 案例4: 原始数字 = 100 转换结果 = 99 案例5: 原始数字 = 4321 转换结果 = 3999 案例6: 原始数字 = 2876 转换结果 = 2799
试题21：京杭大运河货物运输最小成本路径
【题目描述】
运河运输网络可抽象为一个4×4的网格，每个格子表示一个中转站，格子内的数字表示经过该站点的运输成本（元/吨）。从左上角(0,0)出发，只能向右或向下移动，到达右下角(3,3)。网格成本如下：
# 模拟运河运输网络：杭州→苏州→镇江→济宁的运输成本
# 数据代表不同运输路段的成本（单位：元/吨）
canal_network = [
[2, 4, 1, 3], # 杭州到周边城市的基础运输成本
[1, 3, 2, 1], # 苏南地区运输成本
[3, 1, 1, 2], # 苏北地区运输成本
[2, 2, 3, 1] # 鲁南地区到梁山港的成本
]
请使用动态规划求最小总运输成本，并输出最终的DP表格及最小成本。
【题目要求】
实现二维动态规划，状态 dp[i][j] 表示从起点到 (i,j) 的最小成本。输出最终DP表格和最小成本。
【输出示例】
京杭大运河货物运输最小成本路径规划
============================================================
运河运输网络成本图：
2 4 1 3
1 3 2 1
3 1 1 2
2 2 3 1
最终DP表格：
2 6 7 10
3 6 8 9
6 7 8 10
8 9 11 11
最小运输成本: 11 元/吨
试题22：背包问题与应用——“一和零”的二进制字符串选择
【题目描述】
给定一个二进制字符串列表，以及两个整数 m 和 n，分别表示最多能拥有的0的个数和1的个数。每个字符串要么全选要么不选。求最多能选多少个字符串，使得所选字符串中0的总数 ≤ m，1的总数 ≤ n。
测试用例：
"""用多个例子演示算法"""
examples = [
{
"strs": ["10", "0001", "111001", "1", "0"],
"m": 5,
"n": 3,
"description": "经典示例：可以选出4个字符串"
},
{
"strs": ["111", "000", "1010"],
"m": 2,
"n": 2,
"description": "限制严格示例：选择有限"
}
]
请对每个用例输出最大子集大小。
【题目要求】
将问题转化为二维费用背包问题，使用动态规划（状态压缩）求解。输出每个用例的结果。
【输出示例】
一和零问题：二维费用背包实战
============================================================
示例 1: 经典示例：可以选出4个字符串
字符串列表: ['10', '0001', '111001', '1', '0']
限制条件: 最多5个0, 最多3个1
==================================================
🎯 结果: 最大子集大小为 4
============================================================
示例 2: 限制严格示例：选择有限
字符串列表: ['111', '000', '1010']
限制条件: 最多2个0, 最多2个1
==================================================
🎯 结果: 最大子集大小为 1
试题23：古诗对齐中的最长公共子序列
【题目描述】
给定两首古诗（字符串），求它们的最长公共子序列（LCS）的长度和具体序列（不要求连续但顺序一致）。测试用例：
#测试数据 古诗例子
poems = [
{
"title1": "《静夜思》",
"poem1": "床前明月光 疑是地上霜",
"title2": "《望月怀远》",
"poem2": "海上生明月 天涯共此时",
"description": "经典例子：都包含'明月'"
},
{
"title1": "《春晓》",
"poem1": "春眠不觉晓 处处闻啼鸟",
"title2": "《春夜喜雨》",
"poem2": "好雨知时节 当春乃发生",
"description": "中等难度：共同字符较少"
}
]
请输出每对古诗的LCS长度和具体序列（若有多个，输出任意一个）。
【题目要求】
实现动态规划算法求解LCS，输出长度和序列。输出格式参照示例。
【输出示例】
古诗对齐：最长公共子序列(LCS)探索
通过动态规划发现古诗中的隐藏联系！
============================================================
例子 1: 经典例子：都包含'明月'
============================================================
《静夜思》: 床前明月光 疑是地上霜
《望月怀远》: 海上生明月 天涯共此时
古诗LCS分析：
诗1: 床前明月光疑是地上霜
诗2: 海上生明月天涯共此时
分析结果：
最长公共子序列长度: 2
具体序列: 明月
============================================================
============================================================
例子 2: 中等难度：共同字符较少
============================================================
《春晓》: 春眠不觉晓 处处闻啼鸟
《春夜喜雨》: 好雨知时节 当春乃发生
古诗LCS分析：
诗1: 春眠不觉晓处处闻啼鸟
诗2: 好雨知时节当春乃发生
分析结果：
最长公共子序列长度: 1
具体序列: 春
============================================================
试题24：古建筑修复成本优化
【题目描述】
一段长20米的城墙上有5个破损点，位置分别为 [2, 5, 8, 12, 15] 米处。每次可以修复一段连续区间，成本等于该段长度。修复时可以选择任意顺序，但每次修复必须覆盖一段连续破损区域（可能包含已修复段？题目应理解为每次修复一段连续的破损区间，且修复后该段变为完好，后续修复不能断开？实际上类似“合并石子”问题：每次修复一段连续破损，成本为区间长度，修复后该段合并，后续修复若跨越已修复段则整体长度累加。但原题描述类似区间DP：有破损点，每次修复一段连续城墙（可能包含完好部分？），成本为该段长度。要求最小总成本。这类似于“最优二叉搜索树”或“矩阵链乘”的区间DP。
更准确描述：有n个破损点，它们将城墙分成若干段。每次可以选择一个破损点进行修复，但修复一个点实际上会将该点变为完好，且其左右两侧若已修复则可连通成更大连续段？原题输出示例显示DP过程较长，我们简化：给定破损点位置，求最小修复总成本，其中修复一段连续区间（从某个破损点到另一个破损点）的成本等于区间长度（即最后一个破损点坐标减第一个破损点坐标）。每次修复后该段内的所有破损点被修复，后续不能再单独修复其中的点。求修复所有破损点的最小总成本。
实际上这是“戳气球”或“合并石子”的变形。我们按原题提供的数据和输出示例，可以理解为区间DP：状态 dp[i][j] 表示修复从第i个破损点到第j个破损点这段区间的最小成本，转移时枚举最后修复的断点k，成本为 dp[i][k-1] + dp[k+1][j] + (pos[j+1] - pos[i-1])，其中边界需要处理虚拟端点0和城墙末端20。
题目要求：对给定的场景（城墙长20，破损点[2,5,8,12,15]）求解最小成本，并输出DP过程（可选）和最终结果。
#测试数据：演示不同场景下的修复成本优化
scenarios = [
{
"name": "基础案例-5个破损点",
"wall_length": 20,
"damage_points": [2, 5, 8, 12, 15],
"description": "中等复杂度，展示典型优化效果"
},
{
"name": "简单案例-3个破损点",
"wall_length": 10,
"damage_points": [3, 6, 9],
"description": "简单案例，便于理解算法流程"
}
]
【题目要求】
实现区间动态规划，输出最小修复成本。可参考示例输出中的过程（简化或只输出最终结果）。但示例给出了详细过程，竞赛题可要求输出最终成本即可。为简化，本题只要求输出最小成本。
【输出示例】
🏯 古建筑修复成本优化系统
============================================================
场景1: 基础案例-5个破损点
描述: 中等复杂度，展示典型优化效果
--------------------------------------------------
古建筑修复成本优化分析
==================================================
城墙总长度: 20米
破损点位置: [2, 5, 8, 12, 15]
完整点序列: [0, 2, 5, 8, 12, 15, 20]
开始动态规划填表过程:
----------------------------------------
处理区间[0-5]，长度5米
分割点2: 成本 = dp[0][1](0) + dp[1][2](0) + 5 = 5
✅ 更新最小成本: 5
处理区间[2-8]，长度6米
分割点5: 成本 = dp[1][2](0) + dp[2][3](0) + 6 = 6
✅ 更新最小成本: 6
处理区间[5-12]，长度7米
分割点8: 成本 = dp[2][3](0) + dp[3][4](0) + 7 = 7
✅ 更新最小成本: 7
处理区间[8-15]，长度7米
分割点12: 成本 = dp[3][4](0) + dp[4][5](0) + 7 = 7
✅ 更新最小成本: 7
处理区间[12-20]，长度8米
分割点15: 成本 = dp[4][5](0) + dp[5][6](0) + 8 = 8
✅ 更新最小成本: 8
处理区间[0-8]，长度8米
分割点2: 成本 = dp[0][1](0) + dp[1][3](6) + 8 = 14
✅ 更新最小成本: 14
分割点5: 成本 = dp[0][2](5) + dp[2][3](0) + 8 = 13
✅ 更新最小成本: 13
处理区间[2-12]，长度10米
分割点5: 成本 = dp[1][2](0) + dp[2][4](7) + 10 = 17
✅ 更新最小成本: 17
分割点8: 成本 = dp[1][3](6) + dp[3][4](0) + 10 = 16
✅ 更新最小成本: 16
处理区间[5-15]，长度10米
分割点8: 成本 = dp[2][3](0) + dp[3][5](7) + 10 = 17
✅ 更新最小成本: 17
分割点12: 成本 = dp[2][4](7) + dp[4][5](0) + 10 = 17
❌ 保持当前最小成本: 17
处理区间[8-20]，长度12米
分割点12: 成本 = dp[3][4](0) + dp[4][6](8) + 12 = 20
✅ 更新最小成本: 20
分割点15: 成本 = dp[3][5](7) + dp[5][6](0) + 12 = 19
✅ 更新最小成本: 19
处理区间[0-12]，长度12米
分割点2: 成本 = dp[0][1](0) + dp[1][4](16) + 12 = 28
✅ 更新最小成本: 28
分割点5: 成本 = dp[0][2](5) + dp[2][4](7) + 12 = 24
✅ 更新最小成本: 24
分割点8: 成本 = dp[0][3](13) + dp[3][4](0) + 12 = 25
❌ 保持当前最小成本: 24
处理区间[2-15]，长度13米
分割点5: 成本 = dp[1][2](0) + dp[2][5](17) + 13 = 30
✅ 更新最小成本: 30
分割点8: 成本 = dp[1][3](6) + dp[3][5](7) + 13 = 26
✅ 更新最小成本: 26
分割点12: 成本 = dp[1][4](16) + dp[4][5](0) + 13 = 29
❌ 保持当前最小成本: 26
处理区间[5-20]，长度15米
分割点8: 成本 = dp[2][3](0) + dp[3][6](19) + 15 = 34
✅ 更新最小成本: 34
分割点12: 成本 = dp[2][4](7) + dp[4][6](8) + 15 = 30
✅ 更新最小成本: 30
分割点15: 成本 = dp[2][5](17) + dp[5][6](0) + 15 = 32
❌ 保持当前最小成本: 30
处理区间[0-15]，长度15米
分割点2: 成本 = dp[0][1](0) + dp[1][5](26) + 15 = 41
✅ 更新最小成本: 41
分割点5: 成本 = dp[0][2](5) + dp[2][5](17) + 15 = 37
✅ 更新最小成本: 37
分割点8: 成本 = dp[0][3](13) + dp[3][5](7) + 15 = 35
✅ 更新最小成本: 35
分割点12: 成本 = dp[0][4](24) + dp[4][5](0) + 15 = 39
❌ 保持当前最小成本: 35
处理区间[2-20]，长度18米
分割点5: 成本 = dp[1][2](0) + dp[2][6](30) + 18 = 48
✅ 更新最小成本: 48
分割点8: 成本 = dp[1][3](6) + dp[3][6](19) + 18 = 43
✅ 更新最小成本: 43
分割点12: 成本 = dp[1][4](16) + dp[4][6](8) + 18 = 42
✅ 更新最小成本: 42
分割点15: 成本 = dp[1][5](26) + dp[5][6](0) + 18 = 44
❌ 保持当前最小成本: 42
处理区间[0-20]，长度20米
分割点2: 成本 = dp[0][1](0) + dp[1][6](42) + 20 = 62
✅ 更新最小成本: 62
分割点5: 成本 = dp[0][2](5) + dp[2][6](30) + 20 = 55
✅ 更新最小成本: 55
分割点8: 成本 = dp[0][3](13) + dp[3][6](19) + 20 = 52
✅ 更新最小成本: 52
分割点12: 成本 = dp[0][4](24) + dp[4][6](8) + 20 = 52
❌ 保持当前最小成本: 52
分割点15: 成本 = dp[0][5](35) + dp[5][6](0) + 20 = 55
❌ 保持当前最小成本: 52
📊 优化结果:
最小修复成本: 52
城墙长度: 20米
破损点数量: 5个
平均每米成本: 2.60
✅ 成本验证通过
============================================================
场景2: 简单案例-3个破损点
描述: 简单案例，便于理解算法流程
--------------------------------------------------
古建筑修复成本优化分析
==================================================
城墙总长度: 10米
破损点位置: [3, 6, 9]
完整点序列: [0, 3, 6, 9, 10]
开始动态规划填表过程:
----------------------------------------
处理区间[0-6]，长度6米
分割点3: 成本 = dp[0][1](0) + dp[1][2](0) + 6 = 6
✅ 更新最小成本: 6
处理区间[3-9]，长度6米
分割点6: 成本 = dp[1][2](0) + dp[2][3](0) + 6 = 6
✅ 更新最小成本: 6
处理区间[6-10]，长度4米
分割点9: 成本 = dp[2][3](0) + dp[3][4](0) + 4 = 4
✅ 更新最小成本: 4
处理区间[0-9]，长度9米
分割点3: 成本 = dp[0][1](0) + dp[1][3](6) + 9 = 15
✅ 更新最小成本: 15
分割点6: 成本 = dp[0][2](6) + dp[2][3](0) + 9 = 15
❌ 保持当前最小成本: 15
处理区间[3-10]，长度7米
分割点6: 成本 = dp[1][2](0) + dp[2][4](4) + 7 = 11
✅ 更新最小成本: 11
分割点9: 成本 = dp[1][3](6) + dp[3][4](0) + 7 = 13
❌ 保持当前最小成本: 11
处理区间[0-10]，长度10米
分割点3: 成本 = dp[0][1](0) + dp[1][4](11) + 10 = 21
✅ 更新最小成本: 21
分割点6: 成本 = dp[0][2](6) + dp[2][4](4) + 10 = 20
✅ 更新最小成本: 20
分割点9: 成本 = dp[0][3](15) + dp[3][4](0) + 10 = 25
❌ 保持当前最小成本: 20
📊 优化结果:
最小修复成本: 20
城墙长度: 10米
破损点数量: 3个
平均每米成本: 2.00
✅ 成本验证通过
============================================================
试题25：古诗词作者校对系统
【题目描述】
设计一个古诗词作者校对系统，能够处理大规模古诗词数据，实现作者信息的去重与校验。给定测试数据（诗作，作者名），其中可能包含同一诗作被不同作者名记录的情况（如李白与李太白），需要根据作者别名映射统一作者。数据如下：
self.author_poems = {} # 作者到诗作的映射
self.poem_to_author = {} # 诗作到作者的映射（用于去重）
self.author_variations = { # 作者别名统一映射
'李白': ['李太白', '太白', '诗仙'],
'杜甫': ['杜子美', '子美', '诗圣'],
'苏轼': ['苏东坡', '东坡', '苏子瞻']
}
# 添加测试数据
test_data = [
("朝辞白帝彩云间", "李白"),
("床前明月光", "李白"),
("春眠不觉晓", "孟浩然"),
("国破山河在", "杜甫"),
("明月几时有", "苏轼"),
("朝辞白帝彩云间", "李太白"), # 重复诗作，不同作者名
("静夜思", "李白"),
("静夜思", "太白") # 重复诗作
]
作者别名映射：
- 李白别名：李太白、太白、诗仙
- 杜甫别名：杜子美、子美、诗圣
- 苏轼别名：苏东坡、东坡、苏子瞻
要求：
- 添加所有数据，遇到重复诗作（内容相同）则拒绝添加，并输出提示。
- 统计每位作者的诗作数量（按标准姓名）。
- 对比使用朴素算法（列表遍历）和优化算法（集合/字典）在去重时的性能（如查找重复诗作的时间），输出性能对比。
【题目要求】
实现 AuthorProofreader 类，包含添加诗作、统计、性能对比等方法。输出添加过程、统计结果和性能对比。
【输出示例】
=== 古诗词作者校对系统 ===
√ 添加成功：《朝辞白帝彩云间》- 李白
√ 添加成功：《床前明月光》- 李白
√ 添加成功：《春眠不觉晓》- 孟浩然
√ 添加成功：《国破山河在》- 杜甫
√ 添加成功：《明月几时有》- 苏轼
× 添加失败（重复）：《朝辞白帝彩云间》- 李太白
√ 添加成功：《静夜思》- 李白
× 添加失败（重复）：《静夜思》- 太白
=== 李白诗作统计 ===
1. 朝辞白帝彩云间
2. 床前明月光
3. 静夜思
=== 作者统计 ===
李白: 3首
孟浩然: 1首
杜甫: 1首
苏轼: 1首
=== 算法性能对比测试 ===
优化算法耗时: 0.0011秒
朴素算法耗时: 0.5651秒
性能提升: 522.6倍
检测到重复诗作: 2首
试题26：传统纹样生成算法的空间复杂度优化
【题目描述】
使用生成器惰性生成传统对称纹样（例如菱形纹）。要求生成一个9行的菱形图案，由 # 组成，行数为奇数，中间行最长，上下对称。不使用生成器时，需要存储所有行；使用生成器则逐行生成，节省内存。请分别实现“完全存储”和“生成器”两种方式，并输出生成的图案。对比两种方式的内存占用（可简单通过存储元素个数说明）。
【题目要求】
实现函数 generate_pattern(levels)，levels=5 表示最宽处有5个 #，总行数为9。完全存储版本返回列表，生成器版本使用 yield 逐行输出。输出两种方式生成的图案，并给出空间对比说明。
【输出示例】
=== 基础版本：完全存储模式 ===
生成的中间图案数量: 9
存储的内容示例:
生成第1行: #
生成第2行: ###
生成第3行: #####
生成第4行: #######
生成第5行: #########
生成第6行: #######
生成第7行: #####
生成第8行: ###
生成第9行: #
最终图案:
#
###
#####
#######
#########
#######
#####
###
#
============================================================
=== 优化版本：生成器惰性计算 ===
生成 5 级传统对称纹样
使用生成器，不预先计算所有行...
生成器创建完成，尚未开始计算
开始逐行生成:
生成第1行: #
生成第2行: ###
生成第3行: #####
生成第4行: #######
生成第5行: #########
生成第6行: #######
生成第7行: #####
生成第8行: ###
生成第9行: #
最终图案（逐行生成，不存储中间状态）:
#
###
#####
#######
#########
#######
#####
###
#
试题27：飞花令辅助系统
【题目描述】
设计一个飞花令查询辅助系统，能够快速找出包含特定字且不属于指定题材的所有诗句。给定7首示例诗歌（数据见文档），每首诗歌包含标题、作者、内容、题材集合。要求实现两种查询方式：
- 列表遍历法：遍历所有诗歌，检查内容是否包含关键字，题材是否不包含排除题材。
- 集合运算法：预先建立每个字到诗歌的倒排索引，以及每个题材到诗歌的索引，利用集合差集快速得到结果。
对关键字“月”和排除题材“战争”进行查询，输出两种方法的结果和耗时对比。
"""初始化示例诗歌数据"""
sample_poems = [
{"title": "静夜思", "author": "李白", "content": "床前明月光，疑是地上霜。举头望明月，低头思故乡。",
"themes": {"思乡", "月亮"}},
{"title": "春望", "author": "杜甫", "content": "国破山河在，城春草木深。感时花溅泪，恨别鸟惊心。",
"themes": {"战争", "爱国"}},
{"title": "水调歌头", "author": "苏轼", "content": "明月几时有，把酒问青天。不知天上宫阙，今夕是何年。",
"themes": {"月亮", "抒情"}},
{"title": "出塞", "author": "王昌龄",
"content": "秦时明月汉时关，万里长征人未还。但使龙城飞将在，不教胡马度阴山。",
"themes": {"月亮", "战争", "边塞"}},
{"title": "望月怀远", "author": "张九龄", "content": "海上生明月，天涯共此时。情人怨遥夜，竟夕起相思。",
"themes": {"月亮", "思念"}},
{"title": "木兰诗", "author": "佚名", "content": "朔气传金柝，寒光照铁衣。将军百战死，壮士十年归。",
"themes": {"战争", "英雄"}},
{"title": "山居秋暝", "author": "王维", "content": "明月松间照，清泉石上流。竹喧归浣女，莲动下渔舟。",
"themes": {"月亮", "山水"}},
]
【题目要求】
实现诗歌库，支持按关键字和排除题材查询。输出查询结果和性能对比。
【输出示例】
=== 飞花令诗词查询辅助系统 ===
系统功能：快速查找包含指定字且排除特定题材的诗句
诗歌库数量：7 首
现有题材分类：山水, 爱国, 月亮, 思念, 英雄, 思乡, 边塞, 抒情, 战争
==================================================
1. 单次查询演示
2. 性能对比测试
3. 退出系统
请选择功能（1-3）: 1
请输入要查询的关键字: 月
请输入要排除的题材（多个用逗号分隔）: 战争
列表遍历法结果 (共4首):
============================================================
1. 《静夜思》 - 李白
诗句: 床前明月光，疑是地上霜。举头望明月，低头思故乡。
题材: 月亮, 思乡
2. 《水调歌头》 - 苏轼
诗句: 明月几时有，把酒问青天。不知天上宫阙，今夕是何年。
题材: 抒情, 月亮
3. 《望月怀远》 - 张九龄
诗句: 海上生明月，天涯共此时。情人怨遥夜，竟夕起相思。
题材: 月亮, 思念
4. 《山居秋暝》 - 王维
诗句: 明月松间照，清泉石上流。竹喧归浣女，莲动下渔舟。
题材: 山水, 月亮
集合运算法结果 (共4首):
============================================================
1. 《静夜思》 - 李白
诗句: 床前明月光，疑是地上霜。举头望明月，低头思故乡。
题材: 月亮, 思乡
2. 《水调歌头》 - 苏轼
诗句: 明月几时有，把酒问青天。不知天上宫阙，今夕是何年。
题材: 抒情, 月亮
3. 《望月怀远》 - 张九龄
诗句: 海上生明月，天涯共此时。情人怨遥夜，竟夕起相思。
题材: 月亮, 思念
4. 《山居秋暝》 - 王维
诗句: 明月松间照，清泉石上流。竹喧归浣女，莲动下渔舟。
题材: 山水, 月亮
结果一致性检查: 通过
==================================================
1. 单次查询演示
2. 性能对比测试
3. 退出系统
请选择功能（1-3）: 2
请输入要查询的关键字: 月
请输入要排除的题材（多个用逗号分隔）: 战争
请输入测试次数: 2
正在查询包含『月』且不包含题材{'战争'}的诗句...
性能测试结果 (2次查询):
列表遍历法总耗时: 0.000029 秒
集合运算法总耗时: 0.000020 秒
集合运算比列表遍历快 1.5 倍！
找到 4 首符合条件诗歌
==================================================
1. 单次查询演示
2. 性能对比测试
3. 退出系统
请选择功能（1-3）: 3
感谢使用飞花令辅助系统！
试题28：传统节日文化展示优化
【题目描述】
策划一场传统节日文化活动，场地最大宽度为10，总时间为8个单位。有6个展台，每个展台需要占用一定宽度、耗时、产生人气值和文化影响力（数据如下）：
# 设置场地和时间限制
MAX_WIDTH = 10 # 场地最大宽度
TOTAL_TIME = 8 # 总时间单位
# 定义传统节日文化展台数据
# 每个展台：(宽度, 耗时, 人气值, 文化影响力)
traditional_booths = [
(2, 3, 5, 4), # 春节展台：写春联、剪纸
(3, 2, 6, 5), # 元宵展台：灯笼制作、灯谜
(4, 4, 8, 7), # 端午展台：包粽子、龙舟模型
(3, 3, 7, 6), # 中秋展台：月饼制作、赏月
(2, 2, 4, 4), # 重阳展台：菊花酒、登高
(5, 3, 9, 8), # 七夕展台：刺绣、鹊桥
]
要求在宽度和时间限制内选择展台组合，使得总效益（人气值 + 文化影响力）最大化。请使用三维动态规划求解，并输出最优方案的总效益、所用展台列表，以及动态规划表的部分内容。
【题目要求】
实现三维DP（展台索引、已用宽度、已用时间），状态转移为选或不选。输出最大总效益、选择的展台、以及DP表的部分行（如宽度0-6，时间0-6的最终值）。输出格式参照示例。
【输出示例】
=== 传统节日文化展示优化系统 ===
场地限制: 宽度10单位，时间8单位
可用展台列表:
春节展台: 宽度2, 耗时3, 人气5, 文化影响力4
元宵展台: 宽度3, 耗时2, 人气6, 文化影响力5
端午展台: 宽度4, 耗时4, 人气8, 文化影响力7
中秋展台: 宽度3, 耗时3, 人气7, 文化影响力6
重阳展台: 宽度2, 耗时2, 人气4, 文化影响力4
七夕展台: 宽度5, 耗时3, 人气9, 文化影响力8
=== 最优安排方案 ===
最大总效益: 38
使用场地: 宽度10/10, 时间8/8
选择的展台:
中秋展台: 宽度3, 耗时3, 人气7, 文化影响力6
重阳展台: 宽度2, 耗时2, 人气4, 文化影响力4
七夕展台: 宽度5, 耗时3, 人气9, 文化影响力8
总人气值: 20
总文化影响力: 18
=== 动态规划表（部分）===
宽度\时间 0 1 2 3 4 5 6
W=0 | 0 0 0 0 0 0 0
W=1 | 0 0 0 0 0 0 0
W=2 | 0 0 8 9 9 9 9
W=3 | 0 0 11 13 13 13 13
W=4 | 0 0 11 13 15 17 17
W=5 | 0 0 11 17 19 21 22
W=6 | 0 0 11 17 19 24 24
W=7 | 0 0 11 17 19 25 26
=== 不同策略对比 ===
单一目标优化:
仅优化人气: 效益20, 展台['春节', '元宵', '七夕']
仅优化影响力: 效益18, 展台['中秋', '重阳', '七夕']
多目标优化: 效益38, 展台['中秋', '重阳', '七夕']
=== 效益分析 ===
多目标优化方案的实际效果:
- 人气值: 20 (占最大可能性的100.0%)
- 文化影响力: 18 (占最大可能性的100.0%)
说明：多目标优化在两者之间取得了良好平衡
❀ 亚 军 题 库 ❀ 返回最前
试题1：玩具积木塔搭建
【题目描述】
玩具积木塔可以用栈来模拟，每次只能从塔顶添加或拿走积木，体现了后进先出的特性。请实现一个程序，模拟以下操作：
- 初始化一个空积木塔（空栈）。
- 依次往塔顶添加积木：红色积木、蓝色积木、绿色积木。
- 查看当前塔顶积木。
- 从塔顶拿走一块积木（并输出拿走的积木）。
- 再拿走一块积木。
- 尝试从空塔拿走积木时，进行错误处理。
【题目要求】
编写程序，按照上述顺序执行操作，并输出每一步的结果。要求使用列表模拟栈，利用append()实现压栈，pop()实现弹栈，并正确处理空栈情况。输出格式请严格参照示例。
【输出示例】
初始积木塔: [] 添加三块积木后: ['红色积木', '蓝色积木', '绿色积木'] 当前塔顶积木: 绿色积木 拿走了: 绿色积木, 剩余积木: ['红色积木', '蓝色积木'] 又拿走了: 蓝色积木, 剩余积木: ['红色积木'] 积木塔已经空了，不能再拿了！
试题2：智能家居设备响应优先级
【题目描述】
设计一个智能家居任务管理系统，每个设备任务包含设备描述和优先级（数值越小优先级越高）。系统需要支持添加任务、执行最高优先级任务、动态调整任务优先级。请使用优先队列（最小堆）实现。
初始任务如下：
- 添加任务：”空调: 调节至26℃”，优先级2
- 添加任务：”灯光: 切换温馨模式”，优先级3
- 添加任务：”音箱: 播放晨间音乐”，优先级1
- 添加任务：”窗帘: 打开50%”，优先级4
随后依次执行：
- 显示当前任务队列（按优先级排序）。
- 执行两个最高优先级任务。
- 将“灯光: 切换温馨模式”的优先级调整为0。
- 继续执行所有剩余任务，直到队列为空。
【题目要求】
实现一个SmartHomeSystem类，包含添加任务、执行任务、调整优先级、显示任务队列等方法。按照上述操作顺序输出每一步的结果。输出格式参照示例。
【输出示例】
添加任务: 空调: 调节至26℃ (优先级:2) 添加任务: 灯光: 切换温馨模式 (优先级:3) 添加任务: 音箱: 播放晨间音乐 (优先级:1) 添加任务: 窗帘: 打开50% (优先级:4) 当前任务队列(按优先级排序): - 音箱: 播放晨间音乐 (优先级:1) - 空调: 调节至26℃ (优先级:2) - 灯光: 切换温馨模式 (优先级:3) - 窗帘: 打开50% (优先级:4) 执行任务: 执行任务: 音箱: 播放晨间音乐 (优先级:1) 执行任务: 空调: 调节至26℃ (优先级:2) 调整优先级: 调整任务优先级: 灯光: 切换温馨模式 → 0 执行调整后的任务: 执行任务: 灯光: 切换温馨模式 (优先级:0) 执行任务: 窗帘: 打开50% (优先级:4) 最终任务队列: 当前没有待执行任务
试题3：校园家族树
【题目描述】
构建一个校园家族树，模拟学校成员之间的层级关系。校长为根节点，下面有老师，老师下面有学生。每个成员有姓名和角色。要求实现以下功能：
- 初始化校长“张校长”。
- 添加数学老师“李老师”和英语老师“王老师”作为校长的子节点。
- 为数学老师添加学生“小明”、“小红”；为英语老师添加学生“小刚”。
- 显示完整的家族树结构（带缩进）。
- 查找成员“小红”并输出其信息。
- 统计校园总人数。
- 从数学老师处移除学生“小明”，并再次显示树结构及总人数。
【题目要求】
定义CampusMember类，包含姓名、角色和子节点列表。实现添加子节点、移除子节点、查找成员、显示树（递归）、统计人数等方法。按照上述步骤执行并输出结果。输出格式参照示例。
【输出示例】
校长 张校长 新增数学老师: 李老师
校长 张校长 新增英语老师: 王老师
数学老师 李老师 新增学生: 小明
数学老师 李老师 新增学生: 小红
英语老师 王老师 新增学生: 小刚
校园家族树结构:
校长 张校长
数学老师 李老师
学生 小明
学生 小红
英语老师 王老师
学生 小刚
查找测试:
找到成员: 学生 小红
校园总人数: 6人
移除测试:
已移除 小明
更新后的家族树:
校长 张校长
数学老师 李老师
学生 小红
英语老师 王老师
学生 小刚
更新后总人数: 5人
试题4：超市购物清单
【题目描述】
设计一个超市购物清单管理系统，使用集合存储商品，自动去重。实现以下功能：
- 创建两个购物清单：妈妈的清单和爸爸的清单。
- 妈妈添加商品：牛奶、鸡蛋、面包、苹果、鸡蛋、香蕉。
- 爸爸添加商品：啤酒、薯片、鸡蛋、牛排、苹果。
- 检查牛奶是否在妈妈的清单中，以及是否在爸爸的清单中。
- 求两个清单的交集（全家都需要买的商品）和差集（只需要妈妈买的商品）。
- 将爸爸的清单合并到妈妈的清单中，并显示合并后的清单。
- 从合并后的清单中移除“鸡蛋”，再尝试移除不存在的“冰淇淋”，并显示最终清单。
【题目要求】
实现ShoppingList类，封装集合操作：添加、删除、检查、并集、交集、差集。按照上述操作顺序输出每一步的结果。输出格式参照示例。
【输出示例】
妈妈在添加商品:
已添加: 牛奶
已添加: 鸡蛋
已添加: 面包
已添加: 苹果
已添加: 鸡蛋
已添加: 香蕉
爸爸在添加商品:
已添加: 啤酒
已添加: 薯片
已添加: 鸡蛋
已添加: 牛排
已添加: 苹果
检查商品:
牛奶在妈妈的清单中吗? True
牛奶在爸爸的清单中吗? False
集合运算结果:
全家都需要买的商品（交集）: {'苹果', '鸡蛋'}
只需要妈妈买的商品（差集）: {'牛奶', '面包', '香蕉'}
合并购物清单:
购物清单已合并
当前购物清单:
1. 啤酒
2. 牛奶
3. 牛排
4. 苹果
5. 薯片
6. 面包
7. 香蕉
8. 鸡蛋
尝试移除商品:
已移除: 鸡蛋
无法移除: 冰淇淋 不在清单中
当前购物清单:
1. 啤酒
2. 牛奶
3. 牛排
4. 苹果
5. 薯片
6. 面包
7. 香蕉
试题5：植物生长记录表
【题目描述】
使用namedtuple定义植物记录，包含名称、种植日期、高度、叶片数、光照时间、浇水量。创建初始记录：
- 葵花：2026-05-01，45cm，8叶，6小时，300ml
- 番茄：2026-05-10，32cm，12叶，5小时，250ml
- 薄荷：2026-04-25，15cm，24叶，4小时，200ml
要求实现以下功能：
- 显示所有植物记录。
- 将番茄的高度更新为38cm，并再次显示。
- 找出最高的植物并输出。
- 添加新植物“玫瑰”：2026-05-05，28cm，6叶，5小时，180ml，并显示所有记录。
【题目要求】
使用collections.namedtuple定义植物记录。实现显示、更新高度、找最高植物、添加植物的函数。按照上述步骤输出结果。输出格式参照示例。
【输出示例】
我的植物生长记录表 名称 种植日期 高度 叶片数 光照 水量 葵花 2026-05-01 45 8 6 300 番茄 2026-05-10 32 12 5 250 薄荷 2026-04-25 15 24 4 200 番茄 的高度已更新为 38cm 我的植物生长记录表 名称 种植日期 高度 叶片数 光照 水量 葵花 2026-05-01 45 8 6 300 番茄 2026-05-10 38 12 5 250 薄荷 2026-04-25 15 24 4 200 最高的植物是: 葵花 (45cm) 我的植物生长记录表 名称 种植日期 高度 叶片数 光照 水量 葵花 2026-05-01 45 8 6 300 番茄 2026-05-10 38 12 5 250 薄荷 2026-04-25 15 24 4 200 玫瑰 2026-05-05 28 6 5 180
试题6：电子宠物社交系统
【题目描述】
构建一个电子宠物社交网络，每个宠物有ID、名称和种类，宠物之间可以建立双向友谊关系。使用图（邻接表）表示网络。初始宠物：
- p1: 豆豆 (电子狗)
- p2: 毛毛 (电子猫)
- p3: 花花 (电子兔)
- p4: 球球 (电子仓鼠)
- p5: 闪电 (电子狐狸)
- p6: 泡泡 (电子鱼)
建立以下友谊关系（双向）：
p1-p2, p1-p3, p2-p4, p3-p4, p3-p5, p4-p6
要求：
- 输出豆豆的直接朋友。
- 从豆豆开始进行广度优先遍历，输出遍历顺序。
- 找出豆豆到泡泡的最短友谊链。
- 找出最受欢迎的宠物（朋友最多）。
- 为豆豆推荐可能认识的朋友（朋友的朋友，不包括已直接认识）。
【题目要求】
实现PetSocialNetwork类，包含添加宠物、添加友谊、获取朋友、BFS遍历、最短路径、最受欢迎宠物、朋友推荐等方法。按照上述步骤输出结果。输出格式参照示例。
【输出示例】
豆豆的直接朋友: ['花花', '毛毛'] 从豆豆出发的BFS遍历顺序: ['豆豆', '毛毛', '花花', '球球', '闪电', '泡泡'] 豆豆到泡泡的最短友谊链: ['豆豆', '毛毛', '球球', '泡泡'] 最受欢迎的宠物: 花花 (3个朋友) 给豆豆的朋友推荐: ['球球', '闪电']
试题7：图书馆找书系统
【题目描述】
图书馆的书籍已经按书名拼音顺序排好，现给出一个有序的书名列表，要求用二分查找算法快速找到目标书的位置。书列表如下：
["ATSTH安徒生童话", "BKQS百科全书", "HLBT哈利波特", "HLM红楼梦", "JYQJ金庸全集", "ST体", "SW十万个为什么", "XYJ西游记", "XWZ小王子", "ZGLS中国历史"]
查找目标书“HLBT哈利波特”。要求输出每次检查的中间书名，并给出最终位置。
【题目要求】
实现二分查找函数，输入有序列表和目标值，返回索引（从0开始）。在查找过程中，输出每次比较的中间书名。如果找到，输出位置（书架位置从1开始计数）；否则输出未找到。输出格式参照示例。
【输出示例】
开始在图书馆查找：《HLBT哈利波特》 正在检查：《JYQJ金庸全集》 正在检查：《BKQS百科全书》 正在检查：《HLBT哈利波特》 找到了！《HLBT哈利波特》在第3个书架位置
试题8：超市商品价格排行榜
【题目描述】
某超市有10种商品，每种商品有名称和价格（元）。初始数据如下：
[{"name": "可乐", "price": 3},
{"name": "薯片", "price": 5},
{"name": "矿泉水A", "price": 2},
{"name": "矿泉水B", "price": 2},
{"name": "牛奶", "price": 6},
{"name": "巧克力", "price": 10},
{"name": "饼干", "price": 4},
{"name": "口香糖", "price": 3},
{"name": "方便面", "price": 5},
{"name": "果汁", "price": 8}]
请使用选择排序按价格从低到高排序，并输出每一轮排序后的结果（只需输出关键轮次或最终结果，但需体现过程）。最后验证排序的稳定性：观察矿泉水A和矿泉水B的相对顺序是否改变。
【题目要求】
实现选择排序算法，要求输出每一轮排序后的商品列表（至少输出第一轮和最终结果），并验证相同价格商品的相对顺序。输出格式参照示例。
【输出示例】
===== 商品原始价格 ===== 可乐: ￥3 薯片: ￥5 矿泉水A: ￥2 矿泉水B: ￥2 牛奶: ￥6 巧克力: ￥10 饼干: ￥4 口香糖: ￥3 方便面: ￥5 果汁: ￥8 第1轮排序结果： 矿泉水A: ￥2 薯片: ￥5 可乐: ￥3 矿泉水B: ￥2 牛奶: ￥6 巧克力: ￥10 饼干: ￥4 口香糖: ￥3 方便面: ￥5 果汁: ￥8 本轮选择：矿泉水A ￥2 ...（中间轮次省略） ===== 排序后价格排行榜 ===== 1. 矿泉水A: ￥2 2. 矿泉水B: ￥2 3. 可乐: ￥3 4. 口香糖: ￥3 5. 饼干: ￥4 6. 薯片: ￥5 7. 方便面: ￥5 8. 牛奶: ￥6 9. 果汁: ￥8 10. 巧克力: ￥10 ===== 不稳定排序验证 ===== 原始顺序中矿泉水A在矿泉水B前面 排序后顺序: 矿泉水A 矿泉水B
试题9：运动会成绩排名
【题目描述】
学校运动会100米短跑成绩如下（姓名，秒数）：
[{'name': '张小明', 'score': 12.5},
{'name': '王小红', 'score': 11.8},
{'name': '李小刚', 'score': 13.2},
{'name': '盛小丽', 'score': 12.1},
{'name': '朱小强', 'score': 11.9},
{'name': '百小美', 'score': 12.7},
{'name': '盖小华', 'score': 12.3}]
请使用快速排序按成绩从快到慢（秒数从小到大）排序，并输出最终排名结果。
【题目要求】
实现快速排序算法，要求输出排序后的运动员列表（从第1名到第7名）。输出格式参照示例。
【输出示例】
原始成绩列表： 张小明: 12.5秒 王小红: 11.8秒 李小刚: 13.2秒 盛小丽: 12.1秒 朱小强: 11.9秒 百小美: 12.7秒 盖小华: 12.3秒 排名结果（从快到慢）： 第1名: 王小红 11.8秒 第2名: 朱小强 11.9秒 第3名: 盛小丽 12.1秒 第4名: 盖小华 12.3秒 第5名: 张小明 12.5秒 第6名: 百小美 12.7秒 第7名: 李小刚 13.2秒
试题10：图书借阅排行榜
【题目描述】
图书馆有6本图书，每本有名称和借阅次数。数据如下：
[{'name': 'Python编程入门', 'count': 45},
{'name': '科学小实验', 'count': 78},
{'name': '动物世界', 'count': 32},
{'name': '童话故事集', 'count': 91},
{'name': '数学趣味题', 'count': 56},
{'name': '历史大发现', 'count': 23}]
请使用堆排序（利用heapq模块）按借阅次数从高到低排序，输出排行榜。
【题目要求】
实现堆排序函数，输出排序后的图书列表。输出格式参照示例。
【输出示例】
原始图书借阅数据: Python编程入门: 借阅45次 科学小实验: 借阅78次 动物世界: 借阅32次 童话故事集: 借阅91次 数学趣味题: 借阅56次 历史大发现: 借阅23次 热门图书排行榜(从高到低): 第1名: 童话故事集, 借阅91次 第2名: 科学小实验, 借阅78次 第3名: 数学趣味题, 借阅56次 第4名: Python编程入门, 借阅45次 第5名: 动物世界, 借阅32次 第6名: 历史大发现, 借阅23次
试题11：乐高零件按形状分类
【题目描述】
有10个乐高零件，每个零件有编号、形状类型、颜色、尺寸。要求先按形状类型分组，然后在每组内按颜色字母顺序排序，颜色相同的按尺寸从大到小排序（尺寸顺序：大>中>小）。零件数据如下：
[{'id': '3020', 'type': '砖块', 'color': '红', 'size': '小'},
{'id': '3021', 'type': '砖块', 'color': '蓝', 'size': '中'},
{'id': '3022', 'type': '平板', 'color': '黄', 'size': '大'},
{'id': '3023', 'type': '斜面', 'color': '红', 'size': '中'},
{'id': '3024', 'type': '砖块', 'color': '黄', 'size': '大'},
{'id': '3025', 'type': '特殊件', 'color': '蓝', 'size': '小'},
{'id': '3026', 'type': '平板', 'color': '红', 'size': '小'},
{'id': '3027', 'type': '斜面', 'color': '绿', 'size': '大'},
{'id': '3028', 'type': '砖块', 'color': '红', 'size': '大'},
{'id': '3029', 'type': '特殊件', 'color': '黄', 'size': '中'}]
请使用itertools.groupby实现分组，并按要求排序，输出每个形状类下的零件列表，以及每个类的颜色统计。
【题目要求】
实现分组排序功能，输出分组后的零件列表和颜色统计。输出格式参照示例。
【输出示例】
=== 原始零件列表 === 编号:3020 类型:砖块 颜色:红 尺寸:小 编号:3021 类型:砖块 颜色:蓝 尺寸:中 编号:3022 类型:平板 颜色:黄 尺寸:大 编号:3023 类型:斜面 颜色:红 尺寸:中 编号:3024 类型:砖块 颜色:黄 尺寸:大 编号:3025 类型:特殊件 颜色:蓝 尺寸:小 编号:3026 类型:平板 颜色:红 尺寸:小 编号:3027 类型:斜面 颜色:绿 尺寸:大 编号:3028 类型:砖块 颜色:红 尺寸:大 编号:3029 类型:特殊件 颜色:黄 尺寸:中 === 分组排序后的零件 === 【平板】类零件: 编号:3026 颜色:红 尺寸:小 编号:3022 颜色:黄 尺寸:大 【斜面】类零件: 编号:3023 颜色:红 尺寸:中 编号:3027 颜色:绿 尺寸:大 【特殊件】类零件: 编号:3025 颜色:蓝 尺寸:小 编号:3029 颜色:黄 尺寸:中 【砖块】类零件: 编号:3028 颜色:红 尺寸:大 编号:3020 颜色:红 尺寸:小 编号:3021 颜色:蓝 尺寸:中 编号:3024 颜色:黄 尺寸:大 === 每类零件的颜色统计 === 【平板】类颜色分布: 红色: 1个 黄色: 1个 【斜面】类颜色分布: 红色: 1个 绿色: 1个 【特殊件】类颜色分布: 蓝色: 1个 黄色: 1个 【砖块】类颜色分布: 红色: 2个 蓝色: 1个 黄色: 1个
试题12：电子贺卡按发送时间排序
【题目描述】
小明收到多张电子贺卡，每张贺卡有发送时间（字符串格式）和祝福内容。要求按发送时间从早到晚排序。贺卡数据如下：
("2028-12-31 23:59:58", "新年快乐！")
("2028-12-31 23:59:59", "Happy New Year!")
("2028-12-31 23:50:00", "祝你新的一年万事如意！")
("2029-01-01 00:00:01", "新年好！")
("2029-01-01 00:00:00", "元旦快乐！")
请编写程序，使用time模块将时间字符串转换为时间戳，然后按时间戳排序，输出排序后的贺卡列表。
【题目要求】
实现排序函数，输出排序后的结果。输出格式参照示例。
【输出示例】
=== 原始贺卡数据 === 2028-12-31 23:59:58 -> 新年快乐！ 2028-12-31 23:59:59 -> Happy New Year! 2028-12-31 23:50:00 -> 祝你新的一年万事如意！ 2029-01-01 00:00:01 -> 新年好！ 2029-01-01 00:00:00 -> 元旦快乐！ === 按时间排序后 === 2028-12-31 23:50:00 -> 祝你新的一年万事如意！ 2028-12-31 23:59:58 -> 新年快乐！ 2028-12-31 23:59:59 -> Happy New Year! 2029-01-01 00:00:00 -> 元旦快乐！ 2029-01-01 00:00:01 -> 新年好！
试题13：家族辈分图
【题目描述】
构建一个家族辈分有向图，每个成员有姓名和辈分数字（数字越小辈分越高）。关系为有向边从长辈指向晚辈。初始成员：
- 高祖(1), 曾祖(2), 祖父(3), 父亲(4), 本人(5), 儿子(6), 孙子(7)
关系：
高祖→曾祖, 曾祖→祖父, 祖父→父亲, 父亲→本人, 本人→儿子, 儿子→孙子
要求：
- 以树形结构打印家族关系。
- 输出邻接表表示（有向图）。
- 查询本人的所有祖先。
- 查询祖父的所有后代。
- 查找本人和孙子的最近共同祖先。
- 查询第3辈的所有成员。
【题目要求】
实现FamilyTree类，包含添加成员、添加关系、获取祖先、获取后代、最近共同祖先、按辈分查询等方法。按照上述步骤输出结果。输出格式参照示例。
【输出示例】
添加成员: 高祖(1辈)
添加成员: 曾祖(2辈)
添加成员: 祖父(3辈)
添加成员: 父亲(4辈)
添加成员: 本人(5辈)
添加成员: 儿子(6辈)
添加成员: 孙子(7辈)
添加关系: 高祖 → 曾祖
添加关系: 曾祖 → 祖父
添加关系: 祖父 → 父亲
添加关系: 父亲 → 本人
添加关系: 本人 → 儿子
添加关系: 儿子 → 孙子
家族辈分图（有向树结构）:
└── 高祖(1辈)
└── 曾祖(2辈)
└── 祖父(3辈)
└── 父亲(4辈)
└── 本人(5辈)
└── 儿子(6辈)
└── 孙子(7辈)
家族关系邻接表（有向图）:
高祖 → ['曾祖']
曾祖 → ['祖父']
祖父 → ['父亲']
父亲 → ['本人']
本人 → ['儿子']
儿子 → ['孙子']
--- 辈分关系查询 ---
本人的所有祖先: ['父亲(4辈)', '祖父(3辈)', '曾祖(2辈)', '高祖(1辈)']
本人的直接父辈: ['父亲(4辈)']
祖父的所有后代: ['父亲(4辈)', '本人(5辈)', '儿子(6辈)', '孙子(7辈)']
祖父的直接后代: ['父亲(4辈)']
本人和孙子的最近共同祖先: 父亲(4辈)
第3辈的所有成员: ['祖父(3辈)']
试题14：古诗词接龙网络
【题目描述】
给定一个古诗库（诗句列表），诗句之间如果前一句的最后一个字和后一句的第一个字相同，则可以形成接龙。将诗句视为节点，接龙关系视为有向边，构建有向图。使用深度优先搜索（DFS）找出从指定诗句开始的最长接龙序列。古诗库如下（索引从0开始）：
0: 床前明月光
1: 光阴似箭
2: 箭在弦上
3: 上天入地
4: 地久天长
5: 长夜漫漫
6: 漫卷诗书
7: 书山有路
8: 路不拾遗
9: 遗世独立
要求：
- 输出接龙关系图（邻接表，只显示有出边的节点）。
- 从诗句0（床前明月光）开始，找出最长接龙序列，输出诗句文本和接龙关系。
- 从诗句3（上天入地）开始，找出最长接龙序列。
【题目要求】
实现PoetryChain类，构建有向图，使用DFS递归查找最长路径，避免环路。输出结果。输出格式参照示例。
【输出示例】
古诗库：
0: 床前明月光
1: 光阴似箭
2: 箭在弦上
3: 上天入地
4: 地久天长
5: 长夜漫漫
6: 漫卷诗书
7: 书山有路
8: 路不拾遗
9: 遗世独立
接龙关系图（邻接表）：
0('光') -> ['1(光)']
1('箭') -> ['2(箭)']
2('上') -> ['3(上)']
3('地') -> ['4(地)']
4('长') -> ['5(长)']
5('漫') -> ['6(漫)']
6('书') -> ['7(书)']
7('路') -> ['8(路)']
8('遗') -> ['9(遗)']
=== 从『床前明月光』开始的最长接龙 ===
接龙长度: 10
接龙序列:
1. 床前明月光
2. 光阴似箭
3. 箭在弦上
4. 上天入地
5. 地久天长
6. 长夜漫漫
7. 漫卷诗书
8. 书山有路
9. 路不拾遗
10. 遗世独立
接龙关系: 光→光 箭→箭 上→上 地→地 长→长 漫→漫 书→书 路→路 遗→遗
=== 从『上天入地』开始的最长接龙 ===
接龙长度: 7
接龙序列:
1. 上天入地
2. 地久天长
3. 长夜漫漫
4. 漫卷诗书
5. 书山有路
6. 路不拾遗
7. 遗世独立
接龙关系: 地→地 长→长 漫→漫 书→书 路→路 遗→遗
试题15：都江堰智慧灌溉
【题目描述】
给定一个灌溉区域网格，包含水源点（W）、需灌溉耕地（.）和障碍物（#）。水从所有水源点同时向上下左右四个方向流动，每单位时间流动一格，且不能穿过障碍物。请计算：
- 最少需要多少水源点才能覆盖全部耕地？现有水源点为 (1,1)、(3,3)、(5,4)（坐标从0开始），判断是否能覆盖全部区域。
- 从现有水源点出发，水覆盖整个区域所需的最少时间（即最远耕地被覆盖的时间）。
灌溉区域网格如下（6行6列）：
. . . # . . . W . # . . . . . . . # # # . W . . . . . . . . . . # . W .
（其中 W 表示水源，. 表示耕地，# 表示障碍）
【题目要求】
编写程序，使用多源BFS模拟水流扩散。第一问要求判断现有水源能否覆盖全部耕地（若能则输出时间，否则输出-1）。第二问输出覆盖全区域所需时间。输出格式参照示例。
【输出示例】
灌溉区域地图： . . . # . . . W . # . . . . . . . # # # . W . . . . . . . . . . # . W . 最少需要的水源点数量: 1 从现有水源点覆盖全区域所需时间: 5 单位时间 BFS层次遍历模拟水流扩散: 第0层: (0,0) 第1层: (1,0) (0,1) 第2层: (2,0) (0,2) 第3层: (2,1) (1,2) 第4层: (2,2)
试题16：古驿道物资运输
【题目描述】
给定古代驿道网络（加权无向图），要求从长安运送物资到广州，必须经过襄阳和荆州这两个重要驿站，同时需要避开洛阳到开封的路段（因山路险峻）。驿道网络用邻接表表示（节点为驿站名，边为距离）。网络数据如下：
长安: {'洛阳': 300, '潼关': 120}
洛阳: {'长安': 300, '开封': 200, '南阳': 180}
潼关: {'长安': 120, '南阳': 220, '襄阳': 280}
南阳: {'洛阳': 180, '潼关': 220, '襄阳': 150, '荆州': 240}
开封: {'洛阳': 200, '徐州': 280}
襄阳: {'潼关': 280, '南阳': 150, '荆州': 100, '武昌': 200}
荆州: {'南阳': 240, '襄阳': 100, '武昌': 180, '长沙': 300}
徐州: {'开封': 280, '南京': 250}
武昌: {'襄阳': 200, '荆州': 180, '长沙': 220, '南京': 400}
南京: {'徐州': 250, '武昌': 400, '杭州': 180}
长沙: {'荆州': 300, '武昌': 220, '广州': 600}
杭州: {'南京': 180, '福州': 300}
福州: {'杭州': 300, '广州': 500}
广州: {'长沙': 600, '福州': 500}
历史运输数据记录了某些路径的成功次数（可作为权重辅助优化）。现要求：
- 计算不考虑必经点时的基础最短路径及距离。
- 找出所有满足必经点约束且避开禁用路段的路径，并按距离排序，输出前几条（如全部或前5条）。
- 结合历史数据（路径成功次数），综合距离和历史成功率选择最优路径（可自定义评分公式，例如 score = 距离*0.7 + 历史成功率*0.3）。
历史运输数据如下（路径用元组表示，值为成功次数）：
('长安','潼关','南阳','襄阳','荆州','武昌','广州'): 15
('长安','洛阳','南阳','荆州','长沙','广州'): 12
('长安','洛阳','开封','徐州','南京','杭州','福州','广州'): 8
('长安','潼关','襄阳','荆州','长沙','广州'): 20
【题目要求】
实现ConstrainedShortestPath类，包含基础Dijkstra、带约束的路径搜索、历史数据优化等方法。按照上述要求输出结果。输出格式参照示例（可适当简化，但需体现关键信息）。
【输出示例】
基于历史数据的古驿道物资运输路径优化
==================================================
=== 古驿道物资运输路径优化 ===
起点: 长安, 终点: 广州
必经驿站: ['襄阳', '荆州']
避开路段: [('洛阳', '开封')]
1. 基础最短路径: 长安 → 潼关 → 襄阳 → 荆州 → 长沙 → 广州
距离: 1400里
2. 所有满足约束的路径(共29条):
路径1: 长安 → 潼关 → 襄阳 → 荆州 → 长沙 → 广州
距离: 1400里, 历史成功率: 20次
路径2: 长安 → 潼关 → 南阳 → 襄阳 → 荆州 → 长沙 → 广州
距离: 1490里, 历史成功率: 0次
路径3: 长安 → 潼关 → 襄阳 → 荆州 → 武昌 → 长沙 → 广州
距离: 1500里, 历史成功率: 0次
路径4: 长安 → 潼关 → 南阳 → 襄阳 → 荆州 → 武昌 → 长沙 → 广州
距离: 1590里, 历史成功率: 0次
路径5: 长安 → 洛阳 → 南阳 → 襄阳 → 荆州 → 长沙 → 广州
距离: 1630里, 历史成功率: 0次
路径6: 长安 → 潼关 → 襄阳 → 武昌 → 荆州 → 长沙 → 广州
距离: 1680里, 历史成功率: 0次
路径7: 长安 → 潼关 → 襄阳 → 南阳 → 荆州 → 长沙 → 广州
距离: 1690里, 历史成功率: 0次
路径8: 长安 → 潼关 → 南阳 → 荆州 → 襄阳 → 武昌 → 长沙 → 广州
距离: 1700里, 历史成功率: 0次
路径9: 长安 → 洛阳 → 南阳 → 襄阳 → 荆州 → 武昌 → 长沙 → 广州
距离: 1730里, 历史成功率: 0次
路径10: 长安 → 潼关 → 南阳 → 襄阳 → 武昌 → 荆州 → 长沙 → 广州
距离: 1770里, 历史成功率: 0次
路径11: 长安 → 潼关 → 襄阳 → 南阳 → 荆州 → 武昌 → 长沙 → 广州
距离: 1790里, 历史成功率: 0次
路径12: 长安 → 洛阳 → 南阳 → 荆州 → 襄阳 → 武昌 → 长沙 → 广州
距离: 1840里, 历史成功率: 0次
路径13: 长安 → 洛阳 → 南阳 → 襄阳 → 武昌 → 荆州 → 长沙 → 广州
距离: 1910里, 历史成功率: 0次
路径14: 长安 → 洛阳 → 南阳 → 潼关 → 襄阳 → 荆州 → 长沙 → 广州
距离: 1980里, 历史成功率: 0次
路径15: 长安 → 潼关 → 襄阳 → 荆州 → 武昌 → 南京 → 杭州 → 福州 → 广州
距离: 2060里, 历史成功率: 0次
路径16: 长安 → 洛阳 → 南阳 → 潼关 → 襄阳 → 荆州 → 武昌 → 长沙 → 广州
距离: 2080里, 历史成功率: 0次
路径17: 长安 → 潼关 → 南阳 → 襄阳 → 荆州 → 武昌 → 南京 → 杭州 → 福州 → 广州
距离: 2150里, 历史成功率: 0次
路径18: 长安 → 洛阳 → 南阳 → 潼关 → 襄阳 → 武昌 → 荆州 → 长沙 → 广州
距离: 2260里, 历史成功率: 0次
路径19: 长安 → 潼关 → 南阳 → 荆州 → 襄阳 → 武昌 → 南京 → 杭州 → 福州 → 广州
距离: 2260里, 历史成功率: 0次
路径20: 长安 → 洛阳 → 南阳 → 襄阳 → 荆州 → 武昌 → 南京 → 杭州 → 福州 → 广州
距离: 2290里, 历史成功率: 0次
路径21: 长安 → 潼关 → 襄阳 → 南阳 → 荆州 → 武昌 → 南京 → 杭州 → 福州 → 广州
距离: 2350里, 历史成功率: 0次
路径22: 长安 → 洛阳 → 南阳 → 荆州 → 襄阳 → 武昌 → 南京 → 杭州 → 福州 → 广州
距离: 2400里, 历史成功率: 0次
路径23: 长安 → 潼关 → 襄阳 → 荆州 → 长沙 → 武昌 → 南京 → 杭州 → 福州 → 广州
距离: 2400里, 历史成功率: 0次
路径24: 长安 → 潼关 → 南阳 → 襄阳 → 荆州 → 长沙 → 武昌 → 南京 → 杭州 → 福州 → 广州
距离: 2490里, 历史成功率: 0次
路径25: 长安 → 洛阳 → 南阳 → 襄阳 → 荆州 → 长沙 → 武昌 → 南京 → 杭州 → 福州 → 广州
距离: 2630里, 历史成功率: 0次
路径26: 长安 → 洛阳 → 南阳 → 潼关 → 襄阳 → 荆州 → 武昌 → 南京 → 杭州 → 福州 → 广州
距离: 2640里, 历史成功率: 0次
路径27: 长安 → 潼关 → 襄阳 → 南阳 → 荆州 → 长沙 → 武昌 → 南京 → 杭州 → 福州 → 广州
距离: 2690里, 历史成功率: 0次
路径28: 长安 → 洛阳 → 南阳 → 潼关 → 襄阳 → 荆州 → 长沙 → 武昌 → 南京 → 杭州 → 福州 → 广州
距离: 2980里, 历史成功率: 0次
路径29: 长安 → 潼关 → 襄阳 → 武昌 → 南京 → 徐州 → 开封 → 洛阳 → 南阳 → 荆州 → 长沙 → 广州
距离: 3050里, 历史成功率: 0次
3. 综合最优路径: 长安 → 潼关 → 襄阳 → 荆州 → 长沙 → 广州
最终距离: 1400里
驿道网络概况:
长安: 可通往 洛阳, 潼关
洛阳: 可通往 长安, 开封, 南阳
潼关: 可通往 长安, 南阳, 襄阳
南阳: 可通往 洛阳, 潼关, 襄阳, 荆州
开封: 可通往 洛阳, 徐州
襄阳: 可通往 潼关, 南阳, 荆州, 武昌
荆州: 可通往 南阳, 襄阳, 武昌, 长沙
徐州: 可通往 开封, 南京
武昌: 可通往 襄阳, 荆州, 长沙, 南京
南京: 可通往 徐州, 武昌, 杭州
长沙: 可通往 荆州, 武昌, 广州
杭州: 可通往 南京, 福州
福州: 可通往 杭州, 广州
广州: 可通往 长沙, 福州
试题17：传统建筑榫卯结构稳定性
【题目描述】
传统木结构建筑有7个木构件（编号0-6），它们之间可以通过榫卯连接。每个可能的连接有一个稳定性权重（权重越小越稳定）。所有可能的连接及权重如下：
(0,1,2), (0,3,1), (0,4,4), (1,2,3), (1,4,2), (1,5,5), (2,5,2), (2,6,3), (3,4,1), (3,6,4), (4,5,3), (5,6,2)
要求设计一个最小支撑网络，用最少的榫卯连接所有构件，且总稳定性最佳（权重和最小）。请使用Kruskal算法求解，并输出所选连接及总稳定性评分。同时，分析哪些连接是冗余的（即不在最小生成树中的连接）。
【题目要求】
实现UnionFind并查集和Kruskal算法。输出最小生成树的边列表、总稳定性评分，以及被消除的冗余连接列表。输出格式参照示例。
【输出示例】
传统建筑榫卯结构最小支撑网络设计 ================================================== 木构件编号：0-柱A, 1-柱B, 2-柱C, 3-梁D, 4-梁E, 5-梁F, 6-枋G 所有可能的榫卯连接及稳定性权重（权重越小越稳定）： 连接1: 构件0-构件1, 稳定性权重: 2 连接2: 构件0-构件3, 稳定性权重: 1 连接3: 构件0-构件4, 稳定性权重: 4 连接4: 构件1-构件2, 稳定性权重: 3 连接5: 构件1-构件4, 稳定性权重: 2 连接6: 构件1-构件5, 稳定性权重: 5 连接7: 构件2-构件5, 稳定性权重: 2 连接8: 构件2-构件6, 稳定性权重: 3 连接9: 构件3-构件4, 稳定性权重: 1 连接10: 构件3-构件6, 稳定性权重: 4 连接11: 构件4-构件5, 稳定性权重: 3 连接12: 构件5-构件6, 稳定性权重: 2 最小支撑网络（消除冗余连接，使用6个榫卯）： 榫卯1: 构件0-构件3, 稳定性权重: 1 榫卯2: 构件3-构件4, 稳定性权重: 1 榫卯3: 构件0-构件1, 稳定性权重: 2 榫卯4: 构件2-构件5, 稳定性权重: 2 榫卯5: 构件5-构件6, 稳定性权重: 2 榫卯6: 构件1-构件2, 稳定性权重: 3 总稳定性评分: 11（越小越稳定） 被消除的冗余连接（6个）： 冗余连接: 构件1-构件4, 稳定性权重: 2 冗余连接: 构件2-构件6, 稳定性权重: 3 冗余连接: 构件4-构件5, 稳定性权重: 3 冗余连接: 构件0-构件4, 稳定性权重: 4 冗余连接: 构件3-构件6, 稳定性权重: 4 冗余连接: 构件1-构件5, 稳定性权重: 5 连通性验证: 所有1个木构件通过6个榫卯连接形成一个整体
试题18：二十四节气农事活动链
【题目描述】
根据二十四节气，农事活动有严格的先后依赖关系。现有10项农事活动（编号1-10）及其描述：
1: 松土保墒（立春时节，土壤解冻，进行松土保墒工作）
2: 送粪积肥（准备春耕所需的肥料）
3: 春耕春播（开始春季耕作和播种）
4: 选种准备（雨水时节选种，为播种做准备）
5: 小麦追肥（惊蛰时节给小麦追肥）
6: 播种作业（进行大规模播种）
7: 农田灌溉（春分后开始灌溉）
8: 作物管理（清明前后进行作物管理）
9: 夏收准备（小满时节准备夏季收获）
10: 秋收工作（秋分时节进行秋季收获）
合理的依赖关系如下（有向边从先修指向后续）：
1→3, 2→3, 3→6, 4→6, 6→5, 6→7, 7→8, 8→9, 9→10
请判断该依赖关系是否存在环，若无环则输出一个合理的农事活动顺序（拓扑排序）。若添加循环依赖（如10→1, 8→2），则检测到环并输出提示。
【题目要求】
实现拓扑排序算法（使用DFS或Kahn算法），分别对合理依赖和添加循环依赖后的情况进行检测，并输出结果。输出格式参照示例。
【输出示例】
=== 二十四节气农事活动链检测 === 测试1 - 合理的农事活动链: 检测到循环依赖: False 合理的农事顺序: [4, 2, 1, 3, 6, 7, 8, 9, 10, 5] 详细顺序: 1. 选种准备 - 雨水时节选种，为播种做准备 2. 送粪积肥 - 准备春耕所需的肥料 3. 松土保墒 - 立春时节，土壤解冻，进行松土保墒工作 4. 春耕春播 - 开始春季耕作和播种 5. 播种作业 - 进行大规模播种 6. 农田灌溉 - 春分后开始灌溉 7. 作物管理 - 清明前后进行作物管理 8. 夏收准备 - 小满时节准备夏季收获 9. 秋收工作 - 秋分时节进行秋季收获 10. 小麦追肥 - 惊蛰时节给小麦追肥 测试2 - 有循环依赖的农事安排: 检测到循环依赖: True 发现不合理的农事安排！存在循环依赖 示例：秋收工作需要在松土保墒之前，但松土保墒又是秋收的前提 这种循环依赖在农业生产中不可能实现 测试3 - '秋收工作'的依赖链分析: 依赖链: [10, 9, 8, 7, 6, 3, 1, 2, 4] 依赖路径详情: ↳ 秋收工作 ↳ 夏收准备 ↳ 作物管理 ↳ 农田灌溉 ↳ 播种作业 ↳ 春耕春播 ↳ 松土保墒 ↳ 送粪积肥 ↳ 选种准备
试题19：传统文化节日礼物打包
【题目描述】
春节将至，小明需要将礼物装入容量为8的礼品盒中。礼物有5种，每种有名称、价值和体积，礼物可以分割（只装一部分）。礼物数据如下：
- 中国结：价值80，体积2
- 春联：价值30，体积1
- 剪纸：价值60，体积3
- 灯笼：价值100，体积20
- 红包：价值40，体积4
要求使用贪心算法（按单位体积价值从高到低）选择礼物，使得总价值最大。输出每一步的选择过程及最终打包方案。
【题目要求】
实现分数背包问题的贪心算法，输出按价值密度排序后的礼物列表、选择过程（包括全部装入或部分装入）、最终打包方案和总价值。输出格式参照示例。
【输出示例】
=== 传统文化节日礼物打包问题 === 礼品盒总容量: 8 所有礼物清单： 1. 中国结(价值:80, 体积:2, 密度:40.00) 2. 春联(价值:30, 体积:1, 密度:30.00) 3. 剪纸(价值:60, 体积:3, 密度:20.00) 4. 灯笼(价值:100, 体积:20, 密度:5.00) 5. 红包(价值:40, 体积:4, 密度:10.00) 按价值密度排序后的礼物： 1. 中国结(价值:80, 体积:2, 密度:40.00) 2. 春联(价值:30, 体积:1, 密度:30.00) 3. 剪纸(价值:60, 体积:3, 密度:20.00) 4. 红包(价值:40, 体积:4, 密度:10.00) 5. 灯笼(价值:100, 体积:20, 密度:5.00) 开始打包： √ 全部装入 中国结，价值: 80，体积: 2 √ 全部装入 春联，价值: 30，体积: 1 √ 全部装入 剪纸，价值: 60，体积: 3 ○ 部分装入 红包，比例: 0.50，价值: 20.0，体积: 2.0 📦 最终打包方案： ✅ 全部装入: 中国结，价值: 80，体积: 2 ✅ 全部装入: 春联，价值: 30，体积: 1 ✅ 全部装入: 剪纸，价值: 60，体积: 3 ⭕ 部分装入: 红包，比例: 0.50，价值: 20.0，体积: 2.0 礼盒总价值: 190.0 礼盒剩余空间: 0.0
试题20：孙悟空翻越火焰山
【题目描述】
孙悟空站在第一座山上，每座山上标有一个数字，表示从这座山最多能向前跳跃的山数（即能跳到当前位置加上该数字范围内的任何位置）。给定三组火焰山分布，判断孙悟空是否能到达最后一座山，如果能，求出最少跳跃次数。
测试案例：
- [2, 3, 1, 1, 4] （能到达）
- [3, 2, 1, 0, 4] （不能到达）
- [1, 3, 2, 1, 1, 4] （能到达，需要计算步数）
要求输出每组案例的详细分析过程，包括每一步的最远可达位置、跳跃次数，以及最终结论。
【题目要求】
实现贪心算法，维护当前最远可达位置和步数边界，判断可达性并计算最少跳跃次数。输出每组案例的分析过程和结果。输出格式参照示例。
【输出示例】
案例1：[2, 3, 1, 1, 4] === 孙悟空翻越火焰山分析报告 === 火焰山分布: [2, 3, 1, 1, 4] 孙悟空开始翻越火焰山... 站在山0，可跳到山2，当前最远能到山2 🐒 第1次跳跃，下一步能到达山2 站在山1，可跳到山4，当前最远能到山4 ✅ 从山1可以直接或间接跳到终点! ================================================== 🎉 成功！孙悟空能用2次跳跃到达终点 案例2：[3, 2, 1, 0, 4] === 孙悟空翻越火焰山分析报告 === 火焰山分布: [3, 2, 1, 0, 4] 孙悟空开始翻越火焰山... 站在山0，可跳到山3，当前最远能到山3 🐒 第1次跳跃，下一步能到达山3 站在山1，可跳到山3，当前最远能到山3 站在山2，可跳到山3，当前最远能到山3 站在山3，可跳到山3，当前最远能到山3 🐒 第2次跳跃，下一步能到达山3 ❌ 困在山3，无法前进! ================================================== 😞 失败！孙悟空无法翻越所有火焰山 案例3：[1, 3, 2, 1, 1, 4] === 孙悟空翻越火焰山分析报告 === 火焰山分布: [1, 3, 2, 1, 1, 4] 孙悟空开始翻越火焰山... 站在山0，可跳到山1，当前最远能到山1 🐒 第1次跳跃，下一步能到达山1 站在山1，可跳到山4，当前最远能到山4 🐒 第2次跳跃，下一步能到达山4 站在山2，可跳到山4，当前最远能到山4 站在山3，可跳到山4，当前最远能到山4 站在山4，可跳到山5，当前最远能到山5 ✅ 从山4可以直接或间接跳到终点! ================================================== 🎉 成功！孙悟空能用3次跳跃到达终点
试题21：爬楼梯问题
【题目描述】
爬楼梯问题：每次可以爬1级或2级台阶，问爬到第n级台阶有多少种不同的方法。要求用动态规划求解，并展示状态转移过程。
测试n=1,2,3,4,5。输出每种情况的方法数，并演示dp数组的计算过程（至少展示n=3时的递推）。
【题目要求】
实现两种动态规划解法：基础数组版本（O(n)空间）和滚动变量优化版本（O(1)空间）。对于每个测试n，输出方法数和优化版本的计算过程。输出格式参照示例。
【输出示例】
============================================================
爬楼梯问题 - 动态规划解法演示
============================================================
★ 测试 1 阶楼梯:
------------------------------
1. 基础动态规划版本:
结果: 1 种方法
2. 空间优化版本:
结果: 1 种方法
总结: 爬 1 阶楼梯共有 1 种不同的方法
============================================================
★ 测试 2 阶楼梯:
------------------------------
1. 基础动态规划版本:
dp[2] = dp[1] + dp[0] = 1 + 1 = 2
结果: 2 种方法
2. 空间优化版本:
初始状态: prev_prev (dp[0]) = 1, prev (dp[1]) = 1
第2阶: 1 + 1 = 2
结果: 2 种方法
总结: 爬 2 阶楼梯共有 2 种不同的方法
============================================================
★ 测试 3 阶楼梯:
------------------------------
1. 基础动态规划版本:
dp[2] = dp[1] + dp[0] = 1 + 1 = 2
dp[3] = dp[2] + dp[1] = 2 + 1 = 3
结果: 3 种方法
2. 空间优化版本:
初始状态: prev_prev (dp[0]) = 1, prev (dp[1]) = 1
第2阶: 1 + 1 = 2
第3阶: 2 + 1 = 3
结果: 3 种方法
总结: 爬 3 阶楼梯共有 3 种不同的方法
============================================================
★ 测试 4 阶楼梯:
------------------------------
1. 基础动态规划版本:
dp[2] = dp[1] + dp[0] = 1 + 1 = 2
dp[3] = dp[2] + dp[1] = 2 + 1 = 3
dp[4] = dp[3] + dp[2] = 3 + 2 = 5
结果: 5 种方法
2. 空间优化版本:
初始状态: prev_prev (dp[0]) = 1, prev (dp[1]) = 1
第2阶: 1 + 1 = 2
第3阶: 2 + 1 = 3
第4阶: 3 + 2 = 5
结果: 5 种方法
总结: 爬 4 阶楼梯共有 5 种不同的方法
============================================================
★ 测试 5 阶楼梯:
------------------------------
1. 基础动态规划版本:
dp[2] = dp[1] + dp[0] = 1 + 1 = 2
dp[3] = dp[2] + dp[1] = 2 + 1 = 3
dp[4] = dp[3] + dp[2] = 3 + 2 = 5
dp[5] = dp[4] + dp[3] = 5 + 3 = 8
结果: 8 种方法
2. 空间优化版本:
初始状态: prev_prev (dp[0]) = 1, prev (dp[1]) = 1
第2阶: 1 + 1 = 2
第3阶: 2 + 1 = 3
第4阶: 3 + 2 = 5
第5阶: 5 + 3 = 8
结果: 8 种方法
总结: 爬 5 阶楼梯共有 8 种不同的方法
============================================================
试题22：榫卯结构的力学传递
【题目描述】
给定一个榫卯结构承重矩阵（类似数字三角形），每个数字代表该位置的承重能力。从顶部开始，每次可以向下走到左下方或右下方，路径上的承重累加。求从顶部到底部的最大承重路径和，并输出该路径。同时对比贪心算法（每次都选较大的子节点）和动态规划的结果。
承重矩阵如下：
第0层: [5]
第1层: [9, 3]
第2层: [8, 7, 4]
第3层: [4, 6, 9, 3]
要求：
- 用贪心算法找出路径，输出承重和及路径。
- 用动态规划找出最优路径，输出承重和及路径。
- 对比两种算法的结果。
【题目要求】
实现贪心算法（从上到下每次选择较大的子节点）和动态规划（从底部向上递推）。输出两种算法的选择过程和最终结果。输出格式参照示例。
【输出示例】
=== 重构后的榫卯结构承重测试 === 榫卯结构承重矩阵： 第0层: [5] 第1层: [9, 3] 第2层: [8, 7, 4] 第3层: [4, 6, 9, 3] 贪心算法选择过程： 第0层: 选择索引0, 承重5 第1层: 可选索引0(9) 或 1(3) -> 选择索引0, 累计承重14 第2层: 可选索引0(8) 或 1(7) -> 选择索引0, 累计承重22 第3层: 可选索引0(4) 或 1(6) -> 选择索引1, 累计承重28 动态规划计算过程： 第0层: dp[0] = [5] 第1层: dp[1] = [14, 8] 第2层: dp[2] = [22, 21, 12] 第3层: dp[3] = [26, 28, 30, 15] === 算法结果对比 === 贪心算法结果: 承重 28, 路径 [0, 0, 0, 1] 动态规划结果: 承重 30, 路径 [0, 0, 1, 2] === 路径对比分析 === 5(GD) 9(GD) 3 8(G) 7(D) 4 4 6(G) 9(D) 3 ❌ 算法结果不一致: 贪心28 vs 动态规划30
试题23：最大子序和
【题目描述】
给定一个整数数组，求其连续子数组的最大和。分别用贪心算法（Kadane算法思想）和动态规划求解，并对比过程。
测试数据：[-2, 1, -3, 4, -1, 2, 1, -5, 4]
要求：
- 用贪心算法（维护当前和，如果当前和为负则重置）输出每一步的过程。
- 用动态规划（dp[i]表示以i结尾的最大子序和）输出每一步的过程。
- 输出两种算法的最终结果，并验证一致性。
【题目要求】
实现两种算法，输出每一步的计算过程（参考示例格式）。最终结果应一致。
【输出示例】
小明9天的零花钱记录: [-2, 1, -3, 4, -1, 2, 1, -5, 4] ================================================== 贪心算法执行过程： 初始状态: 当前和 = -2, 最大和 = -2 第1天: 当前和-2为负数，重新开始计算 更新最大和 = 1 第2天: 继续累加，当前和 = -2 最大和保持不变 第3天: 当前和-2为负数，重新开始计算 更新最大和 = 4 第4天: 继续累加，当前和 = 3 最大和保持不变 第5天: 继续累加，当前和 = 5 更新最大和 = 5 第6天: 继续累加，当前和 = 6 更新最大和 = 6 第7天: 继续累加，当前和 = 1 最大和保持不变 第8天: 继续累加，当前和 = 5 最大和保持不变 贪心算法结果: 6 动态规划执行过程： 初始化: dp[0] = -2 第1天: dp[1] = max(dp[0] + 1, 1) = 1 当前最大和 = 1 第2天: dp[2] = max(dp[1] + -3, -3) = -2 当前最大和 = 1 第3天: dp[3] = max(dp[2] + 4, 4) = 4 当前最大和 = 4 第4天: dp[4] = max(dp[3] + -1, -1) = 3 当前最大和 = 4 第5天: dp[5] = max(dp[4] + 2, 2) = 5 当前最大和 = 5 第6天: dp[6] = max(dp[5] + 1, 1) = 6 当前最大和 = 6 第7天: dp[7] = max(dp[6] + -5, -5) = 1 当前最大和 = 6 第8天: dp[8] = max(dp[7] + 4, 4) = 5 当前最大和 = 6 动态规划结果: 6 ================================================== 算法对比总结: 二种方法结果一致: True 最优连续零花钱和: 6
试题24：传统文化节气活动安排
【题目描述】
学校文化节有多个基于二十四节气的传统文化活动，每个活动有开始时间和结束时间。要求安排尽可能多的活动，使得活动时间不重叠。请使用贪心算法（按结束时间最早优先）求解。
场景1（标准节气活动）：
("立春剪纸", 900, 1030)
("雨水茶艺", 1030, 1130)
("惊蛰种植", 1100, 1200)
("春分踏青", 1300, 1430)
("清明扫墓", 1400, 1530)
("谷雨赏花", 1500, 1630)
("立夏尝新", 1600, 1700)
("小满养蚕", 1700, 1800)
场景2（密集活动挑战）：
("端午赛舟", 800, 1000)
("芒种收割", 900, 1100)
("夏至观日", 1000, 1200)
("小暑纳凉", 1100, 1300)
("大暑游泳", 1200, 1400)
要求对每个场景，输出活动按结束时间排序后的列表、选择过程，以及最终安排的活动列表和数量。
【题目要求】
实现贪心活动选择算法，输出每个场景的排序结果、选择过程及最终方案。输出格式参照示例。
【输出示例】
🎋 传统文化节气活动安排系统
============================================================
场景1: 春季节气活动安排
----------------------------------------
节气活动安排贪心算法执行过程：
活动按结束时间排序结果：
1. 立春剪纸: 900-1030 (结束时间: 1030)
2. 雨水茶艺: 1030-1130 (结束时间: 1130)
3. 惊蛰种植: 1100-1200 (结束时间: 1200)
4. 春分踏青: 1300-1430 (结束时间: 1430)
5. 清明扫墓: 1400-1530 (结束时间: 1530)
6. 谷雨赏花: 1500-1630 (结束时间: 1630)
7. 立夏尝新: 1600-1700 (结束时间: 1700)
8. 小满养蚕: 1700-1800 (结束时间: 1800)
开始选择活动：
✅ 选择活动: 立春剪纸 (900-1030)
更新最后结束时间: 1030
✅ 选择活动: 雨水茶艺 (1030-1130)
更新最后结束时间: 1130
❌ 跳过活动: 惊蛰种植 (与上一个活动冲突)
✅ 选择活动: 春分踏青 (1300-1430)
更新最后结束时间: 1430
❌ 跳过活动: 清明扫墓 (与上一个活动冲突)
✅ 选择活动: 谷雨赏花 (1500-1630)
更新最后结束时间: 1630
❌ 跳过活动: 立夏尝新 (与上一个活动冲突)
✅ 选择活动: 小满养蚕 (1700-1800)
更新最后结束时间: 1800
==================================================
最终活动安排方案
==================================================
成功安排的活动：
1. 立春剪纸: 900-1030
2. 雨水茶艺: 1030-1130
3. 春分踏青: 1300-1430
4. 谷雨赏花: 1500-1630
5. 小满养蚕: 1700-1800
统计结果：
- 总活动数量: 5个
场景2: 密集活动安排挑战
----------------------------------------
节气活动安排贪心算法执行过程：
活动按结束时间排序结果：
1. 端午赛舟: 800-1000 (结束时间: 1000)
2. 芒种收割: 900-1100 (结束时间: 1100)
3. 夏至观日: 1000-1200 (结束时间: 1200)
4. 小暑纳凉: 1100-1300 (结束时间: 1300)
5. 大暑游泳: 1200-1400 (结束时间: 1400)
开始选择活动：
✅ 选择活动: 端午赛舟 (800-1000)
更新最后结束时间: 1000
❌ 跳过活动: 芒种收割 (与上一个活动冲突)
✅ 选择活动: 夏至观日 (1000-1200)
更新最后结束时间: 1200
❌ 跳过活动: 小暑纳凉 (与上一个活动冲突)
✅ 选择活动: 大暑游泳 (1200-1400)
更新最后结束时间: 1400
==================================================
最终活动安排方案
==================================================
成功安排的活动：
1. 端午赛舟: 800-1000
2. 夏至观日: 1000-1200
3. 大暑游泳: 1200-1400
统计结果：
- 总活动数量: 3个
试题25：粒子碰撞路径计数
【题目描述】
在一个5×5的网格中，粒子从左上角(0,0)出发，要到达右下角(4,4)。网格中有障碍物（值为1的位置不能经过），粒子只能向右或向下移动。请计算所有可能的路径数量。网格如下：
[0, 0, 0, 0, 0] [0, 1, 0, 1, 0] [0, 0, 0, 0, 0] [0, 1, 0, 1, 0] [0, 0, 0, 0, 0]
要求分别用朴素递归和记忆化递归两种方法求解，并对比性能（运行时间）。输出两种方法的路径数及耗时。
【题目要求】
实现两个函数：count_paths_naive（朴素递归）和count_paths_memo（使用字典缓存）。测试网格，输出两种方法的结果和时间，并计算性能提升倍数。输出格式参照示例。
【输出示例】
=== 粒子碰撞路径计数优化实验 === 网格地图: S · · # · · · # · # · · · · · · · # # # · W · · · · · · · · · · # · · · 网格大小: 6x6 障碍物数量: 7 --- 性能对比测试 --- 朴素递归结果: 6条路径 手动记忆化结果: 6条路径 装饰器记忆化结果: 6条路径 朴素递归耗时: 0.000013秒 手动记忆化耗时: 0.000015秒 装饰器记忆化耗时: 0.000025秒 手动记忆化性能提升: 0.9倍 装饰器记忆化性能提升: 0.5倍 结果一致性验证: True ✓ --- 缓存键设计分析 --- 缓存键格式: (x, y) - 使用位置坐标作为唯一标识 这种设计能够准确识别重复的计算状态 --- 大规模网格测试 --- 10x10网格 - 朴素递归: 0.00445秒 10x10网格 - 记忆化优化: 0.00007秒 大规模测试性能提升: 65.2倍
试题26：星座图像压缩存储
【题目描述】
星座图像通常是一个大型网格，其中大部分像素为0（背景），只有少数位置有星星（非零亮度）。请将以下5×5的星图（0表示背景，非0表示星星亮度）转换为稀疏表示（使用字典存储非零元素），并对比稠密存储和稀疏存储的空间大小。
星图数据：
[ [0, 0, 0, 0, 0], [0, 3, 0, 0, 5], [0, 0, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 0, 0, 7] ]
要求：
- 输出稀疏字典表示（键为(row,col)，值为亮度）。
- 计算稠密矩阵的元素总数和非零元素个数，计算空间节省百分比。
【题目要求】
编写函数dense_to_sparse_dict将稠密矩阵转换为稀疏字典。输出转换后的字典及空间分析。输出格式参照示例。
【输出示例】
原始星图（稠密矩阵）：
[0, 0, 0, 0, 0]
[0, 3, 0, 0, 5]
[0, 0, 0, 0, 0]
[0, 0, 2, 0, 0]
[0, 0, 0, 0, 7]
稀疏字典表示：
{(1, 1): 3, (1, 4): 5, (3, 2): 2, (4, 4): 7}
性能对比演示:
星图大小: 5 x 5 = 25 个像素
非零元素(星星): 4 个
稀疏度: 84.00%
稠密存储空间: O(n²) = O(25)
稀疏存储空间: O(k) = O(4)
空间节省: 84.00%
试题27：传统节日知识问答
【题目描述】
设计一个中国传统节日知识问答系统，能快速判断用户输入的节日是否为中国传统节日，并给出节日介绍。已知传统节日列表如下：
["春节", "元宵节", "清明节", "端午节", "七夕节", "中元节", "中秋节", "重阳节", "冬至", "腊八节", "小年", "除夕", "龙抬头", "寒食节", "下元节"]
部分节日有详细介绍（存储在字典中）。要求分别用列表遍历和集合成员判断两种方式实现查询，并对比两种方法的查找速度。
用户交互：循环接收用户输入，输入“退出”结束程序。每次查询输出结果，并显示两种方法的查找耗时及速度比。
【题目要求】
实现FestivalQuiz类，包含列表和集合两种存储方式，以及check_festival_list和check_festival_set方法。主程序循环接收输入，对每个查询输出两种方法的查找结果和耗时。输出格式参照示例。
【输出示例】
系统初始化完成！ 系统中包含 15 个传统节日 集合大小：15 === 中国传统节日知识问答系统 === 已知传统节日： 春节, 元宵节, 清明节, 端午节, 七夕节, 中元节, 中秋节, 重阳节, 冬至, 腊八节, 小年, 除夕, 龙抬头, 寒食节, 下元节 输入'退出'结束程序 请输入一个节日名称：春节 ✅ 正确！春节是中国传统节日 📖 知识介绍：农历正月初一，中国最重要的传统节日，象征新年开始 ⏱️ 列表查找耗时：0.000010秒 ⚡ 集合查找耗时：0.000005秒 🚀 集合查找速度是列表的 2.3 倍！ -------------------------------------------------- 请输入一个节日名称：圣诞节 ❌ 错误！圣诞节不是中国传统节日 ⏱️ 列表查找耗时：0.000008秒 ⚡ 集合查找耗时：0.000005秒 🚀 集合查找速度是列表的 1.5 倍！ -------------------------------------------------- 请输入一个节日名称：退出
试题28：零食采购大作战
【题目描述】
你有一个容量为10的背包，有4种零食，每种零食的体积和价值如下：
- 零食1: 体积2, 价值3
- 零食2: 体积3, 价值4
- 零食3: 体积4, 价值5
- 零食4: 体积5, 价值6
要求：
- 若每种零食只能选一次（01背包），求最大总价值。
- 若每种零食可以选无限次（完全背包），求最大总价值。
- 若前两种零食只能选一次（01背包），后两种可以选多次（完全背包），求最大总价值（混合背包）。
【题目要求】
实现01背包、完全背包、混合背包的动态规划解法（使用一维数组状态压缩）。输出每种情况的最大总价值。输出格式参照示例。
【输出示例】
=== 零食采购大作战 === 背包总容量: 10 可用零食: 零食1: 体积=2, 美味值=3 零食2: 体积=3, 美味值=4 零食3: 体积=4, 美味值=5 零食4: 体积=5, 美味值=6 01背包最大美味值: 13 完全背包最大美味值: 15 混合背包最大美味值: 13
❀ 季 军 题 库 ❀ 返回最前
试题1：糖果罐子管理系统
【题目描述】
实现一个糖果罐管理系统，能够对糖果列表进行基本的增删改查操作。初始糖果列表为 ['棒棒糖', '水果糖', '巧克力', '奶糖']。请编写程序，依次执行以下操作：
- 输出初始糖果罐。
- 输出第一颗糖（索引0）和最后一颗糖（索引-1）。
- 添加
'薄荷糖'到罐子底部。 - 吃掉第三颗糖（索引2），并输出吃掉的糖果。
- 把水果糖（索引1）换成
'棉花糖'。 - 遍历输出所有糖果及其位置。
【题目要求】
按照上述步骤顺序执行，并输出每一步的结果。输出格式请严格参照示例。
【输出示例】
初始糖果罐: ['棒棒糖', '水果糖', '巧克力', '奶糖']
第一颗糖(索引0): 棒棒糖
最后一颗糖(索引-1): 奶糖
添加薄荷糖后: ['棒棒糖', '水果糖', '巧克力', '奶糖', '薄荷糖']
吃掉了: 巧克力, 剩余糖果: ['棒棒糖', '水果糖', '奶糖', '薄荷糖']
更新后的糖果罐: ['棒棒糖', '棉花糖', '奶糖', '薄荷糖']
现在的糖果罐里有:
位置0: 棒棒糖
位置1: 棉花糖
位置2: 奶糖
位置3: 薄荷糖
试题2：学生午餐排队模拟
【题目描述】
用队列模拟学生午餐排队过程。初始队列为空，依次进行以下操作：
- 小明、小红、小刚依次加入队伍。
- 显示当前队伍顺序。
- 队首学生打完饭离开。
- 显示当前队伍顺序。
- 小丽、小强加入队伍。
- 显示当前队伍顺序。
- 连续两次队首学生离开。
- 显示当前队伍顺序。
- 继续队首学生离开直到队伍为空，每次离开时输出信息。
【题目要求】
实现一个队列，按照上述操作顺序输出每一步的结果。输出格式参照示例。
【输出示例】
小明 加入了午餐队伍
小红 加入了午餐队伍
小刚 加入了午餐队伍
当前队伍顺序: 小明 → 小红 → 小刚
小明 已经打完饭离开队伍
当前队伍顺序: 小红 → 小刚
小丽 加入了午餐队伍
小强 加入了午餐队伍
当前队伍顺序: 小红 → 小刚 → 小丽 → 小强
小红 已经打完饭离开队伍
小刚 已经打完饭离开队伍
当前队伍顺序: 小丽 → 小强
小丽 已经打完饭离开队伍
小强 已经打完饭离开队伍
队伍已经没有人了
当前队伍为空
试题3：课间操站位网格
【题目描述】
学校课间操需要按班级和学号站成方阵，每个位置由班级和学号标识。初始有3个班级，每班5人，站位按“班级-学号”命名。请实现以下功能：
- 显示初始站位网格。
- 定位查询2班3号学生。
- 交换1班2号和3班4号的位置。
- 新增一个班级（4班）。
- 遍历所有位置输出。
【题目要求】
按照上述步骤执行，并输出每一步的结果。输出格式参照示例。
【输出示例】
当前课间操站位网格: 1班-1号 | 1班-2号 | 1班-3号 | 1班-4号 | 1班-5号 2班-1号 | 2班-2号 | 2班-3号 | 2班-4号 | 2班-5号 3班-1号 | 3班-2号 | 3班-3号 | 3班-4号 | 3班-5号 共 3 个班级，每班 5 人 定位测试: 2班3号位置: 2班-3号 5班1号位置: 位置不存在 交换位置测试: 已交换: (1, 2) 和 (3, 4) 的位置 当前课间操站位网格: 1班-1号 | 3班-4号 | 1班-3号 | 1班-4号 | 1班-5号 2班-1号 | 2班-2号 | 2班-3号 | 2班-4号 | 2班-5号 3班-1号 | 3班-2号 | 3班-3号 | 1班-2号 | 3班-5号 共 3 个班级，每班 5 人 新增班级测试: 新增 4班 完成 当前课间操站位网格: 1班-1号 | 3班-4号 | 1班-3号 | 1班-4号 | 1班-5号 2班-1号 | 2班-2号 | 2班-3号 | 2班-4号 | 2班-5号 3班-1号 | 3班-2号 | 3班-3号 | 1班-2号 | 3班-5号 4班-1号 | 4班-2号 | 4班-3号 | 4班-4号 | 4班-5号 共 4 个班级，每班 5 人 网格遍历演示: 1班-1号 | 3班-4号 | 1班-3号 | 1班-4号 | 1班-5号 | 2班-1号 | 2班-2号 | 2班-3号 | 2班-4号 | 2班-5号 | 3班-1号 | 3班-2号 | 3班-3号 | 1班-2号 | 3班-5号 | 4班-1号 | 4班-2号 | 4班-3号 | 4班-4号 | 4班-5号 |
试题4：垃圾分类知识库
【题目描述】
设计一个垃圾分类查询系统，使用哈希表存储垃圾名称与类别。初始垃圾数据如下：
('香蕉皮', '厨余垃圾')
('电池', '有害垃圾')
('报纸', '可回收物')
('塑料袋', '其他垃圾')
('苹果核', '厨余垃圾')
('玻璃瓶', '可回收物')
('药品', '有害垃圾')
('纸巾', '其他垃圾')
('鱼骨头', '厨余垃圾')
要求：
- 构建哈希表，桶大小为5，使用链地址法处理冲突。
- 输出哈希表结构（每个桶的内容）。
- 查询以下垃圾的类别：
'香蕉皮','电池','塑料袋','未知垃圾'。
【题目要求】
按照上述要求输出哈希表结构和查询结果。输出格式参照示例。
【输出示例】
垃圾分类哈希表结构: 桶[0]: [['香蕉皮', '厨余垃圾'], ['苹果核', '厨余垃圾'], ['鱼骨头', '厨余垃圾']] 桶[1]: [['报纸', '可回收物'], ['玻璃瓶', '可回收物']] 桶[2]: [['电池', '有害垃圾'], ['药品', '有害垃圾']] 桶[3]: [['塑料袋', '其他垃圾'], ['纸巾', '其他垃圾']] 桶[4]: [] 垃圾分类查询测试: '香蕉皮' 属于: 厨余垃圾 '电池' 属于: 有害垃圾 '塑料袋' 属于: 其他垃圾 '未知垃圾' 属于: 未知垃圾 哈希桶类别分布: 桶[0]: 厨余垃圾 桶[1]: 可回收物 桶[2]: 有害垃圾 桶[3]: 其他垃圾 桶[4]: 未知垃圾
试题5：音乐播放列表
【题目描述】
使用链表实现一个音乐播放列表。每首歌曲包含标题和歌手。初始播放列表为空。请依次执行以下操作：
- 添加歌曲：
'稻香'– 周杰伦，'海阔天空'– Beyond，'晴天'– 周杰伦。 - 显示当前播放列表。
- 删除歌曲
'稻香'。 - 显示当前播放列表。
- 添加歌曲
'夜曲'– 周杰伦。 - 显示当前播放列表。
【题目要求】
实现链表及其操作，按照上述步骤输出结果。输出格式参照示例。
【输出示例】
当前播放列表: 1. 稻香 - 周杰伦 2. 海阔天空 - Beyond 3. 晴天 - 周杰伦 已删除歌曲: 稻香 当前播放列表: 1. 海阔天空 - Beyond 2. 晴天 - 周杰伦 当前播放列表: 1. 海阔天空 - Beyond 2. 晴天 - 周杰伦 3. 夜曲 - 周杰伦
试题6：智能家居设备网络
【题目描述】
使用图结构模拟智能家居设备网络。设备有唯一ID和名称。初始设备：d1客厅主灯、d2卧室空调、d3智能音箱、d4门锁、d5路由器。建立以下连接（双向）：
d1-d5, d2-d5, d3-d5, d4-d3, d1-d3
要求：
- 从
d5开始进行广度优先遍历，输出遍历顺序。 - 找出从
d1到d4的最短路径。 - 检查网络是否完全连通。
- 断开
d3与d5的连接后，再次检查连通性。
【题目要求】
按照上述步骤输出结果。输出格式参照示例。
【输出示例】
BFS遍历顺序: ['d5', 'd1', 'd2', 'd3', 'd4'] 客厅主灯到门锁的最短路径: ['d1', 'd3', 'd4'] 网络是否完全连通: True 断开连接后网络是否连通: True
试题7：图书馆找书系统
【题目描述】
实现一个线性查找程序，在书籍列表中查找目标书编号。书籍列表为 ['LIB003', 'LIB015', 'LIB007', 'LIB001', 'LIB012', 'LIB009']。用户输入书编号，程序输出查找过程及结果。
要求：
- 循环接收用户输入，直到输入
'q'退出。 - 每次查找，输出每一步检查的书名。
- 如果找到，输出位置；否则输出未找到。
【题目要求】
编写程序，模拟交互过程。给定输入序列如：LIB001, LIB020, q。输出参照示例。
【输出示例】
=== 图书馆找书系统 === 当前书架上的书编号： ['LIB003', 'LIB015', 'LIB007', 'LIB001', 'LIB012', 'LIB009'] 请输入要查找的书编号（输入q退出）：LIB001 正在检查第0个位置的书：LIB003 正在检查第1个位置的书：LIB015 正在检查第2个位置的书：LIB007 正在检查第3个位置的书：LIB001 找到啦！LIB001 在第 3 个位置 请输入要查找的书编号（输入q退出）：LIB020 正在检查第0个位置的书：LIB003 正在检查第1个位置的书：LIB015 正在检查第2个位置的书：LIB007 正在检查第3个位置的书：LIB001 正在检查第4个位置的书：LIB012 正在检查第5个位置的书：LIB009 没找到 LIB020，可能已经被借走了 请输入要查找的书编号（输入q退出）：q 谢谢使用，再见！
试题8：全班身高排队系统
【题目描述】
使用冒泡排序对班级身高数据进行排序。初始身高列表为 [135, 142, 128, 145, 130, 138]。要求输出每一轮排序的过程，以及最终排序结果。
【题目要求】
实现冒泡排序算法，并输出每一轮比较和交换的过程。输出格式参照示例（可适当简化中间轮次，但需体现完整过程）。
【输出示例】
=== 全班身高排队系统 ===
原始队伍顺序： [135, 142, 128, 145, 130, 138]
开始冒泡排序...
=== 第 1 轮排序 ===
比较 135 和 142 → 保持不动
比较 142 和 128 → 需要交换 → [135, 128, 142, 145, 130, 138]
比较 142 和 145 → 保持不动
比较 145 和 130 → 需要交换 → [135, 128, 142, 130, 145, 138]
比较 145 和 138 → 需要交换 → [135, 128, 142, 130, 138, 145]
第 1 轮结果：[135, 128, 142, 130, 138, 145]
当前队伍顺序：135 → 128 → 142 → 130 → 138 → 145
=== 第 2 轮排序 ===
比较 135 和 128 → 需要交换 → [128, 135, 142, 130, 138, 145]
比较 135 和 142 → 保持不动
比较 142 和 130 → 需要交换 → [128, 135, 130, 142, 138, 145]
比较 142 和 138 → 需要交换 → [128, 135, 130, 138, 142, 145]
第 2 轮结果：[128, 135, 130, 138, 142, 145]
当前队伍顺序：128 → 135 → 130 → 138 → 142 → 145
=== 第 3 轮排序 ===
比较 128 和 135 → 保持不动
比较 135 和 130 → 需要交换 → [128, 130, 135, 138, 142, 145]
比较 135 和 138 → 保持不动
第 3 轮结果：[128, 130, 135, 138, 142, 145]
当前队伍顺序：128 → 130 → 135 → 138 → 142 → 145
=== 第 4 轮排序 ===
比较 128 和 130 → 保持不动
比较 130 和 135 → 保持不动
第 4 轮结果：[128, 130, 135, 138, 142, 145]
当前队伍顺序：128 → 130 → 135 → 138 → 142 → 145
=== 第 5 轮排序 ===
比较 128 和 130 → 保持不动
第 5 轮结果：[128, 130, 135, 138, 142, 145]
当前队伍顺序：128 → 130 → 135 → 138 → 142 → 145
最终排序结果： [128, 130, 135, 138, 142, 145]
试题9：音乐播放列表的热门排序
【题目描述】
使用插入排序对歌曲按播放次数从小到大排序。给定歌曲列表：
[{'name': '小星星', 'plays': 150},
{'name': '两只老虎', 'plays': 200},
{'name': '生日快乐', 'plays': 80},
{'name': '童年', 'plays': 300},
{'name': '茉莉花', 'plays': 120}]
要求输出每一轮排序后的歌曲名称顺序，以及最终排序结果。
【题目要求】
实现插入排序算法，输出每一步的排序结果。输出格式参照示例。
【输出示例】
原始播放列表： ['小星星', '两只老虎', '生日快乐', '童年', '茉莉花'] 第1轮排序后： ['小星星', '两只老虎', '生日快乐', '童年', '茉莉花'] 第2轮排序后： ['生日快乐', '小星星', '两只老虎', '童年', '茉莉花'] 第3轮排序后： ['生日快乐', '小星星', '两只老虎', '童年', '茉莉花'] 第4轮排序后： ['生日快乐', '茉莉花', '小星星', '两只老虎', '童年'] 按热度排序后的播放列表： 生日快乐: 80次播放 茉莉花: 120次播放 小星星: 150次播放 两只老虎: 200次播放 童年: 300次播放
试题10：生日礼物分类
【题目描述】
使用归并排序对礼物大小进行排序。礼物列表为 [15, 3, 8, 20, 5, 12, 10, 7]。要求输出排序后的结果。
【题目要求】
实现归并排序算法，输出最终排序结果。
【输出示例】
原始礼物顺序: [15, 3, 8, 20, 5, 12, 10, 7] 排序后礼物顺序: [3, 5, 7, 8, 10, 12, 15, 20]
试题11：游戏装备属性筛选
【题目描述】
给定装备列表，每个装备有名称、攻击力、防御力、稀有度、重量。要求按以下规则排序：
- 优先稀有度降序，
- 稀有度相同则攻击力降序，
- 攻击力相同则重量升序。
装备数据如下：
[{"name": "王者之剑", "attack": 120, "defense": 30, "rarity": 5, "weight": 8},
{"name": "精灵之弓", "attack": 95, "defense": 15, "rarity": 4, "weight": 3},
{"name": "巨龙铠甲", "attack": 30, "defense": 150, "rarity": 5, "weight": 12},
{"name": "新手木剑", "attack": 10, "defense": 5, "rarity": 1, "weight": 2},
{"name": "魔法法杖", "attack": 80, "defense": 20, "rarity": 3, "weight": 4},
{"name": "暗影匕首", "attack": 95, "defense": 10, "rarity": 4, "weight": 1},
{"name": "圣光盾牌", "attack": 15, "defense": 120, "rarity": 4, "weight": 7}]
要求输出排序后的装备名称及关键属性。
【题目要求】
使用多条件排序，输出排序结果。输出格式参照示例。
【输出示例】
排序条件：稀有度↓ 攻击力↓ 重量↑ 王者之剑 稀有度:5星 攻击:120 重量:8 巨龙铠甲 稀有度:5星 攻击: 30 重量:12 暗影匕首 稀有度:4星 攻击: 95 重量:1 精灵之弓 稀有度:4星 攻击: 95 重量:3 圣光盾牌 稀有度:4星 攻击: 15 重量:7 魔法法杖 稀有度:3星 攻击: 80 重量:4 新手木剑 稀有度:1星 攻击: 10 重量:2
试题12：智能垃圾桶满载预警
【题目描述】
使用滑动窗口检测垃圾高度数据中的连续上升并达到局部最高点的预警点。给定数据 [15, 18, 22, 20, 25, 27, 30]，窗口大小为3。要求找出所有预警点（即窗口内连续上升且窗口后一个数据下降或到达末尾的窗口最高点位置）。输出预警点的索引和对应高度。
【题目要求】
实现滑动窗口检测算法，输出结果。
【输出示例】
垃圾高度记录: [15, 18, 22, 20, 25, 27, 30] 预警时间点(索引): [2, 6] 对应的高度值: [22, 30]
试题13：朋友圈关系图
【题目描述】
构建一个简单的社交网络图，节点为人名，边为认识关系。初始节点：小明、小红、小刚、小华。关系：小明认识小红和小刚，小红认识小明和小刚，小刚认识所有人，小华只认识小刚。
要求：
- 输出邻接表表示。
- 输出邻接矩阵表示。
- 查询小明的朋友。
- 判断小红和小刚是否认识。
- 找出小明和小红的共同朋友。
【题目要求】
实现图的基本操作，输出结果。输出格式参照示例。
【输出示例】
添加节点: 小明
添加节点: 小红
添加节点: 小刚
添加节点: 小华
添加边: 小明 - 小红
添加边: 小明 - 小刚
添加边: 小红 - 小刚
添加边: 小华 - 小刚
朋友圈关系图（邻接表表示）:
小明 的朋友: ['小红', '小刚']
小红 的朋友: ['小明', '小刚']
小刚 的朋友: ['小明', '小红', '小华']
小华 的朋友: ['小刚']
朋友圈关系图（邻接矩阵表示）:
小明 小红 小刚 小华
小明 [0, 1, 1, 0]
小红 [1, 0, 1, 0]
小刚 [1, 1, 0, 1]
小华 [0, 0, 1, 0]
--- 查询操作演示 ---
小明的朋友: ['小红', '小刚']
小红和小刚是朋友吗? True
小红和小华是朋友吗? False
小明和小红的共同朋友: {'小刚'}
试题14：迷宫逃生
【题目描述】
给定一个5×5的迷宫，0表示通路，1表示墙壁。起点为(0,0)，终点为(4,4)。使用深度优先搜索（DFS）找出一条逃生路径，并输出路径坐标和可视化路径。
迷宫数据：
[[0,1,0,0,0],
[0,1,0,1,0],
[0,0,0,1,0],
[0,1,1,1,0],
[0,0,0,0,0]]
要求输出找到的路径坐标，以及用@标记路径的迷宫可视化。
【题目要求】
实现DFS算法，输出结果。输出格式参照示例。
【输出示例】
迷宫布局： [0, 1, 0, 0, 0] [0, 1, 0, 1, 0] [0, 0, 0, 1, 0] [0, 1, 1, 1, 0] [0, 0, 0, 0, 0] 起点: (0, 0), 终点: (4, 4) 逃生路径找到啦！ 路径坐标: [(0, 0), (1, 0), (2, 0), (2, 1), (2, 2), (1, 2), (0, 2), (0, 3), (0, 4), (1, 4), (2, 4), (3, 4), (4, 4)] 可视化路径 (@表示逃生路线): @ . . . . @ . @ . . @ @ @ . . . . . . . . . . . @ （注：实际输出中墙壁用|表示，通路用.，路径用@，此处简化示意）
试题15：社交网络好友推荐
【题目描述】
给定一个社交网络图（邻接表表示），找出从用户'小明'到用户'小红'的最短好友关系链（即最短路径）。社交网络图如下：
{'小明': ['小王', '小张', '小李'],
'小王': ['小明', '小赵', '小刘'],
'小张': ['小明', '小刘', '小陈'],
'小李': ['小明', '小陈', '小孙'],
'小赵': ['小王', '小孙'],
'小刘': ['小王', '小张', '小孙'],
'小陈': ['小张', '小李', '小红'],
'小孙': ['小李', '小赵', '小刘', '小红'],
'小红': ['小陈', '小孙', '小吴'],
'小吴': ['小红']}
要求输出最短路径和介绍次数。
【题目要求】
使用BFS算法，输出结果。
【输出示例】
查找从 [小明] 到 [小红] 的最短关系链: ✓ 找到最短关系链! 路径: 小明 → 小张 → 小陈 → 小红 介绍次数: 2
试题16：校园导航
【题目描述】
给定校园地图（加权无向图），计算从宿舍到校门的最短路径及距离。地图数据（邻接表）：
{'宿舍': {'食堂': 3, '教学楼A': 7},
'食堂': {'宿舍': 3, '教学楼A': 2, '图书馆': 6},
'教学楼A': {'宿舍': 7, '食堂': 2, '教学楼B': 3, '体育馆': 5},
'教学楼B': {'教学楼A': 3, '图书馆': 4, '体育馆': 2},
'图书馆': {'食堂': 6, '教学楼B': 4, '体育馆': 3, '校门': 8},
'体育馆': {'教学楼A': 5, '教学楼B': 2, '图书馆': 3, '操场': 4},
'操场': {'体育馆': 4, '校门': 5},
'校门': {'图书馆': 8, '操场': 5}}
要求输出从宿舍到校门的最短距离和路径，以及宿舍到各地点最短距离。
【题目要求】
实现Dijkstra算法，输出结果。输出格式参照示例。
【输出示例】
从【宿舍】到【校门】的最短路径： 最短距离: 17 单位 最短路径: 宿舍 → 食堂 → 图书馆 → 校门 从【宿舍】到各地点最短距离: - 体育馆: 10 单位 (路径: 宿舍 → 食堂 → 教学楼A → 体育馆) - 图书馆: 9 单位 (路径: 宿舍 → 食堂 → 图书馆) - 操场: 14 单位 (路径: 宿舍 → 食堂 → 教学楼A → 体育馆 → 操场) - 教学楼A: 5 单位 (路径: 宿舍 → 食堂 → 教学楼A) - 教学楼B: 8 单位 (路径: 宿舍 → 食堂 → 教学楼A → 教学楼B) - 校门: 17 单位 (路径: 宿舍 → 食堂 → 图书馆 → 校门) - 食堂: 3 单位 (路径: 宿舍 → 食堂)
试题17：小区宽带光纤铺设
【题目描述】
某小区有6个居民区（编号0-5），需要铺设光纤网络，连接所有居民区，且总成本最小。可能的铺设路径及成本如下（每条边为(u,v,w)）：
(0,1,4), (0,2,1), (0,3,5),
(1,2,2), (1,4,3), (2,3,6),
(2,4,7), (3,4,8), (3,5,2),
(4,5,9)
要求使用Kruskal算法求最小生成树，输出选择的边和总成本。
【题目要求】
实现Kruskal算法，输出结果。
【输出示例】
小区光纤铺设问题：连接6个居民区的最小成本方案 居民区之间的铺设成本： 居民区0 - 居民区1: 成本4万元 居民区0 - 居民区2: 成本1万元 居民区0 - 居民区3: 成本5万元 居民区1 - 居民区2: 成本2万元 居民区1 - 居民区4: 成本3万元 居民区2 - 居民区3: 成本6万元 居民区2 - 居民区4: 成本7万元 居民区3 - 居民区4: 成本8万元 居民区3 - 居民区5: 成本2万元 居民区4 - 居民区5: 成本9万元 最小生成树边（最优铺设路线）： 路线1: 居民区0 - 居民区2, 成本: 1万元 路线2: 居民区1 - 居民区2, 成本: 2万元 路线3: 居民区3 - 居民区5, 成本: 2万元 路线4: 居民区1 - 居民区4, 成本: 3万元 路线5: 居民区0 - 居民区3, 成本: 5万元 总最小成本: 13万元
试题18：课程选修顺序安排
【题目描述】
给定课程数量及先修关系，判断是否能完成所有课程，并给出一个合理的学习顺序。测试用例：
- 3门课程，先修关系：
[[1,0],[2,1]](0→1→2) - 4门课程，先修关系：
[[1,0],[2,0],[3,1],[3,2]] - 3门课程，先修关系：
[[1,0],[2,1],[0,2]](有环)
要求对每个测试用例输出学习顺序或提示有环。
【题目要求】
实现拓扑排序算法，输出结果。
【输出示例】
=== 课程安排测试 === 测试1 - 简单线性依赖: 课程数量: 3, 先修要求: [[1, 0], [2, 1]] 学习顺序: [0, 1, 2] 测试2 - 复杂依赖关系: 课程数量: 4, 先修要求: [[1, 0], [2, 0], [3, 1], [3, 2]] 学习顺序: [0, 1, 2, 3] 测试3 - 循环依赖检测: 课程数量: 3, 先修要求: [[1, 0], [2, 1], [0, 2]] 学习顺序: [] 检测到循环依赖，无法完成所有课程！
试题19：课堂时间安排
【题目描述】
使用贪心算法解决活动安排问题，选择最多的不冲突活动。给定活动列表（活动名，开始时间，结束时间）：
[('语文', 800, 900),
('数学', 830, 1000),
('英语', 900, 1000),
('物理', 1000, 1100),
('化学', 1030, 1130),
('生物', 1100, 1200)]
要求输出选择的活动及最多可安排的活动数。
【题目要求】
按结束时间排序贪心选择，输出结果。
【输出示例】
今日活动安排： 活动名称 开始时间 结束时间 语文 800 900 英语 900 1000 物理 1000 1100 生物 1100 1200 最多可安排 4 个活动
试题20：硬币找零问题
【题目描述】
给定不同面额的硬币，用最少数量的硬币凑出指定金额。
要求：
- 在中国货币体系（面额
[100,50,10,5,2,1]分）下，用贪心算法凑出136分，输出过程及结果。 - 在特殊币制（面额
[4,3,1]）下，用贪心算法凑出6分，并指出贪心算法是否最优（给出最优解）。 - 对特殊币制，用动态规划求解最优解。
【题目要求】
分别实现贪心算法和动态规划，输出对比结果。输出格式参照示例。
【输出示例】
=== 贪心算法在硬币找零问题中的应用与局限性 ===
案例1：中国货币体系（贪心算法有效）
找零 136 分，硬币面额: [100, 50, 10, 5, 2, 1]
贪心策略过程：
使用 100 分硬币 1 枚，剩余金额: 36 分
使用 10 分硬币 3 枚，剩余金额: 6 分
使用 5 分硬币 1 枚，剩余金额: 1 分
使用 1 分硬币 1 枚，剩余金额: 0 分
找零成功! 总共需要 6 枚硬币
找零方案: {100: 1, 10: 3, 5: 1, 1: 1}
案例2：特殊币制（贪心算法可能失效）
找零 6 分，硬币面额: [4, 3, 1]
贪心策略过程：
使用 4 分硬币 1 枚，剩余金额: 2 分
使用 1 分硬币 2 枚，剩余金额: 0 分
找零成功! 总共需要 3 枚硬币
贪心算法结果: {4: 1, 1: 2}，需要 3 枚硬币
但最优解应该是: {3: 2}，只需要 2 枚硬币
✗ 贪心算法未能得到最优解！
案例3：动态规划解决特殊币制问题
动态规划最优解: {3: 2}，需要 2 枚硬币
试题21：斐波那契数列
【题目描述】
使用动态规划（递推）计算斐波那契数列第n项。要求计算第10项，并输出前10项。
【题目要求】
实现动态规划算法，输出结果。
【输出示例】
斐波那契数列第10项的值：55 数列前10项： [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
试题22：背包问题
【题目描述】
使用0-1背包模型解决传统文化礼品选择问题。背包容量为10，礼品有：
- 紫砂壶（空间2，价值5）
- 文房四宝（空间3，价值7）
- 丝绸围巾（空间4，价值8）
- 茶叶礼盒（空间5，价值9）
要求输出最大文化价值、选择的礼品列表及DP表格。
【题目要求】
实现动态规划算法，输出结果。
【输出示例】
传统文化礼品选择优化方案： 行李箱容量：10 最大文化价值：21 选择的礼品： 茶叶礼盒：占用空间5，文化价值9 文房四宝：占用空间3，文化价值7 紫砂壶：占用空间2，文化价值5 总占用空间：10 DP表格（部分）： 各容量: 0 1 2 3 4 5 6 7 8 9 10 物品0: 0 0 0 0 0 0 0 0 0 0 0 物品1: 0 0 5 5 5 5 5 5 5 5 5 物品2: 0 0 5 7 7 12 12 12 12 12 12 物品3: 0 0 5 7 8 12 13 15 15 20 20 物品4: 0 0 5 7 8 12 13 15 16 20 21
试题23：周末活动规划
【题目描述】
对比贪心算法和动态规划在活动选择问题上的表现。活动列表（时间，快乐值，名称）：
(3,8,'看电影'), (2,5,'运动'), (4,10,'读书'), (1,1,'打游戏')
总可用时间6小时。
要求：
- 用贪心算法（按单位时间快乐值降序）选择活动，输出过程和结果。
- 用动态规划（0-1背包）选择活动，输出过程和结果。
- 对比两种算法的结果。
【题目要求】
实现两种算法，输出对比结果。输出格式参照示例。
【输出示例】
周末活动规划算法对比
可选活动：
活动1: 看电影 - 3小时，快乐值8，单位价值2.67
活动2: 运动 - 2小时，快乐值5，单位价值2.50
活动3: 读书 - 4小时，快乐值10，单位价值2.50
活动4: 打游戏 - 1小时，快乐值1，单位价值1.00
总可用时间: 6小时
>>> 贪心算法求解 <<<
贪心算法执行过程：
按单位时间快乐值排序结果：
1. 看电影: 3小时, 快乐值8, 单位价值2.67
2. 运动: 2小时, 快乐值5, 单位价值2.50
3. 读书: 4小时, 快乐值10, 单位价值2.50
4. 打游戏: 1小时, 快乐值1, 单位价值1.00
开始选择活动：
✅ 选择看电影，用时3小时，获得快乐值8
已用时间: 3小时，累计快乐值: 8
✅ 选择运动，用时2小时，获得快乐值5
已用时间: 5小时，累计快乐值: 13
❌ 跳过读书（时间不足）
✅ 选择打游戏，用时1小时，获得快乐值1
已用时间: 6小时，累计快乐值: 14
贪心算法结果：
总快乐值: 14
选择的活动：
看电影: 3小时，快乐值8
运动: 2小时，快乐值5
打游戏: 1小时，快乐值1
>>> 动态规划求解 <<<
动态规划填表过程：
考虑活动1: 看电影（时间3，快乐值8）
时间3小时: 选择看电影，快乐值从0增加到8
时间4小时: 选择看电影，快乐值从0增加到8
时间5小时: 选择看电影，快乐值从0增加到8
时间6小时: 选择看电影，快乐值从0增加到8
考虑活动2: 运动（时间2，快乐值5）
时间2小时: 选择运动，快乐值从0增加到5
时间5小时: 选择运动，快乐值从8增加到13
时间6小时: 选择运动，快乐值从8增加到13
考虑活动3: 读书（时间4，快乐值10）
时间4小时: 选择读书，快乐值从8增加到10
时间6小时: 选择读书，快乐值从13增加到15
考虑活动4: 打游戏（时间1，快乐值1）
时间1小时: 选择打游戏，快乐值从0增加到1
动态规划结果：
总快乐值: 15
选择的活动：
运动: 2小时，快乐值5
读书: 4小时，快乐值10
>>> 算法对比分析 <<<
贪心算法结果: 14
动态规划结果: 15
🔍 算法结果差异: 1
贪心算法未能找到全局最优解！
试题24：电视节目选择
【题目描述】
使用区间调度贪心算法，计算最多能完整观看的电视节目数量。给定节目列表（按开始和结束时间）：
测试用例1：[[1,3],[2,4],[3,5],[4,6]]
测试用例2：[[6,8],[5,9],[1,2],[3,4],[7,10]]
要求输出每个测试用例的排序后节目表、选择过程及最多节目数。
【题目要求】
实现贪心算法，输出结果。
【输出示例】
=== 测试用例1 === 排序后的节目表：[[1, 3], [2, 4], [3, 5], [4, 6]] 首先选择节目：[1, 3]，结束时间为：3 跳过节目：[2, 4]（与已选节目时间冲突） 选择节目：[3, 5]，结束时间更新为：5 跳过节目：[4, 6]（与已选节目时间冲突） 最多可以观看 2 个节目 === 测试用例2 === 排序后的节目表：[[1, 2], [3, 4], [6, 8], [5, 9], [7, 10]] 首先选择节目：[1, 2]，结束时间为：2 选择节目：[3, 4]，结束时间更新为：4 选择节目：[6, 8]，结束时间更新为：8 跳过节目：[5, 9]（与已选节目时间冲突） 跳过节目：[7, 10]（与已选节目时间冲突） 最多可以观看 3 个节目
试题25：素数判断算法优化
【题目描述】
实现三种素数判断算法：基础暴力法、平方根优化法、6k±1优化法。要求：
- 对给定的测试数字
[2,3,10,97,1009,10000]验证正确性。 - 统计1到100000之间的素数个数，并比较三种算法的运行时间。
【题目要求】
输出验证结果和性能比较。
【输出示例】
素数判断算法性能比较 ================================================== 正确性验证： 数字 2: 基础法=True, 平方根法=True, 6k法=True 数字 3: 基础法=True, 平方根法=True, 6k法=True 数字 10: 基础法=False, 平方根法=False, 6k法=False 数字 97: 基础法=True, 平方根法=True, 6k法=True 数字 1009: 基础法=True, 平方根法=True, 6k法=True 数字 10000: 基础法=False, 平方根法=False, 6k法=False 性能测试（统计1到100000的素数个数）: -------------------------------------------------- 基础暴力法: 素数个数=9592, 耗时=24.9925秒 平方根优化法: 素数个数=9592, 耗时=0.0739秒 6k±1优化法: 素数个数=9592, 耗时=0.0643秒
试题26：斐波那契数列内存优化
【题目描述】
对比使用数组存储（O(n)空间）和使用滚动变量（O(1)空间）两种方法计算斐波那契数列第n项。要求：
- 分别计算 F(10) 和 F(40) 的结果。
- 输出两种方法的运行时间对比。
【题目要求】
实现两种算法，输出结果和时间对比。
【输出示例】
================================================== 计算 F(10) 的性能对比: 优化版本: 结果=55, 时间=0.000008秒 基础版本: 结果=55, 时间=0.000008秒 时间比率: 1.06倍 ================================================== 计算 F(40) 的性能对比: 优化版本: 结果=102334155, 时间=0.000005秒 基础版本: 结果=102334155, 时间=0.000009秒 时间比率: 1.86倍
试题27：列表与字典
【题目描述】
设计一个班级学生生日档案管理系统，使用列表和字典两种数据结构存储学生信息。给定学生数据：
[("张三","2008-03-15"),("李四","2009-07-22"),("王五","2008-11-30"),
("赵六","2009-05-18"),("钱七","2008-12-25"),("孙八","2009-09-03"),
("周九","2008-06-12"),("吴十","2009-02-28")]
要求：
- 分别用列表和字典存储。
- 允许用户输入姓名查询生日，并显示两种方式的查询耗时。
- 对比列表和字典的查询速度。
【题目要求】
实现交互式查询，输入'退出'结束。输出格式参照示例。
【输出示例】
=== 班级学生生日档案管理系统 === 已录入 8 名学生信息 当前所有学生信息： 1. 张三: 2008-03-15 2. 李四: 2009-07-22 3. 王五: 2008-11-30 4. 赵六: 2009-05-18 5. 钱七: 2008-12-25 6. 孙八: 2009-09-03 7. 周九: 2008-06-12 8. 吴十: 2009-02-28 请输入要查询的学生姓名（输入'退出'结束程序）: 张三 查询结果：张三的生日是 2008-03-15 列表查询耗时：0.000009 秒 字典查询耗时：0.000005 秒 字典比列表快 1.9 倍！ 请输入要查询的学生姓名（输入'退出'结束程序）: 退出
试题28：太空探险队指挥官
【题目描述】
使用0-1背包动态规划解决能量块分配问题。能量舱容量为10，能量块有4种，体积分别为 [2,3,4,5]，能量值分别为 [3,4,5,6]。要求输出动态规划表、最大能量值及选择的能量块。
【题目要求】
实现动态规划算法，输出结果。
【输出示例】
=== 能量块分配策略 === 能量舱总容量: 10 可用的能量块: 能量块1: 体积=2, 能量值=3 能量块2: 体积=3, 能量值=4 能量块3: 体积=4, 能量值=5 能量块4: 体积=5, 能量值=6 动态规划表（部分）: 容量: 0 1 2 3 4 5 6 7 8 9 10 前0个: 0 0 0 0 0 0 0 0 0 0 0 前1个: 0 0 3 3 3 3 3 3 3 3 3 前2个: 0 0 3 4 4 7 7 7 7 7 7 前3个: 0 0 3 4 5 7 8 9 9 12 12 前4个: 0 0 3 4 5 7 8 9 10 12 13 === 最优分配方案 === 最大可获得能量: 13 选择的能量块: 能量块1: 体积=2, 能量值=3 能量块2: 体积=3, 能量值=4 能量块4: 体积=5, 能量值=6 使用总体积: 10/10