全国少儿编程大赛(高级)模拟题库

未来科技大师（高级组-冠亚季军选拔赛）

冠军题库 亚军题库 季军题库 在线练习

❀ 冠军题库（共30题）❀ 返回最前

试题1：单词拼写检查器

【题目描述】

请编写一个简单的单词拼写检查器，使用有序列表与二分查找算法判断输入的单词是否存在于预设词典中。要求比较顺序查找与二分查找的效率差异，并输出查找过程与结果。

【题目要求】

创建一个已排序的单词列表作为词典；
实现二分查找算法，并输出查找过程中的比较步骤；
实现顺序查找作为对比，输出查找步数；
输入一个单词，输出两种查找方法的结果与步数比较。

【题目说明】

# 测试数据创建一个已排序的单词列表（小型词典）
dictionary = ['apple', 'banana', 'cat', 'dog', 'elephant', 
              'fish', 'grape', 'house', 'ice', 'jungle']

【输出示例】

我的词典包含：['apple', 'banana', 'cat', 'dog', 'elephant', 'fish', 'grape', 'house', 'ice', 'jungle']
请输入要检查的单词：zebra
顺序查找结果：未找到，用了10步
二分查找过程：
第1步：比较 'zebra' 和 'elephant'
第2步：比较 'zebra' 和 'house'
第3步：比较 'zebra' 和 'ice'
第4步：比较 'zebra' 和 'jungle'
二分查找结果：未找到，用了4步
效率比较：顺序查找用了10步，二分查找只用了4步！

试题2：迷宫探险家（栈与回溯算法）

【题目描述】

请使用栈结构实现迷宫路径搜索算法。给定一个二维迷宫地图（0表示通路，1表示墙壁），从起点出发寻找一条通往终点的路径，并输出路径坐标。

【题目要求】

使用栈存储探索路径；
实现回溯机制，遇到死路时回退到上一个岔路口；
输出从起点到终点的完整路径坐标；
若找不到路径，输出相应提示。

【题目说明】

#迷宫示例 (0=通路，1=墙壁)
maze = [
    [0, 1, 0, 0, 0],
    [0, 1, 0, 1, 0],
    [0, 0, 0, 0, 0],
    [0, 1, 1, 1, 0],
    [0, 0, 0, 1, 0]
]

start = (0, 0)  # 起点
end = (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)]
找到路径!

试题3：班级值日生轮换表（循环队列）

【题目描述】

请使用循环队列实现一个班级值日生自动轮换系统。系统支持添加值日生、按周轮换显示值日生，并具备队列满员提示功能。

【题目要求】

使用循环队列结构实现；
支持添加值日生（队列满时提示）；
模拟每周轮换，输出当前值日生；
输出轮换顺序和队列状态。

【输出示例】

小明 已加入值日表
小红 已加入值日表
小刚 已加入值日表
小丽 已加入值日表
小强 已加入值日表
小华 无法加入，值日表已满！
当前值日生轮换顺序: 小明 → 小红 → 小刚 → 小丽 → 小强 → (循环)

第1周:
本周值日生是: 小明
当前值日生轮换顺序: 小红 → 小刚 → 小丽 → 小强 → (循环)

第2周:
本周值日生是: 小红
当前值日生轮换顺序: 小刚 → 小丽 → 小强 → (循环)

第3周:
本周值日生是: 小刚
当前值日生轮换顺序: 小丽 → 小强 → (循环)

第4周:
本周值日生是: 小丽
当前值日生轮换顺序: 小强 → (循环)

新同学加入:
小华 已加入值日表
小敏 已加入值日表
当前值日生轮换顺序: 小强 → 小华 → 小敏 → (循环)

第5周:
本周值日生是: 小强
当前值日生轮换顺序: 小华 → 小敏 → (循环)

第6周:
本周值日生是: 小华
当前值日生轮换顺序: 小敏 → (循环)

第7周:
本周值日生是: 小敏
当前值日生轮换顺序: (循环)

试题4：迷宫最短路径算法（二维数组与BFS）

【题目描述】

请使用二维数组与广度优先搜索（BFS）算法，计算从迷宫起点到终点的最短路径步数与路径坐标。

【题目要求】

使用二维数组表示迷宫；
实现BFS算法计算最短路径；
输出最短路径的步数与路径坐标；
若无法到达终点，输出提示信息。

【题目说明】

# 1. 创建迷宫地图 (0=路, 1=墙)
maze = [
    [0, 1, 0, 0, 0],
    [0, 1, 0, 1, 0],
    [0, 0, 0, 1, 0],
    [0, 1, 1, 1, 0],
    [0, 0, 0, 1, 0]
]

# 2. 设置起点(0,0)和终点(4,4)
start = (0, 0)
end = (4, 4)

【输出示例】

走出迷宫路径坐标：
第0步: (0, 0)
第1步: (1, 0)
第2步: (2, 0)
第3步: (2, 1)
第4步: (2, 2)
第5步: (1, 2)
第6步: (0, 2)
第7步: (0, 3)
第8步: (0, 4)
第9步: (1, 4)
第10步: (2, 4)
第11步: (3, 4)
第12步: (4, 4)
走出迷宫共需要 12 步

试题5：词频统计工具（字典与Counter）

【题目描述】

请使用Python的collections.Counter工具，对给定文本进行词频统计，输出每个词语的出现次数，并按词频从高到低排序。

【题目要求】

输入一段英文文本；
使用Counter统计词频；
输出每个词语及其出现次数；
输出出现频率最高的前三个词语。

【题目说明】

# 一个简单的童话故事
story = """
Once there was a little rabbit who loved carrots.
One day, the rabbit discovered a big carrot field.
The happy rabbit jumped for joy.
"""

【输出示例】

=== 童话故事词频统计器 ===

故事中词语出现的次数：
'Once': 1次
'there': 1次
'was': 1次
'a': 2次
'little': 1次
'rabbit': 3次
'who': 1次
'loved': 1次
'carrots.': 1次
'One': 1次
'day,': 1次
'the': 1次
'discovered': 1次
'big': 1次
'carrot': 1次
'field.': 1次
'The': 1次
'happy': 1次
'jumped': 1次
'for': 1次
'joy.': 1次

出现最多的词语：
第1名: 'rabbit'出现了3次
第2名: 'a'出现了2次
第3名: 'Once'出现了1次

试题6：关键词过滤系统（集合高效查找）

【题目描述】

请使用集合结构实现一个聊天关键词过滤系统，快速检测输入文本中是否包含预设的敏感词。

【题目要求】

使用集合存储敏感词；
输入一段聊天文本，检测是否包含敏感词；
输出检测到的敏感词；
说明集合查找的时间复杂度优势。

【题目说明】

# 定义敏感词集合（使用集合而不是列表）
sensitive_words = {"笨蛋", "讨厌", "打架", "作弊", "骗子"}

【输出示例】

=== 智能聊天关键词过滤器 ===
系统已加载 5 个敏感词

请输入聊天内容(输入q退出)：小张真是个大笨蛋
发现敏感词: 笨蛋

请输入聊天内容(输入q退出)：q

试题7：迷宫出口探测算法（多维线性查找）

【题目描述】

请在一个二维迷宫中查找入口与出口的位置，并输出其坐标。迷宫使用二维数组表示，其中2为入口，3为出口。

【题目要求】

遍历二维数组，查找入口(2)和出口(3)；
输出入口与出口的行列坐标；
若未找到，输出相应提示。

【题目说明】

# 迷宫出口探测算法 - 多维线性查找
# 5x5迷宫地图定义
• 0表示可以通行的路径
• 1表示墙壁不可通过
• 2表示迷宫的入口
• 3表示迷宫的出口

maze = [
    [1, 1, 1, 1, 1],
    [1, 2, 0, 0, 1],
    [1, 1, 1, 0, 1],
    [1, 0, 0, 0, 1],
    [1, 3, 1, 1, 1]
]

【输出示例】

迷宫地图:
1 1 1 1 1
1 2 0 0 1
1 1 1 0 1
1 0 0 0 1
1 3 1 1 1

入口位置: 第2行, 第2列
出口位置: 第5行, 第2列

试题8：手机通讯录联系人查找系统（二分查找）

【题目描述】

请使用二分查找算法实现一个通讯录系统，支持按姓名精确查找和按姓氏前缀查找，并返回联系人的电话号码。

【题目要求】

实现二分查找精确匹配；
实现前缀匹配查找（如输入“张”找到所有姓张的联系人）；
输入姓名或前缀，输出查找结果；
处理查找不到的情况。

【题目说明】

# 代码功能说明:
1.ContactSearchSystem类：
    •__init__：初始化并排序联系人姓名
    •binary_search_exact：精确查找联系人
    •binary_search_prefix：查找所有匹配前缀的联系人
    •search_contact：综合查找并输出结果
2.二分查找变种应用：
    •精确查找：标准二分查找
    •前缀查找：修改比较逻辑为startswith，并找到匹配范围
3.用户交互：
    •支持精确姓名查找
    •支持姓氏前缀查找
    •友好的输入输出界面

# 模拟通讯录数据
    contacts = {
        "张三": "13800138000",
        "李四": "13900139000",
        "王五": "13700137000",
        "赵六": "13600136000",
        "张伟": "13500135000",
        "李娜": "13400134000",
        "王芳": "13300133000",
        "张丽": "13200132000",
        "李明": "13100131000",
        "王强": "13000130000"
    }

【输出示例】

=== 通讯录查找演示 ===

请输入要查找的姓名或姓氏（输入q退出）:
张三
找到联系人: 张三，电话: 13800138000

请输入要查找的姓名或姓氏（输入q退出）:
张
找到3个姓氏为'张'的联系人:
  张丽: 13200132000
  张三: 13800138000
  张伟: 13500135000

请输入要查找的姓名或姓氏（输入q退出）:
李
找到3个姓氏为'李'的联系人:
  李明: 13100131000
  李娜: 13400134000
  李四: 13900139000

请输入要查找的姓名或姓氏（输入q退出）:
不存在的名字
未找到姓名包含'不存在的名字'的联系人

请输入要查找的姓名或姓氏（输入q退出）:
q
退出通讯录查找系统

试题9：超市水果价格排序（选择排序）

【题目描述】

请使用选择排序算法对一组水果按价格从低到高进行排序，并输出排序前后的列表。

【题目要求】

实现选择排序算法；
输入水果名称与价格；
输出排序前与排序后的水果列表；
说明选择排序的不稳定性。

【题目说明】

# 水果和它们的价格
fruits = [
    {"name": "苹果", "price": 5},
    {"name": "香蕉", "price": 3},
    {"name": "橙子", "price": 4},
    {"name": "葡萄", "price": 6},
    {"name": "梨子", "price": 2}
]

【输出示例】

排序前的水果顺序:
苹果: 5元
香蕉: 3元
橙子: 4元
葡萄: 6元
梨子: 2元

排序后的水果顺序:
梨子: 2元
香蕉: 3元
橙子: 4元
苹果: 5元
葡萄: 6元

试题10：水质监测数据波动分析（冒泡排序与滑窗算法）

【题目描述】

请对一段时间内的水质pH监测数据按日期排序，并使用滑动窗口算法找出连续3天pH值波动最大的时段。

【题目要求】

按日期对监测数据排序；
计算相邻日期的pH差值；
使用滑动窗口找出波动最大的连续3天；
输出该时段日期、pH值及总波动量。

【题目说明】

# 模拟2026年30天的水质监测数据（日期乱序）
water_quality_data = [
    {'date': '2026-05-15', 'pH': 7.2}, {'date': '2026-05-03', 'pH': 6.8},
    {'date': '2026-05-20', 'pH': 7.5}, {'date': '2026-05-08', 'pH': 7.1},
    {'date': '2026-05-25', 'pH': 7.8}, {'date': '2026-05-12', 'pH': 6.9},
    {'date': '2026-05-18', 'pH': 7.4}, {'date': '2026-05-05', 'pH': 6.7},
    {'date': '2026-05-22', 'pH': 7.6}, {'date': '2026-05-10', 'pH': 7.0},
    {'date': '2026-05-28', 'pH': 7.9}, {'date': '2026-05-01', 'pH': 6.5},
    {'date': '2026-05-16', 'pH': 7.3}, {'date': '2026-05-07', 'pH': 6.9},
    {'date': '2026-05-23', 'pH': 7.7}, {'date': '2026-05-13', 'pH': 7.0},
    {'date': '2026-05-19', 'pH': 7.5}, {'date': '2026-05-06', 'pH': 6.8},
    {'date': '2026-05-24', 'pH': 7.7}, {'date': '2026-05-09', 'pH': 7.0},
    {'date': '2026-05-27', 'pH': 7.9}, {'date': '2026-05-02', 'pH': 6.6},
    {'date': '2026-05-17', 'pH': 7.4}, {'date': '2026-05-11', 'pH': 7.0},
    {'date': '2026-05-21', 'pH': 7.6}, {'date': '2026-05-14', 'pH': 7.1},
    {'date': '2026-05-26', 'pH': 7.8}, {'date': '2026-05-04', 'pH': 6.7},
    {'date': '2026-05-29', 'pH': 8.0}, {'date': '2026-05-30', 'pH': 7.2}
]

【输出示例】

2026年原始监测数据(前5条):
日期: 2026-05-15, pH值: 7.2
日期: 2026-05-03, pH值: 6.8
日期: 2026-05-20, pH值: 7.5
日期: 2026-05-08, pH值: 7.1
日期: 2026-05-25, pH值: 7.8

2026年排序后监测数据(前5条):
日期: 2026-05-01, pH值: 6.5
日期: 2026-05-02, pH值: 6.6
日期: 2026-05-03, pH值: 6.8
日期: 2026-05-04, pH值: 6.7
日期: 2026-05-05, pH值: 6.7

2026年pH值变化最大的3天时段:
日期: 2026-05-28, pH值: 7.9
日期: 2026-05-29, pH值: 8.0
日期: 2026-05-30, pH值: 7.2
三日总变化量: 0.90

试题11：音乐播放列表智能推荐（链表与插入排序）

【题目描述】

请使用链表结构实现一个音乐播放列表系统，支持按歌曲热度动态排序，新歌曲按热度插入到合适位置。

【题目要求】

使用链表存储歌曲（名称、热度）；
新歌曲按热度插入到已排序链表中；
输出每次插入后的播放列表；
说明链表在频繁插入场景下的优势。

【题目说明】

# 初始歌曲
songs = [
    Song("小星星", 85),
    Song("两只老虎", 90),
    Song("生日快乐", 75)
]

# 模拟新增歌曲
new_songs = [
    Song("我的朋友在哪里", 80),
    Song("小兔子乖乖", 95),
    Song("上学歌", 70)
]

【输出示例】

当前推荐播放列表:
1. 两只老虎 (热度:90)
2. 小星星 (热度:85)
3. 生日快乐 (热度:75)

=== 新增3首歌曲 ===

新加入歌曲: 我的朋友在哪里 (热度:80)

当前推荐播放列表:
1. 两只老虎 (热度:90)
2. 小星星 (热度:85)
3. 我的朋友在哪里 (热度:80)
4. 生日快乐 (热度:75)

新加入歌曲: 小兔子乖乖 (热度:95)

当前推荐播放列表:
1. 小兔子乖乖 (热度:95)
2. 两只老虎 (热度:90)
3. 小星星 (热度:85)
4. 我的朋友在哪里 (热度:80)
5. 生日快乐 (热度:75)

新加入歌曲: 上学歌 (热度:70)

当前推荐播放列表:
1. 小兔子乖乖 (热度:95)
2. 两只老虎 (热度:90)
3. 小星星 (热度:85)
4. 我的朋友在哪里 (热度:80)
5. 生日快乐 (热度:75)
6. 上学歌 (热度:70)

试题12：运动会成绩排名（快速排序）

【题目描述】

请使用快速排序算法对运动会选手成绩按时间从快到慢进行排序，并输出排名结果。

【题目要求】

实现快速排序算法；
输入选手姓名与成绩（秒）；
输出按成绩升序排列的排名列表；
说明快速排序的分治思想。

【题目说明】

# 测试数据：运动员列表，包含姓名和成绩（秒）
athletes = [
    {'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}
]

【输出示例】

原始成绩列表：
张小明: 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秒

试题13：校园导航最短路径（Dijkstra算法）

【题目描述】

请使用Dijkstra算法计算校园内从起点到目的地的最短路径，输出路径与总耗时。

【题目要求】

使用邻接表表示校园地图；
实现Dijkstra算法；
输入起点与终点，输出最短路径与时间；
说明优先队列在算法中的作用。

【题目说明】

#测试数据：校园地图的加权图表示
campus_map = {
    '宿舍': {'教学楼': 5, '食堂': 3},
    '教学楼': {'宿舍': 5, '图书馆': 7, '操场': 2},
    '食堂': {'宿舍': 3, '图书馆': 2, '体育馆': 6},
    '图书馆': {'教学楼': 7, '食堂': 2, '体育馆': 1},
    '操场': {'教学楼': 2, '体育馆': 3},
    '体育馆': {'食堂': 6, '图书馆': 1, '操场': 3}
}

【输出示例】

最短路径: 宿舍 → 食堂 → 图书馆 → 体育馆
总步行时间: 6分钟

试题14：消防员救援任务（BFS最短步数）

【题目描述】

请使用BFS算法计算消防员从起点到火灾位置的最短步数，并输出路径。

【题目要求】

使用二维地图表示建筑布局；
实现BFS算法计算最短路径；
输出最短步数与路径坐标；
说明BFS在无权图中的优势。

【题目说明】

# 图形表示符
• "." 表示可以通行的道路
• "#" 表示建筑物（无法穿过）
• "F" 是消防站（起点）
• "E" 是着火点（终点）

# 测试地图
city_map = [
    ['F', '.', '#', '.', '.'],
    ['.', '.', '.', '.', '#'],
    ['.', '#', '.', '#', '.'],
    ['.', '.', '.', '.', 'E']
]

#定义四个移动方向：上、下、左、右
    directions = [(-1,0,'U'), (1,0,'D'), (0,-1,'L'), (0,1,'R')]

【输出示例】

城市街区地图:
F . # . .
. . . . #
. # . # .
. . . . E

最短救援步数: 7
移动路径: DDDRRRR

试题15：数独游戏求解器（DFS回溯算法）

【题目描述】

请使用深度优先搜索（DFS）与回溯算法实现一个数独游戏求解器，能够解决给定的9×9数独难题。

【题目要求】

实现DFS递归算法填充数独格子；
应用剪枝优化，提前排除无效数字；
输入一个未完成的数独盘面（空格用0表示）；
输出求解完成的数独盘面。

【题目说明】

# 示例数独题目 (0表示空格)
sudoku_board = [
    [5, 3, 0, 0, 7, 0, 0, 0, 0],
    [6, 0, 0, 1, 9, 5, 0, 0, 0],
    [0, 9, 8, 0, 0, 0, 0, 6, 0],
    [8, 0, 0, 0, 6, 0, 0, 0, 3],
    [4, 0, 0, 8, 0, 3, 0, 0, 1],
    [7, 0, 0, 0, 2, 0, 0, 0, 6],
    [0, 6, 0, 0, 0, 0, 2, 8, 0],
    [0, 0, 0, 4, 1, 9, 0, 0, 5],
    [0, 0, 0, 0, 8, 0, 0, 7, 9]
]

【输出示例】

初始数独:
5 3 . | . 7 . | . . . 
6 . . | 1 9 5 | . . . 
. 9 8 | . . . | . 6 . 
- - - - - - - - - - -
8 . . | . 6 . | . . 3 
4 . . | 8 . 3 | . . 1 
7 . . | . 2 . | . . 6 
- - - - - - - - - - -
. 6 . | . . . | 2 8 . 
. . . | 4 1 9 | . . 5 
. . . | . 8 . | . 7 9 

求解中...

解出的数独:
5 3 4 | 6 7 8 | 9 1 2 
6 7 2 | 1 9 5 | 3 4 8 
1 9 8 | 3 4 2 | 5 6 7 
- - - - - - - - - - -
8 5 9 | 7 6 1 | 4 2 3 
4 2 6 | 8 5 3 | 7 9 1 
7 1 3 | 9 2 4 | 8 5 6 
- - - - - - - - - - -
9 6 1 | 5 3 7 | 2 8 4 
2 8 7 | 4 1 9 | 6 3 5 
3 4 5 | 2 8 6 | 1 7 9

试题16：电力网络冗余线路检测（最小生成树）

【题目描述】

在一个电力网络图中，部分线路可能是冗余的。请使用最小生成树算法（Kruskal或Prim）找出能够连接所有节点的最小必要线路集合，并识别冗余线路。

电力网络冗余线路检测：某城市有6个发电站(A-F)和以下输电线路及维护成本：
• A-B: 4万元/年
• A-C: 3万元/年
• B-C: 5万元/年
• B-D: 7万元/年
• C-D: 6万元/年
• C-E: 8万元/年
• D-F: 9万元/年
• E-F: 5万元/年
由于预算削减，电力公司需要：
1. 确保所有发电站保持连通（可直接或间接输电）
2. 找出可以关闭的冗余线路以节省最多维护费用
3. 处理可能存在的天然不连通区域（生成最小生成森林）

【题目要求】

使用邻接表或邻接矩阵表示电力网络图；
实现最小生成树算法；
输出构成最小生成树的线路集合；
列出被识别为冗余的线路。

【题目说明】

# 发电站映射为数字: A:0, B:1, C:2, D:3, E:4, F:5
edges = [
    (0, 1, 4),  # A-B
    (0, 2, 3),  # A-C  
    (1, 2, 5),  # B-C
    (1, 3, 7),  # B-D
    (2, 3, 6),  # C-D
    (2, 4, 8),  # C-E
    (3, 5, 9),  # D-F
    (4, 5, 5)   # E-F
]

【输出示例】

必需保留的输电线路：
A-C: 3万元/年
A-B: 4万元/年
E-F: 5万元/年
C-D: 6万元/年
C-E: 8万元/年

可关闭的冗余线路：
B-C: 可节约 5万元/年
B-D: 可节约 7万元/年
D-F: 可节约 9万元/年

最优年维护成本: 26万元
每年可节约成本: 21万元

试题17：知识问答系统索引（字典树Trie）

【题目描述】

请使用字典树（Trie）结构构建一个知识问答系统的关键词索引，支持关键词的快速插入、检索和前缀匹配。

【题目要求】

实现字典树数据结构；
支持插入关键词及其关联信息（如答案ID）；
实现前缀匹配搜索，返回所有匹配关键词；
输入查询前缀，输出匹配的关键词列表。

【题目说明】

# 创建知识库并插入一些问题
kb = KnowledgeBase()
kb.insert("什么是光合作用", "植物利用阳光制造食物的过程")
kb.insert("什么是计算机", "能自动执行计算的电子设备")
kb.insert("计算机病毒是什么", "能破坏计算机程序的恶意软件")
kb.insert("太阳系有多少行星", "太阳系有8大行星")
kb.insert("怎么学习编程", "从基础开始，多实践")

【输出示例】

=== 知识库结构 ===
问题: '什么是光合作用' -> 答案: '植物利用阳光制造食物的过程'
问题: '什么是计算机' -> 答案: '能自动执行计算的电子设备'
问题: '计算机病毒是什么' -> 答案: '能破坏计算机程序的恶意软件'
问题: '太阳系有多少行星' -> 答案: '太阳系有8大行星'
问题: '怎么学习编程' -> 答案: '从基础开始，多实践'

=== 精确查找测试 ===
问题: '什么是计算机'
答案: 能自动执行计算的电子设备

=== 前缀匹配测试 ===
输入前缀: '计算机'
匹配问题: '计算机病毒是什么' -> 答案: '能破坏计算机程序的恶意软件'
匹配问题: '什么是计算机' -> 答案: '能自动执行计算的电子设备'

试题18：城市供水管网与最大流问题（图的最大流）

【题目描述】

模拟城市供水管网系统，请使用最大流算法（如Edmonds-Karp）计算从水源点到居民区的最大供水量。

【题目要求】

使用有向图表示管网，边权表示管道容量；
实现最大流算法；
输入水源点、汇点及管网结构；
输出最大流量值及关键路径。

【题目说明】

# 创建一个供水管网
water_system = Graph()

# 添加管道连接和容量
water_system.add_edge('水源', 'A小区', 3)
water_system.add_edge('水源', 'B小区', 2)
water_system.add_edge('A小区', 'C小区', 2)
water_system.add_edge('B小区', 'C小区', 1)
water_system.add_edge('B小区', 'D小区', 3)
water_system.add_edge('C小区', '目标小区', 2)
water_system.add_edge('D小区', '目标小区', 2)

【输出示例】

从水源到目标小区的最大供水量是: 4 单位

试题19：用游乐园快速通行证问题学习贪心算法

【题目描述】

限时内玩最多游乐园项目：小明在游乐园有3小时的游玩时间（180分钟），想尽可能多地体验游乐项目。每个项目有不同的持续时间和娱乐价值（如下面的列表），如何选择项目组合，才能在3小时内获得最佳体验？

项目名称	持续时间(分钟)	娱乐价值
过山车	60	90
旋转木马	20	30
鬼屋	45	80
碰碰车	30	50
摩天轮	40	65

【题目要求】

1.多维条件的贪心决策
2.价值/时间比的计算与应用
3.动态优先级调整策略
4.贪心算法的局限性分析

【题目说明】

# 游乐园项目数据
attractions = [
    {'name': '过山车', 'time': 60, 'value': 90},
    {'name': '旋转木马', 'time': 20, 'value': 30},
    {'name': '鬼屋', 'time': 45, 'value': 80},
    {'name': '碰碰车', 'time': 30, 'value': 50},
    {'name': '摩天轮', 'time': 40, 'value': 65}
]

【输出示例】

最佳项目选择方案： ['鬼屋', '碰碰车', '摩天轮', '过山车']
总共游玩项目数： 4
剩余时间： 5 分钟
选择的项目及详情：
鬼屋: 时长45分钟, 价值80, 价值比1.78
碰碰车: 时长30分钟, 价值50, 价值比1.67
摩天轮: 时长40分钟, 价值65, 价值比1.62
过山车: 时长60分钟, 价值90, 价值比1.50

试题20：野餐食物选择 – 多维背包问题

【题目描述】

野餐食物选择问题：小明要去野餐，他的背包最多能装5公斤食物。他需要选择一些食物，既要考虑食物的美味程度（1-5分），又要考虑食物的健康程度（1-5分）。如何选择食物才能在不超过背包重量的情况下，使食物的总美味度和总健康度都尽可能高？

【题目要求】

1. 多维约束的0/1背包问题
2.双价值维度的处理方法
3.记忆化搜索技术
4.递归与回溯思想
5.简单优化技巧

【题目说明】

假设有以下野餐食物选择：

食物	重量(kg)	美味度	健康度
苹果	1	3	5
薯片	2	5	1
三明治	3	4	4
果汁	1	2	3
巧克力	1	5	2

背包容量：5公斤

【输出示例】

选择的食物: [‘苹果’, ‘薯片’, ‘果汁’, ‘巧克力’]
总美味度: 15, 总健康度: 11
总重量: 5kg

试题21：网格最小路径规划

【题目描述】

小明在一个 n×m 的网格中，从左上角出发，每次只能向右或向下移动，要到达右下角。每个格子有一个数字代表通过该格子的代价。请找出路径上数字总和最小的路径，并输出最小代价。

【题目要求】

输入一个 n×m 的网格矩阵。
输出最小代价及具体路径（如：1→3→1→1→1）。
使用动态规划实现。

【题目说明】

# 测试网格
[1, 3, 1]
[1, 5, 1]
[4, 2, 1]

【输出示例】

最小路径：1→3→1→1→1
最小代价：1+3+1+1+1 = 7

试题22：篮球赛程价值最大化 – 带权区间调度

【题目描述】

市里举办篮球锦标赛，每场比赛有开始时间、结束时间和价值分数。要求选择若干场时间不冲突的比赛，使得总价值最大。

【题目要求】

输入比赛列表（开始时间、结束时间、价值）。
输出最大总价值。
使用动态规划实现，可结合二分查找优化。

【题目说明】

#测试用例
games1 = [[1, 3, 5], [2, 4, 3], [3, 5, 8], [4, 6, 4]]
games2 = [[1, 4, 2], [2, 5, 10], [3, 6, 3], [5, 7, 8]]

【输出示例】

最大总价值：13

试题23：零食分享配对 – 最长公共子序列

【题目描述】

小明和小红各自有一袋按顺序排列的零食序列。请找出两个序列的最长公共子序列（LCS），即在不改变顺序的情况下，两人能拿出的相同零食的最长排列。

【题目要求】

输入两个字符串，分别代表两人的零食序列。
输出最长公共子序列的长度及具体序列。
使用动态规划实现。

【题目说明】

# 测试数据
小明的零食："ABCBDAB"
小红的零食："BDCAB"

【输出示例】

最长公共子序列长度：4
最长公共子序列：BCAB

试题24：迷宫游戏地图—稀疏矩阵应用

【题目描述】

用迷宫游戏理解稀疏矩阵：想象你在设计一个迷宫游戏，地图是一个100×100的巨大网格，但只有不到10%的格子是墙壁（障碍物），其他都是可通行的空地。稀疏矩阵就像一张”智能地图”，只记录墙壁的位置，而不是傻傻地记住每个格子有没有墙，大大节省了内存空间。

【题目要求】

1.稀疏矩阵的概念和应用场景
2.稀疏矩阵与密集矩阵的对比
3.使用defaultdict实现稀疏矩阵
4.用纸张绘制迷宫对比两种存储方式，实际测量内存使用差异

【题目说明】

地图打印：
•只打印玩家周围10×10区域（简化显示）
•"P"表示玩家，"#"表示墙壁，"."表示空地

【输出示例】

迷宫地图 (仅显示10×10区域，共100×100)
.#########
....#.....
..........
......#...
..........
.#...P....
..........
.........#
..........
.........#

密集矩阵需要存储 10000 个格子
稀疏矩阵实际存储 853 个格子
节省了 91.47% 的空间

(50,30)是墙壁吗? False

试题25：校园寻宝游戏 – 二维分治算法

【题目描述】

校园被划分成 N×N 网格，某些格子藏有宝藏。请设计一个高效算法，找出所有宝藏的位置。

【题目要求】

输入一个 N×N 的网格（0表示无宝藏，1表示有宝藏）。
输出所有宝藏的坐标。
使用二维分治算法实现，支持剪枝优化。

【题目说明】

# 校园地图示例 (0表示无宝藏，1表示有宝藏)
campus = [
    [0, 0, 0, 1],
    [0, 1, 0, 0],
    [0, 0, 1, 0],
    [1, 0, 0, 0]
]

【输出示例】

=== 校园寻宝游戏开始 ===
校园地图:
[0, 0, 0, 1]
[0, 1, 0, 0]
[0, 0, 1, 0]
[1, 0, 0, 0]

正在搜索宝藏...

=== 寻宝结果 ===
找到 4 处宝藏:
第1行, 第4列
第2行, 第2列
第3行, 第3列
第4行, 第1列

试题26：交通灯配时优化 – 滑动窗口

【题目描述】

十字路口有四组交通灯，每分钟更新一次各方向车流量。请根据过去5分钟的车流量动态调整绿灯时间分配比例。

【题目要求】

输入四个方向过去5分钟的车流量列表。
输出各方向绿灯时间分配比例（百分比）。
使用滑动窗口算法实现。

【题目说明】

车流量数据每分钟更新一次：
•	东：[10, 15, 20, 15, 10]
•	南：[5, 10, 15, 10, 5]
•	西：[8, 12, 18, 12, 8]
•	北：[3, 7, 10, 7, 3]

【输出示例】

绿灯时间分配建议：
东方向：34%
南方向：22%
西方向：29%
北方向：15%

试题27：游戏装备合成优先级系统 – 堆排序

【题目描述】

游戏中有多个装备需要合成，每个装备有稀有度、合成时间、材料价值三个属性。请根据优先级（稀有度 > 时间 > 价值）智能安排合成顺序。

【题目要求】

输入装备列表（名称、稀有度、时间、价值）。
输出按优先级排序的合成队列。
使用堆排序（优先队列）实现。

【题目说明】

# 测试数据
王者之剑 (传说, 120分钟, 材料价值5000金币)
 火焰法杖 (史诗, 60分钟, 材料价值3000金币)
 黄金盾牌 (史诗, 90分钟, 材料价值4500金币)
 铁质头盔 (普通, 30分钟, 材料价值800金币)
 魔法戒指 (稀有, 45分钟, 材料价值2000金币)

【输出示例】

=== 最终合成队列（按优先级排序）===
排名 | 装备名称 | 稀有度 | 时间(分) | 价值(金)
-------------------------------------------------
   1 | 王者之剑   | 传说   |      120 |     5000
   2 | 火焰法杖   | 史诗   |       60 |     3000
   3 | 黄金盾牌   | 史诗   |       90 |     4500
   4 | 魔法戒指   | 稀有   |       45 |     2000
   5 | 铁质头盔   | 普通   |       30 |      800

试题28：零花钱记账本 – 前缀和与差分

【题目描述】

小明记录每周每天的零花钱使用情况，需要快速查询任意区间的花费总和，并支持动态更新某天的花费。

【题目要求】

输入一周的每日花费列表。
支持查询任意区间花费总和。
支持更新某一天的花费。
使用前缀和与差分技术实现。

【题目说明】

前缀和是什么？就像搭积木一样，我们把每天的消费累加起来：
每日消费：[5, 3, 8, 6, 2, 9, 4] (周一~周日)
前缀和： [5, 8, 16, 22, 24, 33, 37]

【输出示例】

=== 智能零花钱记账本 ===

1. 记录本周消费：

零花钱消费报告：
周一: 5元 | 周二: 3元 | 周三: 8元 | 周四: 6元 | 周五: 2元 | 周六: 9元 | 周日: 4元 | 

总计花费: 37元
========================================

2. 查询周三到周五的花费：
周三到周五共花费: 16 元

3. 周四又花了5元：

零花钱消费报告：
周一: 5元 | 周二: 3元 | 周三: 8元 | 周四: 11元 | 周五: 2元 | 周六: 9元 | 周日: 4元 | 

总计花费: 42元
========================================

试题29：汉诺塔问题 – 递归算法

【题目描述】

有三根柱子（A、B、C），A柱上有 n 个大小不同的盘子。要求将所有盘子移动到 C 柱，每次只能移动一个盘子，且大盘子不能放在小盘子上面。请输出移动步骤。

【题目要求】

输入盘子数量 n。
输出每一步的移动描述。
使用递归算法实现。

【输出示例】

=== 汉诺塔问题递归解法 ===

移动 3 个盘子的解决方案:
========================================
步骤1: 将盘子1从 A 移动到 C
步骤2: 将盘子2从 A 移动到 B
步骤3: 将盘子1从 C 移动到 B
步骤4: 将盘子3从 A 移动到 C
步骤5: 将盘子1从 B 移动到 A
步骤6: 将盘子2从 B 移动到 C
步骤7: 将盘子1从 A 移动到 C

3个盘子需要 7 步

不同盘子数量需要的步数:
========================================
1个盘子: 1步
2个盘子: 3步
3个盘子: 7步
4个盘子: 15步
5个盘子: 31步

试题30：N皇后问题 – 回溯算法

【题目描述】

在 N×N 的棋盘上放置 N 个皇后，使得它们彼此不在同一行、同一列或同一斜线上。请找出所有可能的摆放方案。

【题目要求】

输入棋盘大小 N。
输出所有摆放方案（可用棋盘矩阵或皇后位置列表表示）。
使用回溯算法实现。

【输出示例】

8皇后问题总共有 92 种解决方案！

❀ 亚军题库（共30题）❀ 返回最前

试题1：考试成绩统计分析——列表遍历与统计

【题目描述】

编写一个程序，读取一个班级的数学成绩列表，计算并输出以下统计信息：

全班总分
平均分（保留一位小数）
最高分
最低分
高于平均分的学生人数

【题目要求】

使用列表存储成绩数据。
使用循环遍历列表，并调用内置函数完成统计。
输出格式需清晰，包含必要的中文说明。

【输出示例】

=== 考试成绩统计分析 ===
全班数学成绩： [85, 92, 78, 90, 88, 95, 82, 76, 89, 93]

带编号的成绩显示：
学生1的成绩：85分
学生2的成绩：92分
...
学生10的成绩：93分

=== 统计结果 ===
全班总分：868分
平均分：86.8分
最高分：95分
最低分：76分

高于平均分的学生人数：6人

试题2：括号匹配检测器——栈的应用

【题目描述】

编写一个程序，判断一个表达式中的括号是否匹配。支持的括号类型包括：圆括号 ()、方括号 []、花括号 {}。

【题目要求】

使用栈结构实现括号匹配检测。
程序应能处理包含多种括号的表达式。
输出检测结果，并说明是否匹配。

【输出示例】

括号匹配检测结果:
'(3 + [5 × {2 + 1}])':通过 (预期: True, 实际: True)
'(3 + [5 × {2 + 1)]':通过 (预期: False, 实际: False)
'{[()]}':通过 (预期: True, 实际: True)
'{[(])}':通过 (预期: False, 实际: False)
'((()))':通过 (预期: True, 实际: True)
'[{[()]}]':通过 (预期: True, 实际: True)
'abc(def[ghi]jkl)mno':通过 (预期: True, 实际: True)
'no brackets here':通过 (预期: True, 实际: True)

试题3：银行叫号系统——多队列管理

【题目描述】

模拟一个银行叫号系统，支持三类客户：VIP客户、对公客户、普通客户。系统应按照优先级顺序叫号，并实时显示各队列状态。

【题目要求】

实现三个独立队列，分别对应不同客户类型。
叫号顺序为：VIP → 对公 → 普通。
支持取号、叫号、显示队列状态等功能。

【输出示例】

===== 客户开始取号 =====
普通客户 N1001 已取号，前面有 0 位普通客户等待
VIP客户 V1002 已取号，前面有 0 位VIP客户等待
普通客户 N1003 已取号，前面有 1 位普通客户等待
对公客户 C1004 已取号，前面有 0 位对公客户等待
VIP客户 V1005 已取号，前面有 1 位VIP客户等待
普通客户 N1006 已取号，前面有 2 位普通客户等待

=== 当前排队情况 ===
VIP队列(2人): ['V1002', 'V1005']
对公队列(1人): ['C1004']
普通队列(3人): ['N1001', 'N1003', 'N1006']
==================


===== 开始叫号 =====
请 V1002 到1号窗口办理业务（VIP优先）
V1002 业务办理完成

请 V1005 到1号窗口办理业务（VIP优先）
V1005 业务办理完成

请 C1004 到2号窗口办理业务（对公业务）
C1004 业务办理完成

请 N1001 到3号窗口办理业务（普通业务）
N1001 业务办理完成

请 N1003 到3号窗口办理业务（普通业务）
N1003 业务办理完成

请 N1006 到3号窗口办理业务（普通业务）
N1006 业务办理完成

当前没有客户等待

=== 当前排队情况 ===
VIP队列(0人): []
对公队列(0人): []
普通队列(0人): []
==================

试题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号 |

试题5：学生成绩管理系统——嵌套字典

【题目描述】

设计一个学生成绩管理系统，使用嵌套字典存储学生姓名、各科成绩，并支持查询成绩、计算平均分。

【题目要求】

使用字典嵌套字典的结构存储数据。
支持按学生姓名查询成绩。
输出该学生的各科成绩及平均分。

【输出示例】

=== 学生成绩查询系统 ===
请输入学生姓名：小明

小明的成绩单：
数学: 90分
语文: 85分
英语: 88分
平均分: 87.7分

试题6：抽奖系统去重——集合唯一性

【题目描述】

编写一个抽奖系统，自动去除重复的参与者，确保每人仅有一次中奖机会，并展示去重后的参与者名单。

【题目要求】

使用集合去除重复名字。
随机选择一名中奖者。
输出去重后的名单及中奖者。

【输出示例】

=== 幸运抽奖系统 ===
原始参与者名单： ['小明', '小红', '小刚', '小红', '小丽', '小明', '小强']
去重后的唯一参与者： {'小强', '小刚', '小明', '小丽', '小红'}

恭喜 小红 中奖啦!

试题7：单词拼写检查器——线性查找与时间复杂度

【题目描述】

给定一个无序的单词词典列表，编写一个程序，检查用户输入的单词是否在词典中。要求使用线性查找算法实现，并记录比较次数与查找时间。

【题目要求】

使用线性查找在无序列表中查找单词。
记录查找过程中的比较次数和实际耗时。
输出查找结果及统计信息。

【题目说明】

# 无序的常用单词词典（前20个单词作为示例）
word_dictionary = [
    'apple', 'book', 'cat', 'dog', 'egg',
    'fish', 'girl', 'hat', 'ice', 'jump',
    'kite', 'love', 'moon', 'nose', 'orange',
    'pig', 'queen', 'rabbit', 'sun', 'tree'
]

【输出示例】

请输入要检查的单词: dog
拼写正确！单词 'dog' 在词典的第4个位置。

查找统计:
- 比较次数: 4次
- 查找时间: 0.0041毫秒
- 词典大小: 20个单词

试题8：图书馆找书系统——二分查找算法

【题目描述】

假设图书馆的图书已按书名拼音顺序排列，编写一个程序，使用二分查找算法快速定位指定图书的位置。

【题目要求】

实现二分查找算法。
输出查找过程中每次检查的图书名称。
返回图书在列表中的位置（从1开始计数）。

【题目说明】

# 模拟已排序的图书馆藏书（按书名拼音顺序）
books = [
    "ATSTH安徒生童话", "BKQS百科全书", "HLBT哈利波特", "HLM红楼梦",
    "JYQJ金庸全集", "ST体", "SW十万个为什么", "XYJ西游记",
    "XWZ小王子", "ZGLS中国历史"

【输出示例】

开始在图书馆查找：《HLBT哈利波特》
正在检查：《JYQJ金庸全集》
正在检查：《BKQS百科全书》
正在检查：《HLBT哈利波特》
找到了！《HLBT哈利波特》在第3个书架位置

试题9：垃圾分类助手——多属性选择排序

【题目描述】

给定一组垃圾数据，包含名称、类型和重量三个属性，编写一个程序，实现按类型排序、以及按类型和重量双重排序的功能。

【题目要求】

实现支持多属性排序的选择排序算法。
分别按“类型”和“类型+重量”排序并输出结果。
使用字典列表存储垃圾数据。

【题目说明】

# 垃圾数据：名称、类型（1:可回收 2:有害 3:厨余 4:其他）、重量(kg)
trash_items = [
    {"name": "旧报纸", "type": 1, "weight": 0.5},
    {"name": "电池", "type": 2, "weight": 0.1},
    {"name": "香蕉皮", "type": 3, "weight": 0.2},
    {"name": "塑料袋", "type": 4, "weight": 0.05},
    {"name": "玻璃瓶", "type": 1, "weight": 0.3},
    {"name": "药品", "type": 2, "weight": 0.05},
    {"name": "剩饭", "type": 3, "weight": 1.2},
    {"name": "餐巾纸", "type": 4, "weight": 0.1}
]

【输出示例】

=== 按类型排序 ===
旧报纸: 类型1, 重量0.5kg
玻璃瓶: 类型1, 重量0.3kg
电池: 类型2, 重量0.1kg
药品: 类型2, 重量0.05kg
香蕉皮: 类型3, 重量0.2kg
剩饭: 类型3, 重量1.2kg
塑料袋: 类型4, 重量0.05kg
餐巾纸: 类型4, 重量0.1kg

=== 按类型和重量排序 ===
玻璃瓶: 类型1, 重量0.3kg
旧报纸: 类型1, 重量0.5kg
药品: 类型2, 重量0.05kg
电池: 类型2, 重量0.1kg
香蕉皮: 类型3, 重量0.2kg
剩饭: 类型3, 重量1.2kg
塑料袋: 类型4, 重量0.05kg
餐巾纸: 类型4, 重量0.1kg

试题10：停车场车牌排序系统——冒泡排序

【题目描述】

给定一组车牌号，编写一个程序，使用冒泡排序算法按照以下规则排序：

按省份简称拼音顺序排序
省份相同则按字母顺序排序
字母相同则按数字部分排序

【题目要求】

实现冒泡排序算法，支持多级比较。
使用自定义比较函数处理省份、字母和数字。
输出排序前后的车牌列表。

【题目说明】

# 省份简称到拼音的映射（简化版）
province_pinyin = {
    '京': 'jing', '沪': 'hu', '津': 'jin', '渝': 'yu',
    '冀': 'ji', '晋': 'jin', '辽': 'liao', '吉': 'ji',
    '黑': 'hei', '苏': 'su', '浙': 'zhe', '皖': 'wan',
    '闽': 'min', '赣': 'gan', '鲁': 'lu', '豫': 'yu',
    '鄂': 'e', '湘': 'xiang', '粤': 'yue', '琼': 'qiong',
    '川': 'chuan', '贵': 'gui', '云': 'yun', '陕': 'shan',
    '甘': 'gan', '青': 'qing', '藏': 'zang', '蒙': 'meng',
    '桂': 'gui', '宁': 'ning', '新': 'xin'
}

【输出示例】

原始车牌顺序:
京A12345
沪B23456
京B12345
粤A99999
京A99999
沪A00001
京C11111
粤B11111
京A11111
沪A11111

排序后车牌顺序:
沪A00001
沪A11111
沪B23456
京A11111
京A12345
京A99999
京B12345
京C11111
粤A99999
粤B11111

试题11：直播礼物实时排行榜——插入排序优化

【题目描述】

模拟直播平台礼物排行榜，每当有观众送出礼物时，实时更新主播的礼物值，并维护一个按礼物值降序排列的榜单。

【题目要求】

使用插入排序算法实时更新排序。
每次送礼后输出最新排行榜。
支持多名主播的礼物值动态更新。

【题目说明】

# 初始化5位主播和他们的礼物值
    anchors = ["主播小A", "主播小B", "主播小C", "主播小D", "主播小E"]
    gifts = [0] * 5  # 初始礼物值都是0

【输出示例】

直播礼物实时排行榜
当前排名:
第1名: 主播小A - 0礼物
第2名: 主播小B - 0礼物
...

主播小C 收到 45 礼物！

最新排行榜:
第1名: 主播小C - 45礼物
第2名: 主播小A - 0礼物
...

主播小B 收到 78 礼物！

最新排行榜:
第1名: 主播小B - 78礼物
第2名: 主播小C - 45礼物
...

试题12：电商商品多条件筛选——快速排序的高级应用

【题目描述】

给定一组商品数据（包含名称、价格、销量、评分），编写一个程序，支持按单属性（如价格）或多属性（如评分+价格）进行排序。

【题目要求】

实现快速排序算法，支持多关键字排序。
可分别按价格升序、销量降序、评分降序+价格升序等规则排序。
输出排序后的商品列表。

【题目说明】

# 模拟电商商品数据
products = [
    {"name": "手机", "price": 2999, "sales": 500, "rating": 4.7},
    {"name": "耳机", "price": 399, "sales": 1200, "rating": 4.3},
    {"name": "平板", "price": 1999, "sales": 800, "rating": 4.5},
    {"name": "笔记本", "price": 5999, "sales": 300, "rating": 4.8},
    {"name": "智能手表", "price": 999, "sales": 1500, "rating": 4.4},
    {"name": "充电宝", "price": 99, "sales": 2500, "rating": 4.2},
]

【输出示例】

按价格升序排序:
充电宝: ￥99
耳机: ￥399
智能手表: ￥999
平板: ￥1999
手机: ￥2999
笔记本: ￥5999

按销量降序排序:
充电宝: 销量2500
智能手表: 销量1500
耳机: 销量1200
平板: 销量800
手机: 销量500
笔记本: 销量300

按评分降序，价格升序排序:
笔记本: 评分4.8, ￥5999
手机: 评分4.7, ￥2999
平板: 评分4.5, ￥1999
智能手表: 评分4.4, ￥999
耳机: 评分4.3, ￥399
充电宝: 评分4.2, ￥99

试题13：地铁最短路线规划——Dijkstra算法

【题目描述】

小明的城市有两条地铁线路：

🟥 红线：学校站 → 公园站（5分钟）→ 商场站（5分钟）→ 游乐园站
🟦 蓝线：学校站 → 图书馆站（5分钟）→ 游乐园站

在公园站可以换乘（需要3分钟），帮小明找到从学校去游乐园的最快路线！

给定一个地铁线路图（含换乘站及行程时间），编写一个程序，计算从起点到终点的最短时间路径。

【题目要求】

使用Dijkstra算法计算最短路径。
输出最短时间及完整路径。
支持多条线路及换乘时间计算。

【输出示例】

红线直达: (15, ['红_学校', '红_公园', '红_商场', '红_游乐园'])
蓝线直达: (10, ['蓝_学校', '蓝_图书馆', '蓝_游乐园'])
换乘路线: (13, ['红_学校', '红_公园', '蓝_图书馆', '蓝_游乐园'])

试题14：用社交网络学习BFS和三度人脉算法

【题目描述】

给定一个社交关系图，编写一个程序，从指定用户出发，找出其一度、二度和三度人脉（即朋友、朋友的朋友、朋友的朋友的朋友）。

【题目要求】

使用BFS算法按层级遍历社交网络。
输出各度人脉的用户列表。
限制遍历深度为三度。

【题目说明】

#测试数据
小红的直接好友：小明、小华
小明的好友：小红、小强、小丽
小华的好友：小红、小美
小强的好友：小明、小刚
小丽的好友：小明
小美的好友：小华
小刚的好友：小强

【输出示例】

小红的好友推荐系统结果:
1度人脉推荐: 小明, 小华
2度人脉推荐: 小强, 小丽, 小美
3度人脉推荐: 小刚

试题15：校园谣言传播——有向图可达性分析（DFS/BFS）

【题目描述】

给定一个谣言传播的有向图，编写一个程序，计算从源头开始所有可能听到谣言的节点，以及在限定时间内能传播到的节点。

【题目要求】

使用DFS计算所有可达节点。
使用BFS计算在指定时间内的传播范围。
输出节点列表及传播时间。

【题目说明】

# 测试数据
课间10分钟，一条"明天停课"的谣言从同学A开始传播：
•	A首先告诉B和C
•	B又告诉D
•	C告诉E
•	D又告诉E（E听到两次）
问题：
1.	从A出发，哪些同学会听到谣言？
2.	如果谣言在5分钟内能传播多远？（假设每次传播需要1分钟）
将同学看作节点，谣言传播方向看作有向边，问题转化为有向图的可达性分析。

【输出示例】

从A出发会听到谣言的同学: ['A', 'B', 'C', 'D', 'E']

5分钟内谣言传播情况:
A: 0分钟
B: 1分钟
C: 1分钟
D: 2分钟
E: 2分钟

试题16：乐高城堡稳固结构与最小生成树

【题目描述】

给定多个塔楼（节点）及其之间可能的连接桥（边）与建造成本（权重），编写一个程序，设计一个连接所有塔楼且总成本最低的桥梁方案。

【题目要求】

使用Prim算法构建最小生成树。
输出每条连接桥及其成本。
计算并输出总成本。

【题目说明】

已知塔楼间可能的连接桥及其需要的积木数量：
•	A-B: 5块
•	A-C: 9块
•	A-D: 12块
•	B-C: 8块
•	B-D: 14块
•	C-D: 10块

【输出示例】

最优乐高城堡连接方案：
A-B: 5块积木
B-C: 8块积木
C-D: 10块积木
总共需要积木: 23块

试题17：用学校组织学习广度优先搜索

【题目描述】

模拟一个学校组织结构树，编写一个程序，使用广度优先搜索遍历整个组织，并计算组织的高度（层数）。

【题目要求】

使用BFS遍历树结构。
按层输出组织成员。
输出组织结构的总层数。

【题目说明】

# 构建学校组织结构
principal = SchoolMember("张校长", "校长")
dean1 = SchoolMember("李主任", "教导主任")
dean2 = SchoolMember("王主任", "后勤主任")
teacher1 = SchoolMember("赵老师", "语文老师")
teacher2 = SchoolMember("钱老师", "数学老师")
class1 = SchoolMember("一班", "班级")
class2 = SchoolMember("二班", "班级")

【输出示例】

=== 开始遍历 ===
=== 学校组织架构 ===

第 1 层：校长(张校长) 
第 2 层：教导主任(李主任) 后勤主任(王主任) 
第 3 层：语文老师(赵老师) 数学老师(钱老师) 
第 4 层：班级(一班) 班级(二班) 

学校管理结构的高度是：4层

试题18：旅游景点路线规划与最短路径

【题目描述】

给定一个旅游区景点分布图（加权无向图），编写一个程序，计算从指定起点到终点的最短时间路径。

【题目要求】

使用Dijkstra算法计算最短路径。
输出完整路径及总时间。
支持多组起点-终点查询。

【题目说明】

旅游景点示例-我们有5个景点：
	0: 熊猫馆
	1: 恐龙乐园
	2: 水上世界
	3: 太空探索
	4: 童话城堡
步行道连接及行走时间：
	熊猫馆 ↔ 恐龙乐园：5分钟
	熊猫馆 ↔ 水上世界：10分钟
	恐龙乐园 ↔ 童话城堡：20分钟
	恐龙乐园 ↔ 水上世界：3分钟
	水上世界 ↔ 太空探索：8分钟
	太空探索 ↔ 童话城堡：6分钟

【输出示例】

=== 旅游区景点 ===
0: 熊猫馆
1: 恐龙乐园
2: 水上世界
3: 太空探索
4: 童话城堡

=== 步行道连接及时间(分钟) ===
熊猫馆 ↔ 恐龙乐园: 5分钟
熊猫馆 ↔ 水上世界: 10分钟
恐龙乐园 ↔ 熊猫馆: 5分钟
恐龙乐园 ↔ 水上世界: 3分钟
恐龙乐园 ↔ 童话城堡: 20分钟
水上世界 ↔ 熊猫馆: 10分钟
水上世界 ↔ 恐龙乐园: 3分钟
水上世界 ↔ 太空探索: 8分钟
太空探索 ↔ 水上世界: 8分钟
太空探索 ↔ 童话城堡: 6分钟
童话城堡 ↔ 恐龙乐园: 20分钟
童话城堡 ↔ 太空探索: 6分钟

=== 最短路径查询结果 ===
从 熊猫馆 到 童话城堡 的最短路径是:
熊猫馆 → 恐龙乐园 → 水上世界 → 太空探索 → 童话城堡
总时间: 22分钟

=== 最短路径查询结果 ===
从 水上世界 到 童话城堡 的最短路径是:
水上世界 → 太空探索 → 童话城堡
总时间: 14分钟

试题19：用兴趣班时间安排学习贪心算法

【题目描述】

给定多个兴趣班的开始和结束时间，编写一个程序，选择最多数量的不冲突课程。

【题目要求】

使用贪心算法（按结束时间排序）选择课程。
输出所选课程列表及总数。
确保课程时间不重叠。

【题目说明】

# 测试数据
courses = [
    ("美术课", 9, 10),
    ("舞蹈课", 9.5, 10.5),
    ("编程课", 10, 11),
    ("音乐课", 10.5, 11.5),
    ("书法课", 11, 12)
]

【输出示例】

最多可以安排的不冲突课程： ['美术课', '编程课', '书法课']
总共可以安排 3 门课程

试题20：暑假各科分数提升与时间分配——分组背包问题

【题目描述】

给定多个学科组，每组包含若干复习计划（需天数、可提分数），在总天数限制下，每组至多选择一项计划，求最大总分提升。

【题目要求】

使用分组背包的动态规划算法求解。
输出最优复习计划及总分提升。
使用滚动数组优化空间。

【题目说明】

学科分组：
1.语文组：
    •背古诗：2天，可提高5分
    •阅读训练：3天，可提高8分
    •作文练习：4天，可提高10分
2.数学组：
    •基础题训练：1天，可提高3分
    •难题攻克：3天，可提高7分
    •模拟测试：5天，可提高12分
3.英语组：
    •单词记忆：2天，可提高6分
    •听力训练：3天，可提高9分
    •语法练习：4天，可提高11分
规则：
    •每组最多选择一项复习计划
    •总时间不超过10天

【输出示例】

动态规划(滚动数组)解法：
最大分数提升: 26分
复习计划安排:
  第1组: 3天复习，提高8分
  第2组: 5天复习，提高12分
  第3组: 2天复习，提高6分
总使用天数: 10天 (≤10天)

试题21：吃糖果大冒险——探索动态规划

【题目描述】

小明每天可以吃1块或2块糖果，编写一个程序，计算吃完n块糖果的不同方式数。

【题目要求】

使用动态规划递推求解。
输出方式总数。
理解状态转移方程：dp[i] = dp[i-1] + dp[i-2]。

【题目说明】

• 可以每天吃1块，10天吃完：1+1+1+1+1+1+1+1+1+1
• 可以某几天吃2块：1+2+1+2+1+2+1
• 也可以连续几天吃2块：2+2+2+2+2

【输出示例】

吃完10块糖果的不同方式有：89种

试题22：教室借用安排——区间分组

【题目描述】

给定多个社团的活动时间区间，编写一个程序，计算最少需要多少间教室，使得所有活动不冲突。

【题目要求】

使用贪心算法（按开始时间排序）结合最小堆实现。
输出最少教室数量。
模拟活动安排过程并输出每一步状态。

【题目说明】

    """
    计算最少需要的教室数量
    参数:
    activities -- 活动列表，每个活动是[start, end]格式
    返回:
    最少需要的教室数量
    """

【输出示例】

=== 测试用例===
按开始时间排序后的活动：[[1, 3], [2, 4], [3, 5], [4, 6]]

处理活动：[1, 3]
  需要新开一间教室
  当前教室状态（结束时间）：[3]

处理活动：[2, 4]
  需要新开一间教室
  当前教室状态（结束时间）：[3, 4]

处理活动：[3, 5]
  安排到最早空闲的教室（原结束时间：4）
  当前教室状态（结束时间）：[4, 5]

处理活动：[4, 6]
  安排到最早空闲的教室（原结束时间：5）
  当前教室状态（结束时间）：[5, 6]
最少需要 2 间教室

试题23：乐高拼写游戏——字符串DP

【题目描述】

给定目标单词和一堆字母积木，编写一个程序，判断是否能用积木恰好拼出目标单词。

【题目要求】

使用字符计数或动态规划方法判断。
输出是否可拼出及缺少或多出的字母。
展示DP状态转移过程（如使用）。

【题目说明】

    """
    判断是否能用积木拼出目标单词
    参数:
    target -- 目标单词
    blocks -- 可用积木字符串
    返回:
    是否能够拼出
    """

【输出示例】

=== 测试用例1：可以拼出 ===
目标单词 'LEGO' 需要字母: {'L': 1, 'E': 1, 'G': 1, 'O': 1}
可用积木 'GOLE' 提供字母: {'G': 1, 'O': 1, 'L': 1, 'E': 1}
所有字母都足够！可以拼出目标单词
结果: True

=== 测试用例2：有多余字母 ===
目标单词 'CAT' 需要字母: {'C': 1, 'A': 1, 'T': 1}
可用积木 'CABT' 提供字母: {'C': 1, 'A': 1, 'B': 1, 'T': 1}
有多余字母: {'B'}
所有字母都足够！可以拼出目标单词
结果: True

=== DP方法测试 ===

DP方法分析:
目标单词长度: 3
积木统计: {'C': 1, 'A': 1, 'B': 1}
  使用积木 'A' 匹配目标第1个字符，dp[1] = 1
  使用积木 'B' 匹配目标第2个字符，dp[2] = 1
  使用积木 'C' 匹配目标第3个字符，dp[3] = 1
DP方法结果: True

试题24：电子宠物社交系统——社交网络图结构

【题目描述】

模拟一个电子宠物社交网络，编写一个程序，实现朋友查询、最短关系链查找、最受欢迎宠物推荐等功能。

【题目要求】

使用邻接表表示图结构。
实现BFS遍历、最短路径查找、度中心性计算。
输出查询结果。

【题目说明】

# 创建宠物社交网络
pet_network = PetSocialNetwork()
 
# 添加宠物
pet_network.add_pet('p1', '豆豆', '电子狗')
pet_network.add_pet('p2', '毛毛', '电子猫')
pet_network.add_pet('p3', '花花', '电子兔')
pet_network.add_pet('p4', '球球', '电子仓鼠')
pet_network.add_pet('p5', '闪电', '电子狐狸')
pet_network.add_pet('p6', '泡泡', '电子鱼')
 
# 建立友谊关系
pet_network.add_friendship('p1', 'p2')  # 豆豆-毛毛
pet_network.add_friendship('p1', 'p3')  # 豆豆-花花
pet_network.add_friendship('p2', 'p4')  # 毛毛-球球
pet_network.add_friendship('p3', 'p4')  # 花花-球球
pet_network.add_friendship('p3', 'p5')  # 花花-闪电
pet_network.add_friendship('p4', 'p6')  # 球球-泡泡

【输出示例】

豆豆的直接朋友: ['花花', '毛毛']

从豆豆出发的BFS遍历顺序: ['豆豆', '毛毛', '花花', '球球', '闪电', '泡泡']

豆豆到泡泡的最短友谊链: ['豆豆', '毛毛', '球球', '泡泡']

最受欢迎的宠物: 花花 (3个朋友)

给豆豆的朋友推荐: ['球球', '闪电']

试题25：乐高城堡建造——分治算法

【题目描述】

使用分治算法模拟多人分工建造乐高城堡的过程，将任务分解为独立子任务，最后合并结果。

【题目要求】

实现递归分治逻辑。
模拟分工建造过程并输出步骤。
输出最终建造完成的所有部分。

【题目说明】

# 城堡的组成部分
castle_parts = ["东城墙", "西城墙", "北塔楼", "南塔楼"]
# 建造工人
workers = ["小明", "小红", "小刚", "小丽"]

【输出示例】

=== 开始建造乐高城堡 ===
分工建造: ['小明', '小红']负责['东城墙', '西城墙'], ['小刚', '小丽']负责['北塔楼', '南塔楼']
分工建造: ['小明']负责['东城墙'], ['小红']负责['西城墙']
小明正在建造东城墙...
小明的东城墙: 已完成 1/3
小明的东城墙: 已完成 2/3
小明的东城墙: 已完成 3/3
小明完成了东城墙!

小红正在建造西城墙...
小红的西城墙: 已完成 1/3
小红的西城墙: 已完成 2/3
小红的西城墙: 已完成 3/3
小红完成了西城墙!

分工建造: ['小刚']负责['北塔楼'], ['小丽']负责['南塔楼']
小刚正在建造北塔楼...
小刚的北塔楼: 已完成 1/3
小刚的北塔楼: 已完成 2/3
小刚的北塔楼: 已完成 3/3
小刚完成了北塔楼!

小丽正在建造南塔楼...
小丽的南塔楼: 已完成 1/3
小丽的南塔楼: 已完成 2/3
小丽的南塔楼: 已完成 3/3
小丽完成了南塔楼!


=== 所有部分建造完成！ ===
最终城堡包含: 建造好的东城墙, 建造好的西城墙, 建造好的北塔楼, 建造好的南塔楼

试题26：用滑动窗口统计游戏连击技能伤害

【题目描述】

给定一个攻击伤害序列，使用滑动窗口算法，找出连续攻击伤害总和不超过100的最长连击段。

【题目要求】

实现可变大小滑动窗口。
输出最长连击次数及总伤害。
实时更新窗口并输出状态（可选）。

【题目说明】

举例说明：
攻击伤害：[20, 30, 40, 15, 25, 50]
最长连击若是第2-5次攻击(30+40+15+25=110>100不行，30+40+15=85可以)，共3次攻击，总和85

【输出示例】

最长连击3次，总伤害90

试题27：用医院急诊分诊学习堆排序

【题目描述】

模拟医院急诊分诊系统，根据病人紧急程度和到达时间，使用优先队列（最小堆）安排就诊顺序。

【题目要求】

使用堆实现多条件优先级队列。
支持病人挂号、治疗下一位病人、显示等待列表。
输出就诊顺序和等待队列。

【题目说明】

# 创建急诊室
hospital = EmergencyRoom()
 
# 模拟病人到来
print("=== 医院急诊分诊系统 ===")
hospital.add_patient(2, "小明")    # 紧急程度2级
hospital.add_patient(1, "小红")    # 紧急程度1级（最紧急）
hospital.add_patient(3, "小刚")
hospital.add_patient(1, "小丽")    # 紧急程度1级，但比小红晚到

【输出示例】

=== 医院急诊分诊系统 ===
小明 已挂号，紧急程度2级
小红 已挂号，紧急程度1级
小刚 已挂号，紧急程度3级
小丽 已挂号，紧急程度1级

=== 当前等待情况 ===

当前等待病人列表:
排名 | 姓名    | 紧急程度 | 到达时间
----------------------------------------
   1 | 小红     |        1 | 02:05:33
   2 | 小丽     |        1 | 02:05:33
   3 | 小明     |        2 | 02:05:33
   4 | 小刚     |        3 | 02:05:33

=== 开始治疗 ===
正在治疗: 小红 (紧急程度1级, 到达时间02:05:33)
正在治疗: 小丽 (紧急程度1级, 到达时间02:05:33)
正在治疗: 小明 (紧急程度2级, 到达时间02:05:33)

=== 等待情况 ===

当前等待病人列表:
排名 | 姓名    | 紧急程度 | 到达时间
----------------------------------------
   1 | 小刚     |        3 | 02:05:33

试题28：灯泡开关谜题——位运算

【题目描述】

使用位运算模拟多个灯泡的状态控制，支持翻转单个或全部灯泡，并判断是否达到全亮状态。

【题目要求】

使用整数二进制位表示灯泡状态。
使用异或运算实现翻转。
输出操作后的状态及是否全亮。

【题目说明】

•	1 表示灯泡亮 💡
•	0 表示灯泡灭 ⚫
•	用异或操作 ^ 来翻转灯泡状态

【输出示例】

=== 灯泡游戏 ===

可用的操作:
1. 翻转第1个灯泡 (001)
2. 翻转第2个灯泡 (010)
3. 翻转第3个灯泡 (100)
4. 翻转所有灯泡 (111)

请选择操作(1-4): 1
操作后的状态: 0b111
恭喜！所有灯泡都亮了！

试题29：家族辈分关系-递归树形结构

【题目描述】

探索家族树：用递归算法查找家族成员关系
小明想了解自己家族中每个人的辈分关系。请设计一个程序，使用递归算法来：
1.构建家族树形结构
2.查找某个人的所有后代
3.计算某个人的辈分等级
4.找出家族中最年长的一代

【题目要求】

实现递归函数计算走法数。
输出结果。
理解递归基线条件和递推关系。

【题目说明】

    # 创建家族成员
    great_grandpa = FamilyMember("太爷爷")
    grandpa = FamilyMember("爷爷")
    uncle = FamilyMember("叔叔")
    father = FamilyMember("爸爸")
    mother = FamilyMember("妈妈")
    me = FamilyMember("小明")
    brother = FamilyMember("弟弟")
    sister = FamilyMember("妹妹")
    cousin = FamilyMember("堂兄")
     
    # 建立关系
    great_grandpa.add_child(grandpa)
    grandpa.add_child(uncle)
    grandpa.add_child(father)  
    uncle.add_child(cousin)
    father.add_child(me)
    father.add_child(brother)
    father.add_child(sister)

【输出示例】

=== 家族辈分关系分析 ===

1. 太爷爷的所有后代: ['爷爷', '叔叔', '堂兄', '爸爸', '小明', '弟弟', '妹妹']
2. 小明的辈分等级: 第3代
2. 爷爷的辈分等级: 第1代
2. 堂兄的辈分等级: 第3代
3. 家族中最年长的是第3代

4. 完整家族结构:
└─ 太爷爷 (第0代)
  └─ 爷爷 (第1代)
    └─ 叔叔 (第2代)
      └─ 堂兄 (第3代)
    └─ 爸爸 (第2代)
      └─ 小明 (第3代)
      └─ 弟弟 (第3代)
      └─ 妹妹 (第3代)

试题30：特工任务破解密码锁——回溯算法

【题目描述】

破解密码锁：

你是一个身手敏捷的小特工，发现了一个古老的三位数字密码锁（每个数字从0到9）。锁的密码被忘记了，但你知道一个秘密线索：这个密码的数字之和等于8。

你的任务不是傻傻地从000一直试到999，而是用聪明的办法，快速找出所有可能满足“数字之和为8”的密码组合，然后一一尝试，直到打开它！

【题目要求】

使用回溯算法探索所有路径。
标记已访问位置，避免重复访问。
输出找到的路径或路径总数。

【输出示例】

小特工开始破解密码锁！所有可能密码如下：
找到密码: [0, 0, 8]
找到密码: [0, 1, 7]
找到密码: [0, 2, 6]
找到密码: [0, 3, 5]
找到密码: [0, 4, 4]
找到密码: [0, 5, 3]
找到密码: [0, 6, 2]
找到密码: [0, 7, 1]
找到密码: [0, 8, 0]
找到密码: [1, 0, 7]
找到密码: [1, 1, 6]
找到密码: [1, 2, 5]
找到密码: [1, 3, 4]
找到密码: [1, 4, 3]
找到密码: [1, 5, 2]
找到密码: [1, 6, 1]
找到密码: [1, 7, 0]
找到密码: [2, 0, 6]
找到密码: [2, 1, 5]
找到密码: [2, 2, 4]
找到密码: [2, 3, 3]
找到密码: [2, 4, 2]
找到密码: [2, 5, 1]
找到密码: [2, 6, 0]
找到密码: [3, 0, 5]
找到密码: [3, 1, 4]
找到密码: [3, 2, 3]
找到密码: [3, 3, 2]
找到密码: [3, 4, 1]
找到密码: [3, 5, 0]
找到密码: [4, 0, 4]
找到密码: [4, 1, 3]
找到密码: [4, 2, 2]
找到密码: [4, 3, 1]
找到密码: [4, 4, 0]
找到密码: [5, 0, 3]
找到密码: [5, 1, 2]
找到密码: [5, 2, 1]
找到密码: [5, 3, 0]
找到密码: [6, 0, 2]
找到密码: [6, 1, 1]
找到密码: [6, 2, 0]
找到密码: [7, 0, 1]
找到密码: [7, 1, 0]
找到密码: [8, 0, 0]

❀ 季军题库（共30题）❀ 返回最前

试题1：购物清单管理系统

【题目描述】

编写一个Python程序，模拟购物清单的创建、查看、修改和删除功能。程序应能对清单中的物品进行增删改查操作，并支持按索引或切片方式访问物品。

【题目要求】

创建一个空列表用于存储购物物品。
实现添加物品功能（支持末尾添加与指定位置插入）。
实现查看物品功能（支持遍历、索引访问和切片）。
实现修改物品功能（根据索引修改物品名称）。
实现删除物品功能（支持按索引删除和按值删除）。
使用循环遍历并输出最终清单。

【输出示例】

欢迎使用购物清单管理小助手！
当前购物清单：[]

添加物品后的购物清单：
['苹果', '鸡蛋', '牛奶', '面包']

购物清单中的物品：
0. 苹果
1. 鸡蛋
2. 牛奶
3. 面包

第一个要买的物品：苹果
前两样物品：['苹果', '鸡蛋']
最后一样物品：面包

修改后的购物清单：['苹果', '鸡蛋', '牛奶', '全麦面包']

删除了：鸡蛋
删除后的购物清单：['苹果', '牛奶', '全麦面包']

再次删除后的购物清单：['苹果', '全麦面包']

最终购物清单：
0. 苹果
1. 全麦面包

试题2：浏览器后退功能模拟系统

【题目描述】

使用栈数据结构模拟浏览器的后退功能。要求实现一个类，支持页面访问记录和后退操作，遵循“后进先出”原则。

【题目要求】

实现一个BrowserHistory类，包含visit和back方法。
visit方法用于访问新页面，并将当前页面压入栈中。
back方法用于返回上一个页面，并从栈中弹出最近访问的页面。
若无法后退，应提示用户。
模拟一系列页面访问和后退操作，并输出每一步的结果。

【输出示例】

当前页面: 智码云端||言若金叶网站首页 www.kidzm.cn
当前页面: 关于我们->联系我们页
当前页面: 关于我们->新闻资讯页
当前页面: 关于我们->管理团队页
当前页面: 关于我们->企业简介页

开始后退操作:
后退到: 关于我们->管理团队页
后退到: 关于我们->新闻资讯页
后退到: 关于我们->联系我们页
后退到: 智码云端||言若金叶网站首页 www.kidzm.cn
无法后退，已在最初页面

试题3：打印机任务调度系统

【题目描述】

使用队列数据结构模拟打印机任务调度过程。任务按照“先进先出”原则依次执行，要求实现任务的添加、打印和队列查看功能。

【题目要求】

使用collections.deque实现一个任务队列。
实现add_task方法用于添加打印任务。
实现print_next方法用于打印队列中的下一个任务。
实现show_queue方法用于显示当前所有待打印任务。
模拟多个任务的添加与打印过程，并输出每一步的状态。

【输出示例】

已添加打印任务: 数学作业.pdf
已添加打印任务: 家庭照片.jpg
已添加打印任务: 科学报告.docx
当前打印队列: 数学作业.pdf → 家庭照片.jpg → 科学报告.docx

开始打印任务:
正在打印: 数学作业.pdf
完成打印: 数学作业.pdf
正在打印: 家庭照片.jpg
完成打印: 家庭照片.jpg
正在打印: 科学报告.docx
完成打印: 科学报告.docx
没有待打印的任务

已添加打印任务: 英语作文.doc
正在打印: 英语作文.doc
完成打印: 英语作文.doc

试题4：教室座位表管理系统

【题目描述】

使用二维数组（列表的列表）模拟一个4排5列的教室座位表，实现座位的占用、显示与统计功能。座位状态用0（空）和1（已占）表示。

【题目要求】

初始化一个4×5的全空座位表。
实现指定座位的占用功能（例如第2排第3列）。
以矩阵形式显示当前座位表，区分空位与已占座位。
统计并输出当前到课学生人数。
注意行列索引从0开始。

【输出示例】

当前座位表：
空位 空位 空位 空位 空位
空位 空位 已占 空位 空位
空位 空位 已占 空位 空位
空位 空位 空位 空位 空位

今天来了 2 位同学

试题5：单词翻译器

【题目描述】

编写一个简单的英汉单词翻译器。程序预置一个英文单词到中文释义的字典，允许用户输入英文单词查询其中文意思。

【题目要求】

创建一个字典，包含至少5个英文单词及其对应中文释义。
程序启动时显示欢迎语和可查询的单词列表。
接收用户输入的英文单词。
若单词在字典中，输出其中文释义；否则提示未收录。
程序应能处理连续查询（本题按单次查询实现即可）。

【输出示例】

欢迎使用小小单词翻译器！
目前我可以翻译这些水果单词：apple, banana, orange, grape, watermelon
请输入你想查的英文单词：apple
apple 的中文意思是：苹果

试题6：好友共同兴趣查找器

【题目描述】

使用集合数据结构，计算并显示你和两位好友的兴趣共同点与差异。程序支持选择一位好友进行比较，输出共同兴趣、所有兴趣以及各自独有的兴趣。

【题目要求】

为“你”和两位好友分别初始化一个兴趣集合。
提供菜单让用户选择与哪一位好友进行比较。
计算并输出：
- 共同兴趣（交集）
- 两人所有的兴趣（并集）
- 你独有的兴趣（差集）
- 好友独有的兴趣（差集）
使用集合运算符（&、|、-）实现计算。

【题目说明】

# 定义你和朋友的兴趣集合
your_hobbies = {"篮球", "画画", "编程", "吃披萨"}
friend1_hobbies = {"足球", "编程", "看电影", "吃汉堡"}
friend2_hobbies = {"篮球", "游泳", "编程", "吃披萨"}

【输出示例】

=== 好友兴趣匹配器 ===
请选择要比较的好友：
1. 小明
2. 小红
输入选择(1或2): 2

你和小红的共同兴趣是：{'吃披萨', '编程', '篮球'}
你们所有的兴趣是：{'画画', '吃披萨', '游泳', '篮球', '编程'}
只有你喜欢的：{'画画'}
只有小红喜欢的：{'游泳'}

试题7：图书馆找书系统

【题目描述】

模拟图书馆的图书查找过程。假设图书馆有100本编号连续的书，用户输入想借阅的图书编号，程序使用线性查找算法在列表中寻找该书，并返回其位置或未找到的提示。

【题目要求】

初始化一个包含1到100的列表，表示图书编号。
接收用户输入的目标图书编号。
使用线性查找（顺序遍历）算法在列表中查找该书。
若找到，输出该书在书架上的位置（从1开始计数）；若未找到，给出相应提示。
查找过程中使用found标志和position记录结果。

【输出示例】

请输入你想借的书本编号(1-100): 5

找到了！书本编号5在书架的第5个位置。

试题8：字典单词快速查询

【题目描述】

在已按字母顺序排序的单词列表中，使用二分查找算法快速查询某个单词是否存在，并返回其索引位置。

【题目要求】

初始化一个已排序的单词列表。
实现binary_search函数，接收单词列表和目标单词，返回其索引（找到）或-1（未找到）。
在函数中使用左右指针和循环实现二分查找。
在主程序中调用该函数，根据返回值输出相应的找到或未找到信息。
注意确保输入列表是有序的。

【单词列表示例】

# 示例使用
dictionary = ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig', 'grape']
word_to_find = 'date'
 
# 必须先确保字典是有序的！
dictionary.sort()  # 虽然这个例子已经有序，但实际使用时需要确保

【输出示例】

找到单词 'date' 了！它在字典的第 4 个位置。

试题9：运动会成绩排行榜

【题目描述】

使用选择排序算法对一组运动会成绩（如50米跑时间）进行从小到大排序，模拟排行榜的生成过程。要求输出每一轮排序后的结果。

【题目要求】

初始化一个包含至少5个成绩的列表。
实现selection_sort函数，对输入列表进行选择排序（升序）。
排序过程中，每确定一个最小值的位置后，输出当前轮次排序后的列表。
最终输出排序后的最终排行榜。
要求使用双重循环实现，并交换元素位置。

【成绩示例】

# 运动会50米跑成绩（秒）
scores = [8.5, 7.2, 9.1, 6.8, 7.8, 8.0, 7.5]

【输出示例】

原始成绩: [8.5, 7.2, 9.1, 6.8, 7.8, 8.0, 7.5]
第1轮排序后: [6.8, 7.2, 9.1, 8.5, 7.8, 8.0, 7.5]
第2轮排序后: [6.8, 7.2, 9.1, 8.5, 7.8, 8.0, 7.5]
第3轮排序后: [6.8, 7.2, 7.5, 8.5, 7.8, 8.0, 9.1]
第4轮排序后: [6.8, 7.2, 7.5, 7.8, 8.5, 8.0, 9.1]
第5轮排序后: [6.8, 7.2, 7.5, 7.8, 8.0, 8.5, 9.1]
第6轮排序后: [6.8, 7.2, 7.5, 7.8, 8.0, 8.5, 9.1]
最终排行榜: [6.8, 7.2, 7.5, 7.8, 8.0, 8.5, 9.1]

试题10：班级身高排队系统

【题目描述】

使用冒泡排序算法对班级学生的身高数据进行从矮到高排序，并实现优化：当某一轮没有发生交换时提前终止排序。

【题目要求】

初始化一个包含至少5个身高数据的列表。
实现bubble_sort_with_optimization函数，进行升序冒泡排序。
使用swapped标志优化算法，当一轮未发生交换时提前结束。
每完成一轮排序，输出当前列表状态。
最终输出排序后的身高序列。

【输出示例】

原始身高顺序: [155, 160, 148, 172, 165, 158, 163, 170, 168, 150]
第1轮排序后: [155, 148, 160, 165, 158, 163, 170, 168, 150, 172]
第2轮排序后: [148, 155, 160, 158, 163, 165, 168, 150, 170, 172]
第3轮排序后: [148, 155, 158, 160, 163, 165, 150, 168, 170, 172]
第4轮排序后: [148, 155, 158, 160, 163, 150, 165, 168, 170, 172]
第5轮排序后: [148, 155, 158, 160, 150, 163, 165, 168, 170, 172]
第6轮排序后: [148, 155, 158, 150, 160, 163, 165, 168, 170, 172]
第7轮排序后: [148, 155, 150, 158, 160, 163, 165, 168, 170, 172]
第8轮排序后: [148, 150, 155, 158, 160, 163, 165, 168, 170, 172]
最终排序结果: [148, 150, 155, 158, 160, 163, 165, 168, 170, 172]

试题11：扑克牌整理小游戏

【题目描述】

模拟摸牌和理牌过程，使用插入排序的思想，每次摸一张新牌就将其插入到手牌中正确的位置，使手牌始终保持从小到大排列。

【题目要求】

准备一副数字为1-10的牌并打乱顺序。
初始化一个空手牌列表。
循环摸牌：每次从牌堆摸一张牌，找到它在手牌中的正确插入位置并插入。
每摸一张牌，输出摸到的牌、插入位置和当前手牌状态。
最终输出整理完成后的手牌。

【输出示例】

开始整理扑克牌！
洗好的牌: [7, 10, 6, 1, 9, 3, 8, 5, 4, 2]

摸到: 2
插入位置: 0
当前手牌: [2]

摸到: 4
插入位置: 1
当前手牌: [2, 4]

摸到: 5
插入位置: 2
当前手牌: [2, 4, 5]

摸到: 8
插入位置: 3
当前手牌: [2, 4, 5, 8]

摸到: 3
插入位置: 1
当前手牌: [2, 3, 4, 5, 8]

摸到: 9
插入位置: 5
当前手牌: [2, 3, 4, 5, 8, 9]

摸到: 1
插入位置: 0
当前手牌: [1, 2, 3, 4, 5, 8, 9]

摸到: 6
插入位置: 5
当前手牌: [1, 2, 3, 4, 5, 6, 8, 9]

摸到: 10
插入位置: 8
当前手牌: [1, 2, 3, 4, 5, 6, 8, 9, 10]

摸到: 7
插入位置: 6
当前手牌: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

整理完成！最终手牌:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

试题12：学校食堂快速分餐系统

【题目描述】

使用快速排序算法对不同班级的学生编号列表进行排序，模拟食堂按班级顺序分餐的优化流程。

【题目要求】

初始化一个包含多个班级编号的列表（可能有重复）。
实现quick_sort函数，使用分治策略对列表进行升序排序。
选择列表中间元素作为基准值（pivot），进行分区操作（左区小于基准，中区等于基准，右区大于基准）。
递归地对左右分区进行快速排序，并与中区合并返回结果。
输出排序前后的班级顺序。

【输出示例】

分餐前班级顺序: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
分餐后班级顺序: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

试题13：校园快递最优配送路线

【题目描述】

小明是校园快递站的一名配送员，每天需要从快递站出发，将包裹送到校园各个宿舍楼。校园中有多条道路连接不同的地点，每条道路都有不同的行走时间。请使用Dijkstra算法计算从快递站出发到各宿舍楼的最短路径（时间）及具体路线。

【题目要求】

使用邻接表（字典）表示校园各地点及其之间的步行时间。
实现dijkstra函数，使用优先队列（heapq）计算单源最短路径。
记录每个节点的最短距离和前驱节点。
实现get_shortest_path函数，根据前驱节点字典回溯出完整路径。
输出从起点到各目标地点的最短时间和具体路线。

【题目说明】

# 校园地图图表示（邻接表）（单位：分钟）
campus_graph = {
    '快递站': {'食堂': 3, '图书馆': 5},
    '食堂': {'快递站': 3, '图书馆': 1, '教学楼': 2},
    '图书馆': {'快递站': 5, '食堂': 1, '教学楼': 1, '宿舍A': 4},
    '教学楼': {'食堂': 2, '图书馆': 1, '宿舍B': 3},
    '宿舍A': {'图书馆': 4, '宿舍B': 2},
    '宿舍B': {'教学楼': 3, '宿舍A': 2}
}

【输出示例】

从快递站到各宿舍楼的最短配送时间:
到宿舍A: 8分钟
最优路线: 快递站 -> 食堂 -> 图书馆 -> 宿舍A
到宿舍B: 8分钟
最优路线: 快递站 -> 食堂 -> 教学楼A -> 宿舍B

试题14：走迷宫最短步数求解

【题目描述】

在一个字符矩阵表示的迷宫中，使用广度优先搜索（BFS）算法找出从起点‘S’到终点‘E’的最短步数。只能上下左右移动，每次一步，‘#’代表墙壁。

【题目要求】

定义迷宫地图（二维列表）。
实现shortest_path函数，使用队列（deque）进行BFS。
使用visited集合记录已访问位置，避免重复。
每次从队列取出位置时，检查是否到达终点。
若找到终点，返回步数；若队列为空仍未找到，返回-1。
输出最短步数。

【题目说明】

#迷宫地图:
S . . . #
. # # . #
. # # . .
. . . . E
   S代表起点，E代表终点，.代表可通路径，#代表墙壁不能能行

【输出示例】

迷宫地图:
S . . . #
. # # . #
. # # . .
. . . . E

从起点到终点的最短步数是: 7

试题15：校园迷宫寻宝

【题目描述】

在一个4×4的迷宫中，使用深度优先搜索（DFS）回溯算法寻找一条从起点‘S’到宝藏‘T’的路径。‘.’为路，‘#’为墙。

【题目要求】

定义4×4的迷宫地图。
实现递归函数find_path，尝试四个方向（上、下、左、右）。
通过将走过的位置标记为‘x’来避免绕圈。
若到达终点，记录路径并返回成功；若所有方向都不通，则回溯（恢复标记并从路径中移除当前位置）。
输出找到的一条路径（位置坐标序列）。

【题目说明】

• S 是起点（入口）
• T 是宝藏（终点）
• . 是可以走的路
• # 是灌木墙，不能走
# 迷宫 4×4 定义如下
maze = [
    ['S', '.', '.', '#'],
    ['.', '#', '.', '.'],
    ['.', '.', '#', '.'],
    ['#', '.', '.', 'T']
]

小明一次只能向上、下、左、右走一步，

【输出示例】

找到了一条路径:
-> (0, 0) -> (1, 0) -> (2, 0) -> (2, 1) -> (3, 1) -> (3, 2) -> (3, 3)

试题16：村庄光纤铺设成本优化

【题目描述】

在多个村庄之间铺设光纤网络，每条线路有相应成本。使用Kruskal算法找到连接所有村庄且总成本最低的铺设方案。

每条可能的光纤线路及其铺设成本如下：

A-B: 2万元
A-D: 6万元
B-C: 3万元
B-D: 8万元
B-E: 5万元
C-E: 7万元
D-E: 9万元

【题目要求】

使用边列表表示村庄间的连接及成本。
实现UnionFind类（并查集），支持find和union操作，用于检测环路。
实现kruskal函数：将边按成本排序，依次选择不会构成环路的边加入最小生成树，直到选中边数达到n-1。
输出最优铺设方案（边及其成本）和总成本。

【输出示例】

最优光纤铺设方案：
A-B: 2万元
B-C: 3万元
B-E: 5万元
A-D: 6万元
总成本: 16万元

试题17：家族关系查询系统

【题目描述】

构建一个简单的家族树，并实现基于深度优先搜索（DFS）的成员查找功能。树节点包含成员姓名和子节点列表。

【题目要求】

实现FamilyMember类，包含姓名、子节点列表，以及add_child和find_member方法。
find_member方法使用递归进行DFS查找，打印检查过程。
构建一个至少三代的家族树。
调用根节点的find_member方法查找指定成员。
输出查找过程及结果。

【输出示例】

=== 家族结构 ===
爷爷
  爸爸
    小明
    妹妹
  妈妈

=== 查找家庭成员 ===
正在检查：爷爷
正在检查：爸爸
正在检查：小明
正在检查：妹妹
找到了！妹妹

查找结果：找到 妹妹

试题18：地铁线路查询与图论基础

【题目描述】

模拟一个简单的地铁线路网络，使用邻接矩阵和邻接表两种方式表示图结构，并计算每个站点的连接线路数量（顶点的度）。

【题目要求】

定义5个地铁站及其名称映射。
分别用邻接矩阵和邻接表表示给定的地铁连接关系。
实现calculate_degrees函数，根据邻接矩阵计算每个站点的连接数。
输出站点信息、邻接矩阵、邻接表以及每个站点的连接数量。
查询指定站点的连接信息。

【题目说明】

地铁线路示例-假设我们有5个地铁站：
•	0: 动物园站
•	1: 公园站
•	2: 学校站
•	3: 商场站
•	4: 游泳馆站
地铁线路连接如下：
•	动物园站 ↔ 公园站
•	公园站 ↔ 学校站
•	学校站 ↔ 商场站
•	商场站 ↔ 游泳馆站
•	游泳馆站 ↔ 动物园站

【输出示例】

=== 地铁站信息 ===
0: 动物园站
1: 公园站
...

=== 邻接矩阵表示 ===
[0, 1, 0, 0, 1]
[1, 0, 1, 0, 0]
...

=== 每个地铁站的连接线路数量 ===
动物园站: 2条连接线路
...

查询: 学校站的连接信息
学校站 直接连接: 公园站, 商场站

试题19：零钱兑换问题（贪心算法）

【题目描述】

给定一个金额和一组硬币面额，使用贪心算法计算凑出该金额所需的最少硬币数量（假设硬币供应无限）。硬币面额需满足贪心选择性质。

【题目要求】

实现min_coins_greedy函数，接收金额和硬币面额列表。
将硬币面额从大到小排序。
遍历排序后的面额，每次尽可能多地使用当前面额硬币，并更新剩余金额。
若最终剩余金额为0，返回使用的硬币列表；否则返回None。
输出凑零钱的方案和硬币总数。

【题目说明】

小明想用最少的硬币数来买价值8元的零食。假设现在有面额为1元、2元和5元的硬币，如何用最少的硬币凑出8元？

【输出示例】

用最少的硬币凑出8元的方法是：[5, 2, 1]
最少需要3个硬币

试题20：小书包装玩具（0/1背包问题）

【题目描述】

在背包容量有限的情况下，从一组物品（各有重量和价值）中选择若干物品装入背包，使得总价值最大。每个物品最多选一次（0/1背包）。分别用动态规划法和贪心法求解，并比较结果。

【题目要求】

实现动态规划解法knapsack_dp：使用二维DP表，状态dp[i][w]表示前i个物品、容量w下的最大价值。通过状态转移填充表格，并回溯得到所选物品。
实现贪心解法knapsack_greedy：按价值重量比降序选择物品，直到背包装满。
给定物品数据（重量、价值）和背包容量，分别调用两种方法。
输出两种方法得到的最大价值、所选物品及其重量、价值。

【题目说明】

玩具清单：
1.	玩具熊：重量1kg，价值6元
2.	小汽车：重量2kg，价值10元
3.	积木：重量3kg，价值12元
4.	玩偶：重量2kg，价值7元
5.	拼图：重量4kg，价值14元
6.	球：重量1kg，价值5元

【输出示例】

动态规划解法：
最大价值: 23元
选择的玩具: [4, 2, 1]
对应重量: [2, 2, 1]
对应价值: [7, 10, 6]

贪心算法解法：
最大价值: 21元
选择的玩具: [1, 6, 2]
对应重量: [1, 1, 2]
对应价值: [6, 5, 10]

试题21：校园快递派送路径规划（Dijkstra算法实现）

【题目描述】

在一个加权有向图表示的校园地图中，实现Dijkstra算法，计算从快递站出发到其他所有地点的最短配送时间，并输出最短路径。

【题目要求】

使用邻接表字典表示校园地图（地点为键，值为可达邻居及时间的字典）。
实现完整的dijkstra函数，使用优先队列（最小堆）优化。
记录每个地点的最短距离和前驱节点。
实现print_paths函数，根据前驱节点字典打印从起点到所有其他地点的最短路径及时间。
输出所有最短路径。

【题目说明】

#用字典构建邻接表，出发点到到达点的时间
campus = {
"快递站": {"图书馆": 5, "食堂": 2},
"食堂": {"教学楼A": 1},
"图书馆": {"教学楼A": 3},
"教学楼A": {"教学楼B": 4},
"教学楼B": {}
}

【输出示例】

从快递站到各教学楼的最短时间：
快递站: 0分钟
食堂: 2分钟
图书馆: 5分钟
教学楼A: 3分钟
教学楼B: 7分钟

从快递站出发的最短路径：
到食堂: 快递站 -> 食堂 (总时间: 2分钟)
到图书馆: 快递站 -> 图书馆 (总时间: 5分钟)
到教学楼A: 快递站 -> 食堂 -> 教学楼A (总时间: 3分钟)
到教学楼B: 快递站 -> 食堂 -> 教学楼A -> 教学楼B (总时间: 7分钟)

试题22：电视节目选择问题（区间调度-贪心算法）

【题目描述】

给定一组电视节目的开始和结束时间，使用贪心算法找出最多能观看多少个互不冲突的完整节目。

【题目要求】

实现max_programs函数，接收节目列表（每个节目是[start, end]）。
将节目按结束时间升序排序。
贪心选择：依次选择结束时间最早且不与已选节目冲突的节目。
记录并输出选择过程（选择或跳过某个节目）。
返回并输出最多可观看的节目数量。

【题目说明】

电视节目数量：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 个节目

试题23：密码强度检查员（字符串动态规划）

【题目描述】

给定一个密码字符串，使用动态规划思想找出其中最长的连续数字子序列的长度。

【题目要求】

实现find_longest_digits函数，接收密码字符串。
使用DP数组dp，其中dp[i]表示以第i个字符（索引i-1）结尾的连续数字长度。
遍历字符串：若当前字符是数字，dp[i] = dp[i-1] + 1；否则dp[i] = 0。同时更新全局最大长度和结束位置。
根据结束位置回溯得到最长的连续数字子串。
输出分析过程、最长连续数字及其长度。

【输出示例】

=== 测试用例1：混合字符 ===
分析密码: 'abc123xy4567z'
密码长度: 13

开始检查每个字符...
字符1: 'a'不是数字，重置计数: 0
字符2: 'b'不是数字，重置计数: 0
字符3: 'c'不是数字，重置计数: 0
字符4: '1'是数字，连续计数: 1
字符5: '2'是数字，连续计数: 2
字符6: '3'是数字，连续计数: 3
字符7: 'x'不是数字，重置计数: 0
字符8: 'y'不是数字，重置计数: 0
字符9: '4'是数字，连续计数: 1
字符10: '5'是数字，连续计数: 2
字符11: '6'是数字，连续计数: 3
字符12: '7'是数字，连续计数: 4
字符13: 'z'不是数字，重置计数: 0

发现最长连续数字: '4567' (位置:8-11)
最长连续数字长度: 4

=== 测试用例2：复杂密码 ===
分析密码: 'P@ssw0rd2023!Safe789'
密码长度: 20

开始检查每个字符...
字符1: 'P'不是数字，重置计数: 0
字符2: '@'不是数字，重置计数: 0
字符3: 's'不是数字，重置计数: 0
字符4: 's'不是数字，重置计数: 0
字符5: 'w'不是数字，重置计数: 0
字符6: '0'是数字，连续计数: 1
字符7: 'r'不是数字，重置计数: 0
字符8: 'd'不是数字，重置计数: 0
字符9: '2'是数字，连续计数: 1
字符10: '0'是数字，连续计数: 2
字符11: '2'是数字，连续计数: 3
字符12: '3'是数字，连续计数: 4
字符13: '!'不是数字，重置计数: 0
字符14: 'S'不是数字，重置计数: 0
字符15: 'a'不是数字，重置计数: 0
字符16: 'f'不是数字，重置计数: 0
字符17: 'e'不是数字，重置计数: 0
字符18: '7'是数字，连续计数: 1
字符19: '8'是数字，连续计数: 2
字符20: '9'是数字，连续计数: 3

发现最长连续数字: '2023' (位置:8-11)
最长连续数字长度: 4

=== 空间优化版本测试 ===
密码 'a1b22c333' 的最长数字序列: 3
密码 '123abc456' 的最长数字序列: 3
密码 'no-digits' 的最长数字序列: 0

试题24：智能家居设备网络（图结构应用）

【题目描述】

模拟一个智能家居设备网络，使用图结构（邻接表）表示设备间的连接关系，并实现网络遍历、最短路径查找和连通性检查功能。

【题目要求】

实现SmartHomeNetwork类，使用defaultdict(list)表示邻接表。
提供add_device（添加设备）、add_connection（添加双向连接）方法。
实现bfs_traversal（广度优先遍历）、find_shortest_path（BFS求无权图最短路径）和check_network_connectivity（检查网络是否全连通）方法。
构建一个包含至少5个设备的网络并添加连接。
测试并输出BFS遍历顺序、设备间最短路径和网络连通性。

【题目说明】

# 设备名称列表
my_home.add_device('d1', '客厅主灯', 'light')
my_home.add_device('d2', '卧室空调', 'ac')
my_home.add_device('d3', '智能音箱', 'speaker')
my_home.add_device('d4', '门锁', 'lock')
my_home.add_device('d5', '路由器', 'router')

【输出示例】

BFS遍历顺序: ['d5', 'd1', 'd2', 'd3', 'd4']
客厅主灯到门锁的最短路径: ['d1', 'd3', 'd4']
网络是否完全连通: True
断开连接后网络是否连通: True

试题25：巧克力分块比赛（分治算法）

【题目描述】

将一块由N个小方格组成的长条形巧克力全部掰成1×1的小块，每次只能沿直线掰开一块巧克力。使用分治算法计算所需的最少掰断次数。

【题目要求】

实现递归函数chocolate_breaks，参数为小方格总数n。
基线条件：当n为1时，返回0（无需再掰）。
递归关系：将n对半分开（或尽可能接近），当前掰1次加上左右两部分各自需要掰的次数。
计算并输出掰断不同大小巧克力所需的最少次数。

【输出示例】

4块巧克力需要掰: 3 次
8块巧克力需要掰: 7 次
12块巧克力需要掰: 11 次

试题26：滑动窗口找最甜的3颗糖

【题目描述】

给定一个表示糖果甜度的列表，使用固定大小为3的滑动窗口，找出连续3颗糖甜度总和最高的组合。

【题目要求】

实现find_sweetest_3candies函数，接收甜度列表。
若列表长度小于3，返回提示信息。
计算初始窗口（前3颗糖）的甜度和。
滑动窗口：每次减去离开窗口的糖果甜度，加上新进入窗口的糖果甜度，更新当前和。
跟踪最大和及其起始位置。
输出最甜的3颗糖的起始位置、甜度总和以及具体甜度值。

【输出示例】

例如：糖果甜度：[5, 2, 8, 3, 1]，连续3颗糖的甜度总和：
•	5+2+8=15
•	2+8+3=13
•	8+3+1=12
最高总和是15，对应第1-3颗糖（5, 2, 8）

【输出示例】

最甜的3颗糖是第1-3颗，甜度总和是15，它们是[5, 2, 8]

试题27：图书借阅排行榜（堆排序算法）

【题目描述】

使用堆排序算法，根据图书的借阅次数对图书列表进行降序排序，生成热门图书排行榜

【题目要求】

实现heap_sort函数，接收图书列表（每个图书是包含name和count键的字典）。
使用heapq模块构建最小堆，通过将借阅次数取负值来模拟最大堆。
将所有图书插入堆后，依次弹出堆顶元素，恢复正数后得到降序列表。
输出原始数据和排序后的排行榜（从高到低）。

【输出示例】

原始图书借阅数据:
Python编程入门: 借阅45次
科学小实验: 借阅78次
动物世界: 借阅32次
童话故事集: 借阅91次
数学趣味题: 借阅56次
历史大发现: 借阅23次

热门图书排行榜(从高到低):
第1名: 童话故事集, 借阅91次
第2名: 科学小实验, 借阅78次
第3名: 数学趣味题, 借阅56次
第4名: Python编程入门, 借阅45次
第5名: 动物世界, 借阅32次
第6名: 历史大发现, 借阅23次

试题28：食堂多窗口打饭调度（负载均衡-最小堆）

【题目描述】

模拟食堂多个打饭窗口的排队调度。使用最小堆数据结构，始终将新来的同学分配到当前排队人数最少的窗口。

【题目要求】

实现CanteenScheduler类，初始化指定数量的窗口（初始人数为0）。
使用heapq.heapify将窗口列表转化为最小堆。
add_student方法：弹出堆顶（人数最少的窗口），将其人数加1后重新入堆。
模拟连续多个同学到来的分配过程，输出每次分配的结果。
最终输出各窗口的排队人数。

【输出示例】

=== 食堂多窗口打饭调度系统 ===
初始化：有3个打饭窗口，开始都为空

开始模拟同学们来打饭：
第1个同学：新同学分配到原来有0人的窗口，现在有1人
第2个同学：新同学分配到原来有0人的窗口，现在有1人
第3个同学：新同学分配到原来有0人的窗口，现在有1人
第4个同学：新同学分配到原来有1人的窗口，现在有2人
第5个同学：新同学分配到原来有1人的窗口，现在有2人
第6个同学：新同学分配到原来有1人的窗口，现在有2人
第7个同学：新同学分配到原来有2人的窗口，现在有3人
第8个同学：新同学分配到原来有2人的窗口，现在有3人
第9个同学：新同学分配到原来有2人的窗口，现在有3人
第10个同学：新同学分配到原来有3人的窗口，现在有4人

最终各窗口排队人数：[3, 3, 4]

试题29：走楼梯的算法探索（递归算法）

【题目描述】

爬一个n阶的楼梯，每次可以跨1阶或2阶。使用递归算法计算爬到第n阶有多少种不同的走法。

【题目要求】

实现递归函数climb_stairs，参数为楼梯阶数n。
基线条件：n == 1时返回1（一种走法）；n == 2时返回2（两种走法：1+1或2）。
递归关系：爬到第n阶的走法数 = 爬到第n-1阶的走法数 + 爬到第n-2阶的走法数。
计算并输出爬1到10阶楼梯的走法数。

【生活案例】

• 1阶 + 1阶 + 1阶
• 1阶 + 2阶
• 2阶 + 1阶

【输出示例】

=== 基础递归版本 ===
爬1阶楼梯有 1 种走法
爬2阶楼梯有 2 种走法
爬3阶楼梯有 3 种走法
爬4阶楼梯有 5 种走法
爬5阶楼梯有 8 种走法
爬6阶楼梯有 13 种走法
爬7阶楼梯有 21 种走法
爬8阶楼梯有 34 种走法
爬9阶楼梯有 55 种走法
爬10阶楼梯有 89 种走法

试题30：迷宫寻宝游戏（回溯算法）

【题目描述】

在一个5×5的数字迷宫中，从起点(0,0)出发，使用回溯算法寻找一条到达宝藏（值为9）的路径。0为道路，1为墙壁，不能重复走。

【题目要求】

定义迷宫地图（二维列表）。
实现递归回溯函数find_treasure，参数为当前位置(x, y)和当前路径列表。
函数需检查边界、墙壁和重复访问。
若找到宝藏，返回True；否则依次尝试四个方向（右、下、左、上）进行递归探索。
若所有方向都不通，则回溯（返回False）。
使用字符图案可视化显示迷宫和探索路径。
输出完整的探索过程及最终结果。

【题目说明】

关键技巧：使用递归来自动”返回”到上一个位置，用列表记录走过的路径。

# 创建迷宫地图
# 0 = 道路, 1 = 墙壁, 9 = 宝藏
maze = [
[0, 0, 1, 0, 0],
[0, 1, 1, 0, 0],
[0, 0, 0, 0, 0],
[1, 1, 0, 1, 0],
[0, 0, 0, 0, 9]
]

【输出示例】

============================================================
           迷宫寻宝游戏 - 回溯算法大冒险 
============================================================
规则：从起点(0,0)出发，找到宝藏🎁！
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径
============================================================

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

🟦 🟦 🟫 🟦 🟦 
🟦 🟫 🟫 🟦 🟦 
🟦 🟦 🟦 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

🚀 开始冒险！从起点 (0, 0) 出发...
============================================================
走到位置 (0, 0)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
🟦 🟫 🟫 🟦 🟦 
🟦 🟦 🟦 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
走到位置 (0, 1)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 👣 🟫 🟦 🟦 
🟦 🟫 🟫 🟦 🟦 
🟦 🟦 🟦 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
↓ 向下走
← 向左走
↑ 向上走
❌ 位置 (0, 1) 是死路，需要回溯
↓ 向下走
走到位置 (1, 0)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
🟦 🟦 🟦 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
↓ 向下走
走到位置 (2, 0)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 🟦 🟦 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
走到位置 (2, 1)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 👣 🟦 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
走到位置 (2, 2)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 👣 👣 🟦 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
走到位置 (2, 3)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 👣 👣 👣 🟦 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
走到位置 (2, 4)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 👣 👣 👣 👣 
🟫 🟫 🟦 🟫 🟦 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
↓ 向下走
走到位置 (3, 4)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 👣 👣 👣 👣 
🟫 🟫 🟦 🟫 👣 
🟦 🟦 🟦 🟦 🎁 

→ 向右走
↓ 向下走
走到位置 (4, 4)

当前迷宫状态：
🟦: 道路  🟫: 墙壁  🎁: 宝藏  👣: 你的路径

👣 🟦 🟫 🟦 🟦 
👣 🟫 🟫 🟦 🟦 
👣 👣 👣 👣 👣 
🟫 🟫 🟦 🟫 👣 
🟦 🟦 🟦 🟦 👣 

太棒了！找到宝藏啦！
冒险成功！你找到了宝藏！

游戏结束！你学会了回溯算法！

未来科技大师（高级组-冠亚季军选拔赛）

冠军题库 亚军题库 季军题库 在线练习

❀ 冠 军 题 库（共30题）❀ 返回最前

试题1：单词拼写检查器

试题2：迷宫探险家（栈与回溯算法）

试题3：班级值日生轮换表（循环队列）

试题4：迷宫最短路径算法（二维数组与BFS）

试题5：词频统计工具（字典与Counter）

试题6：关键词过滤系统（集合高效查找）

试题7：迷宫出口探测算法（多维线性查找）

试题8：手机通讯录联系人查找系统（二分查找）

试题9：超市水果价格排序（选择排序）

试题10：水质监测数据波动分析（冒泡排序与滑窗算法）

试题11：音乐播放列表智能推荐（链表与插入排序）

试题12：运动会成绩排名（快速排序）

试题13：校园导航最短路径（Dijkstra算法）

试题14：消防员救援任务（BFS最短步数）

试题15：数独游戏求解器（DFS回溯算法）

试题16：电力网络冗余线路检测（最小生成树）

试题17：知识问答系统索引（字典树Trie）

试题18：城市供水管网与最大流问题（图的最大流）

试题19：用游乐园快速通行证问题学习贪心算法

试题20：野餐食物选择 – 多维背包问题

试题21：网格最小路径规划

试题22：篮球赛程价值最大化 – 带权区间调度

试题23：零食分享配对 – 最长公共子序列

试题24：迷宫游戏地图—稀疏矩阵应用

试题25：校园寻宝游戏 – 二维分治算法

试题26：交通灯配时优化 – 滑动窗口

试题27：游戏装备合成优先级系统 – 堆排序

试题28：零花钱记账本 – 前缀和与差分

试题29：汉诺塔问题 – 递归算法

试题30：N皇后问题 – 回溯算法

❀ 亚 军 题 库（共30题）❀ 返回最前

试题1：考试成绩统计分析——列表遍历与统计

试题2：括号匹配检测器——栈的应用

试题3：银行叫号系统——多队列管理

试题4：课间操站位网格——二维数组管理队列位置

试题5：学生成绩管理系统——嵌套字典

试题6：抽奖系统去重——集合唯一性

试题7：单词拼写检查器——线性查找与时间复杂度

试题8：图书馆找书系统——二分查找算法

试题9：垃圾分类助手——多属性选择排序

试题10：停车场车牌排序系统——冒泡排序

试题11：直播礼物实时排行榜——插入排序优化

试题12：电商商品多条件筛选——快速排序的高级应用

试题13：地铁最短路线规划——Dijkstra算法

试题14：用社交网络学习BFS和三度人脉算法

试题15：校园谣言传播——有向图可达性分析（DFS/BFS）

试题16：乐高城堡稳固结构与最小生成树

试题17：用学校组织学习广度优先搜索

试题18：旅游景点路线规划与最短路径

试题19：用兴趣班时间安排学习贪心算法

试题20：暑假各科分数提升与时间分配——分组背包问题

试题21：吃糖果大冒险——探索动态规划

试题22：教室借用安排——区间分组

试题23：乐高拼写游戏——字符串DP

试题24：电子宠物社交系统——社交网络图结构

试题25：乐高城堡建造——分治算法

试题26：用滑动窗口统计游戏连击技能伤害

试题27：用医院急诊分诊学习堆排序

试题28：灯泡开关谜题——位运算

试题29：家族辈分关系​-递归树形结构

试题30：特工任务破解密码锁——回溯算法

❀ 季 军 题 库（共30题）❀ 返回最前

试题1：购物清单管理系统

试题2：浏览器后退功能模拟系统

试题3：打印机任务调度系统

试题4：教室座位表管理系统

试题5：单词翻译器

试题6：好友共同兴趣查找器

试题7：图书馆找书系统

试题8：字典单词快速查询

试题9：运动会成绩排行榜

试题10：班级身高排队系统

试题11：扑克牌整理小游戏

试题12：学校食堂快速分餐系统

试题13：校园快递最优配送路线

试题14：走迷宫最短步数求解

冠军题库亚军题库季军题库在线练习

❀ 冠军题库（共30题）❀ 返回最前

❀ 亚军题库（共30题）❀ 返回最前

试题29：家族辈分关系-递归树形结构

❀ 季军题库（共30题）❀ 返回最前