52 lines
73 KiB
Python
52 lines
73 KiB
Python
import openai
|
||
import time
|
||
import re
|
||
|
||
model = "Qwen/Qwen3-8B"
|
||
max_tokens = 500
|
||
|
||
output_format = """
|
||
score:
|
||
reason:
|
||
"""
|
||
|
||
def getDim(content, dim):
|
||
client = openai.OpenAI(base_url='https://api.siliconflow.cn/v1',
|
||
api_key="xxx")
|
||
time.sleep(3)
|
||
messages = []
|
||
messages.append({
|
||
"role": "system",
|
||
"content": "你是一位评分老师，请根据提供给你的评分标准对文本进行评分，结果仅仅输出分数，不需要任何解释"
|
||
"输出格式："
|
||
f"{output_format}"
|
||
|
||
})
|
||
messages.append({
|
||
"role": "user",
|
||
"content": f"待评分内容：{content}"
|
||
f"评分标准：{dim}"
|
||
})
|
||
response = client.chat.completions.create(
|
||
model=model,
|
||
messages=messages,
|
||
max_tokens=max_tokens,
|
||
temperature=0.1
|
||
)
|
||
|
||
# print(response.choices[0].message.content)
|
||
# match = re.search(r'\d+', response.choices[0].message.content)
|
||
# if match:
|
||
# score = match.group()
|
||
# else:
|
||
# score = response.choices[0].message.content
|
||
# print(score)
|
||
return response.choices[0].message.content
|
||
|
||
if __name__ == "__main__":
|
||
content = """
|
||
项目实践：迷宫游戏实现 \n211370106 沈钰舒 难度五\n1 问题描述 \n迷宫介绍：\n假设一个迷宫的示意图如下，其中的每个方块用空白表示通道，用阴影表示障碍物。入口在左上角，出\n口在右下角。\n为了表示迷宫，设置一个数组 M*N 的二维数组 , 其中每个元素表示一个方块的状态，为 1 时表示对应方块\n是通道，为 0 时表示对应方块是障碍物 ( 不可走 ) ，或者相反。\n求迷宫问题就是在一个指定的迷宫中求出从入口到出口的一条路径。在求解时采用 “ 穷举法 ” ，即从入口出\n发依次试探相邻的方块，一且找到一个可走的相邻方块就继续走下去 , 并记下所走的方位。两个方块有公\n共边称为相邻。\n难度五\n使用不超过 2x100x100 的三维数组模拟两层楼迷宫，支持多出口、楼梯和自定义楼梯距离，输出最短的\n行走路径或 “ 无解 ” 。\n等级 5的出口可参考以下范例输入：\n2\n1 3 5\n0 10 39\n表示有 2个出口，分别在二楼的（ 3,5 ）和一楼的（ 10,39 ）坐标处\n等级 5的楼梯可参考以下范例输入：\n2\n8 9 3\n15 27 2\n表示有 2个楼梯，位置（ 8,9 ）的楼梯可以从 (0,8,9) 处到达（ 1,8,9 ），距离为 3 ；位置（ 15,27 ）的楼梯可\n以从 (0,15,27) 处到达（ 1,15,27 ），距离为 2 。\n轮\n次提问 回复 思考及行动\n1问题等效，交\n代问题描述等效成图论中的路径搜\n索问题，提示了需要处\n理额外的维度和多个目\n标节点理解了问题的核心，决定使用图论的算法来\n完成该程序的实现\n2提问图论所推\n荐的算法推荐了五种图论中的算\n法，详细描述了优缺\n点，均在课内知识覆盖\n之内针对不同通道有不同的通过成本或距离，决\n定采取迪杰特斯拉算法\n3提问该题中迪\n杰特斯拉算法\n的核心函数提供了核心函数的伪代\n码该代码描述了迪杰特斯拉算法，即将迷宫上\n下左右的相邻格子等效为边长为 1 连接的\n点，楼梯连接的两个格子等效为边长为 n\n（指定值）连接的点\n4要求拆解为精\n确的具体步骤将整个程序的实现拆解\n为了具体的七步明确了设计数据结构、输入迷宫数据、实现\n核心函数算法、调用该算法、处理错误和边\n界检查这些步骤，可以以此逐步实现\n轮\n次提问 回复 思考及行动\n1要求实现步骤一：\n设计和设置数据结\n构提供了数据结构部分的代码，\n包括：迷宫数组、楼梯信息、\n出口信息结构明确，三维数组来存储每个位\n置是通道还是障碍，楼梯信息将存\n储起始层、起始行、起始列、目标\n层和楼梯距离，出口信息只需存储\n层、行和列，对应题目要求的输入\n2要求实现步骤二：\n输入迷宫数据，特\n别要求使用 txt 文\n件方式输入定义一个明确的文件格式来描\n述迷宫的布局、楼梯信息以及\n出口位置，使用标准输入输出\n库（fstream）实现检查了文件格式的设计符合题目要\n求的输入，且涵盖了数据结构所需\n的全部信息\n3要求实现步骤三：\n实现 Dijkstra 算法在整体思路设计的基础上，结\n合数据结构的定义，实现了具\n体的算法代码使用一个优先队列作为辅助，来保\n证每次都处理当前最短未处理路\n径，同时确认了代码处理了邻近节\n点、楼梯、出口的情况，符合逻辑2 概要 \n2.1 整体思路设计 \n整体思路设计阶段包含 4 轮交互，交互过程概述如下\n2.2 代码实现 \n代码实现共包含 5 轮交互，交互过程概述如下：\n轮\n次提问 回复 思考及行动\n4要求实现步骤四：\n搜索和输出最短路\n径修改主函数以实现搜索和输出在主函数中调用了处理文件输入的\n函数、 Dijkstra 函数，从 0 ， 0 ， 0\n开始进行遍历\n5要求实现步骤五：\n错误处理和边界条\n件检查添加了对文件读取失败、输入\n数据无效、数组越界等多种潜\n在错误的检查逐行阅读，确认覆盖到了常见的一\n场情况，将以上代码整合为完整的\n代码，放入 vscode 中 build 成功未\n见报错，开始进入测试\n6要求实现额外步\n骤：当找到出口\n时，打印输出该条\n路径全部节点以便\n观察添加了找到出口时打印路径的\n代码为了保证最短路径的正确性，我主\n动要求添加方便观测寻找路径过程\n的代码，以防无法及时看出较为复\n杂的寻路过程。\n轮\n次提问 回复 思考及行动\n1询问应该拟定\n哪几种数据、\n覆盖到哪几种\n情况来测试代\n码给出了四类需要\n测试的大方向以此为指导，开始逐一设计测试用例、预测预期输\n出、运行程序、检查实际输出。由于迷宫算法的过\n程较为复杂，为了完整展示每一步过程来观察算法\n的运行情况，决定将针对各种情况的每一个测试用\n例单独列出进行分析对比。\n2针对基本功能\n测试的测试用\n例设计提供了单层小迷\n宫和两层小迷宫\n的测试用例运行了测试用例，发现代码缺少对于单层迷宫输入\n的标记，会将后续的输入信息视为第二层迷宫，故\n要求修改了输入逻辑，允许输入层数来决定此次输\n入迷宫的层数。修改后成功运行得到了预期结果，\n证明抵达出口、使用楼梯的基本功能测试通过\n3针对边界条件\n测试的测试用\n例设计提供了空迷宫、\n迷宫全是障碍、\n迷宫无出口、迷\n宫出口不可达的\n测试用例实际上该四种测试用例本质上都是为了测试 “ 无法\n抵达出口 ” 的情况，初次测试后发现迷宫出口不可\n达的程序意外中断，检查后发现是 gpt 提供的输入\n格式有误，将出口输入的层数漏了，更正后顺利执\n行，测试通过\n4针对特殊逻辑\n测试的测试用\n例设计提供了多楼梯连\n接、楼梯循环、\n楼梯直接通向出\n口的测试用例该部分的测试用例针对了楼梯的使用在整个图中的\n影响，设计了较为复杂的楼梯使用情况。由于提前\n要求了打印路径输出的函数，根据每一次找到出口\n时返回打印的路径，能够清晰观测到路径的走向和\n不同 cost 的对比。2.3 测试与调试 \n测试与调试阶段包含 ** 轮交互，交互过程概述如下：\n轮\n次提问 回复 思考及行动\n5性能测试提供了大迷宫的\n测试用例输入格\n式（迷宫过大无\n法直接给出）自行靠复制粘贴完成了通路完整的大迷宫的 txt 输入\n文件，用人类智能取代人工智能预测了预期输出，\n运行后输出一致\n3 设计实现与交互过程 \n3.1 设计思路 \nQ1：请你阅读这题，这道题可以等效成什么问题？\n这个迷宫问题可以等效成图论中的路径搜索问题。具体地，可以将迷宫视为一个由节点（方块）和\n边（方块之间的连接）组成的图。在这个图中，节点可以代表迷宫中的每个可走的方块，边则代表\n方块之间的可走的通路。路径搜索问题就是要在这个图中找到从起点（迷宫入口）到终点（迷宫出\n口）的一条路径。\n在计算机科学中，这个问题通常可以使用深度优先搜索（ DFS ）或者广度优先搜索（ BFS ）等算法\n来解决。在这个迷宫问题的上下文中，如果要找到最短路径，则可以采用 BFS ，因为它可以在无权\n图中找到从起点到终点的最短路径。\n另外，由于题目中提到了楼梯和多个出口，这就增加了图的复杂度，因为你需要处理额外的维度\n（楼层）和多个目标节点（出口）。这可能需要对标准的 BFS 或 DFS 算法进行适当的修改或扩展。\n例如，可以使用 Dijkstra 算法或 A* 搜索算法来找到最短路径，尤其是在考虑楼层跳转和多出口的情\n况下。\n说明\n等效成抽象的数据结构，将方方正正的迷宫和堆叠的楼层统一处理成边权重不同的顶点，理解了问\n题的核心，决定使用图论的算法来完成该程序的实现\nQ2：你推荐使用哪些方法来进行路径搜索？\n对于迷宫问题，尤其是涉及寻找最短路径的情况，有几种常用的搜索算法可以使用。每种方法都有\n其优缺点，适用于不同的场景和需求。以下是几种推荐的方法：\n1. 广度优先搜索 (BFS) \n广度优先搜索（ BFS ）是解决此类问题的最直接和最常用的方法，尤其适用于在未加权的图中寻找\n最短路径。 BFS 从起点开始，逐层探索所有邻居节点，直到找到终点或探索完所有节点。\n优点：直接找到最短路径，易于实现。\n缺点：在广阔空间中可能会消耗大量内存。\n2. 深度优先搜索 (DFS) \n深度优先搜索（ DFS ）是一种利用递归或栈实现的搜索技术，它沿着一条路径深入探索，直到无法\n继续为止，然后回溯到上一个分叉点继续探索其他路径。\n优点：内存消耗相对较少。\n缺点：不保证找到最短路径，且在大型迷宫中可能非常慢。\n3. A* 搜索算法 \nA*算法是一种效率较高的路径搜索算法，通过使用启发式函数来估计从当前节点到目标节点的最佳\n路径。它结合了 BFS 的全面性和贪心算法的效率。\n优点：在大多数情况下能迅速找到最短路径，效率高。\n缺点：需要一个合适的启发式函数来保证性能和准确性。\n4. 双向搜索 \n双向搜索是从起点和终点同时开始搜索，直到两个搜索相遇。这种方法可以大大减少搜索空间，从\n而加快搜索速度。\n优点：在理想情况下可以显著减少搜索时间。\n缺点：实现复杂，需要维护两个搜索队列。\n5. 迪杰斯特拉算法 (Dijkstra's Algorithm) \n如果迷宫的不同通道有不同的通过成本或距离，迪杰斯特拉算法可以找到从起点到所有其他节点的\n最短路径。\n优点：能处理带权重的图。\n缺点：在非加权图中比 A* 或 BFS 更慢。\n说明\n通过 gpt的总结，五种不同的图论算法中，针对不同通道有不同的通过成本或距离，决定采取迪杰特\n斯拉算法\nQ：考虑到楼梯存在长度，我认为将整个迷宫和楼梯视为图来处理是一个好的方法，我希望使用迪杰斯特\n拉算法 (Dijkstra's Algorithm) ，为我提供核心函数\n使用迪杰斯特拉算法（ Dijkstra's Algorithm ）处理带有楼梯距离的多层迷宫是个合理选择，尤其当\n楼梯距离作为权重时。迪杰斯特拉算法能有效地处理带权图中的最短路径问题。下面提供一个\nC++实现的核心函数示例，假设我们的迷宫是一个二维数组，每层的迷宫通过额外的楼梯信息连\n接。\n假设数据结构 \n1. int maze[2][M][N] - 表示两层迷宫，其中 1代表通道， 0代表障碍。\n2. vector<tuple<int, int, int, int, int>> stairs - 楼梯信息，格式为： ( 开始层 , 行 , \n列, 目标层 , 距离 ) 。\n3. vector<pair<int, int>> exits - 出口信息，格式为： ( 层 , 行 , 列 ) 。\nDijkstra 算法的核心函数 \n下面是使用 Dijkstra 算法计算从入口到最近出口的最短路径的 C++ 代码：\n#include <iostream>\n#include <vector>\n#include <queue>\n#include <tuple>\n#include <limits>\n#include <algorithm>\nusing namespace std;\nconst int MAX_M = 100; // 最大行\nconst int MAX_N = 100; // 最大列\nint maze[2][MAX_M][MAX_N];\nvector<tuple<int, int, int, int, int>> stairs;\nvector<pair<int, int>> exits;\nstruct Node {\n int layer, row, col, cost;\n bool operator>(const Node& other) const {\n return cost > other.cost;\n }\n};\n// 使用Dijkstra 算法找到从入口到最近出口的最短路径\nint dijkstra(int start_layer, int start_row, int start_col) {\n priority_queue<Node, vector<Node>, greater<Node>> pq;\n vector<vector<vector<int>>> dist(2, vector<vector<int>>(MAX_M, \nvector<int>(MAX_N, numeric_limits<int>::max())));\n pq.push({start_layer, start_row, start_col, 0});\n dist[start_layer][start_row][start_col] = 0;\n while (!pq.empty()) {\n Node current = pq.top();\n pq.pop();\n if (find(exits.begin(), exits.end(), make_pair(current.layer, \ncurrent.row, current.col)) != exits.end()) {\n return current.cost; // 找到出口\n }\n // 检查四个方向\n int directions[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};\n for (auto& dir : directions) {\n int new_row = current.row + dir[0];\n int new_col = current.col + dir[1];\n if (new_row >= 0 && new_row < MAX_M && new_col >= 0 && new_col < \nMAX_N && maze[current.layer][new_row][new_col] == 1) {\n int new_cost = current.cost + 1;\n if (new_cost < dist[current.layer][new_row][new_col]) {\n dist[current.layer][new_row][new_col] = new_cost;\n pq.push({current.layer, new_row, new_col, new_cost});\n }\n }\n }\n // 检查楼梯\n for (auto& stair : stairs) {\n int slayer, srow, scol, tlayer, tdist;\n tie(slayer, srow, scol, tlayer, tdist) = stair;\n if (slayer == current.layer && srow == current.row && scol == \ncurrent.col) {\n int new_cost = current.cost + tdist;\n if (new_cost < dist[tlayer][srow][scol]) {\n dist[tlayer][srow][scol] = new_cost;\n pq.push({tlayer, srow, scol, new_cost});\n }\n }\n }\n }\n return -1; // 如果没有找到任何出口\n}\n这个函数可以作为你迷宫解决方案的核心部分，根据具体需要调整和优化。\n说明\n该代码描述了迪杰特斯拉算法的基础，包括存储迷宫、楼梯和出口的信息的结构，使用\npriority_queue来优化搜索过程，确保总是先处理当前成本最低的节点，对于每个节点，程序检查\n上、下、左、右四个方向以及可能的楼梯连接，将符合条件的新节点加入队列中，当遇到出口时返回当\n前路径成本，如果无法到达任何出口，则返回 -1。\n已经初具核心，接下来就要完成它的具体实现和输入问题，我决定逐步完成。\n3.2 步骤拆解 \nQ1：我希望使用 Dijkstra 算法来寻找这个问题的最短路径。为了解决这个问题，请为我将它拆解为精确\n的具体步骤，我该如何逐步实现完成它？\n要实现一个使用迪杰斯特拉算法来解决两层楼迷宫问题的程序，你可以按照以下步骤逐步进行：\n步骤 1: 设计和设置数据结构 \n迷宫数组 ：定义一个三维数组 int maze[2][M][N]，其中 M 和 N 是迷宫的行和列。\nmaze[l][r][c] 的值为 1 表示通道，值为 0 表示障碍。\n楼梯信息 ：创建一个结构体或使用 vector<tuple<int, int, int, int, int>> 来存储楼\n梯信息，每个元组包含：起始层、起始行、起始列、目标层、距离。\n出口信息 ：使用 vector<pair<int, int>> 存储出口信息，每个对包含层、行、列。\n步骤 2: 输入迷宫数据 \n提供接口读取迷宫大小、迷宫布局、出口数量及位置和楼梯数量及细节。\n确保数据输入合法，如数组索引不超出界限等。\n步骤 3: 实现 Dijkstra 算法 \n初始化：创建距离数组 vector<vector<vector<int>>> dist，初始化为极大值，除了起\n点设为 0。\n优先队列 ：使用优先队列（最小堆）来存储和排序探索的节点，优先探索代价最小的节点。\n探索邻居 ：对于每个节点，检查其四个方向的邻居（如果在迷宫内且为通道）。如果通过当前\n节点到达邻居节点的总成本更低，更新邻居节点的成本并将其加入队列。\n处理楼梯 ：同样地，检查当前节点是否有楼梯连接到另一层的节点，如果是，并且使用楼梯到\n达的总成本更低，更新对应节点的成本并加入队列。int main() {\n // 这里应该初始化 maze, stairs, exits\n // Example call\n cout << \"最短路径长度 : \" << dijkstra(0, 0, 0) << endl;\n return \n0;\n}\n步骤 4: 搜索和输出最短路径 \n运行 Dijkstra 算法从起点开始，不断探索直到找到任一出口或所有可达节点都被探索完毕。\n输出从起点到最近出口的最短路径成本，或者如果找不到路径则输出 “ 无解 ” 。\n步骤 5: 错误处理和边界条件检查 \n确保处理所有可能的边界条件，例如迷宫全是障碍物、没有出口、出口或楼梯位置错误等。\n检查输入数据的有效性，确保不会引起程序崩溃。\n步骤 6: 测试和验证 \n对你的程序进行单元测试，确保它可以正确处理各种边界情况和复杂情况。\n进行集成测试，检查整个程序是否按预期工作，包括数据输入、算法执行和输出结果。\n按照上述步骤逐步开发和完善你的迷宫求解程序，可以确保系统性和全面性，避免遗漏关键功能或\n错误处理。\n4 代码实现 \n4.1 设计和设置数据结构 \n迷宫数组 ：定义一个三维数组 int maze[2][M][N]，其中 M 和 N 是迷宫的行和列。 maze[l][r]\n[c] 的值为 1 表示通道，值为 0 表示障碍。\n楼梯信息 ：创建一个结构体或使用 vector<tuple<int, int, int, int, int>> 来存储楼梯信\n息，每个元组包含：起始层、起始行、起始列、目标层、距离。\n出口信息 ：使用 vector<pair<int, int>> 存储出口信息，每个对包含层、行、列。\n为了实现一个基于迪杰斯特拉算法的两层楼迷宫解决方案，我们首先需要设置适当的数据结构来存\n储迷宫、楼梯和出口信息。下面是使用 C++ 语言定义的数据结构的详细实现：\n1. 迷宫数组 \n我们需要一个三维数组来存储每个位置是通道还是障碍。\n2. 楼梯信息 \n楼梯信息将存储起始层、起始行、起始列、目标层和楼梯距离。\n3. 出口信息 \n出口信息只需存储层、行和列。\n下面是这些数据结构的具体实现：\n#include <iostream>\n#include <vector>\n#include <tuple>\n// 假设迷宫的最大尺寸\nconst int MAX_LAYERS = 2; // 两层楼\nconst int MAX_M = 100; // 最大行数\nconst int MAX_N = 100; // 最大列数\n// 迷宫数组，其中 maze[layer][row][col] = 1 表示通道， 0 表示障碍\nint maze[MAX_LAYERS][MAX_M][MAX_N];\n// 楼梯信息， tuple 格式为： ( 起始层 , 起始行 , 起始列 , 目标层 , 楼梯距离 )\nstd::vector<std::tuple<int, int, int, int, int>> stairs;\n// 出口信息， pair 格式为： ( 层 , 行 , 列 )\nstd::vector<std::pair<int, int>> exits;\n// 用于初始化迷宫的功能函数\nvoid initializeMaze() {\n // 假设我们已经知道迷宫的布局，这里是初始化迷宫的代码\n // 例如，设置全部为障碍，然后手动设置通道\n for (int l = 0; l < MAX_LAYERS; ++l) {\n for (int r = 0; r < MAX_M; ++r) {\n for (int c = 0; c < MAX_N; ++c) {\n maze[l][r][c] = 0; // 默认设置为障碍\n以上代码定义了迷宫的基本结构和一些辅助函数来初始化和配置迷宫、楼梯和出口。这是构建迷宫\n问题解决方案的基础，接下来你可以在此基础上实现 Dijkstra 算法和其他逻辑。\n说明\n定义结构明确，三维数组来存储每个位置是通道还是障碍，楼梯信息将存储起始层、起始行、起始\n列、目标层和楼梯距离，出口信息只需存储层、行和列，对应题目要求的输入。\n4.2 输入迷宫数据 \n提供接口读取迷宫大小、迷宫布局、出口数量及位置和楼梯数量及细节。\n确保数据输入合法，如数组索引不超出界限等。\nQ：在以上的基础上，完成步骤 2: 输入迷宫数据，我希望使用 txt 文件输入，为我指定 txt 文件需要的格\n式，并提供将它输入的代码\n为了从文本文件读取迷宫数据，我们需要定义一个明确的文件格式来描述迷宫的布局、楼梯信息以\n及出口位置。以下是一个示例的文件格式以及如何用 C++ 读取这些数据。 }\n }\n }\n // 假设设置一些通道，具体的设置根据实际需要调整\n maze[0][0][0] = 1; // 例如设置入口处为通道\n maze[1][99][99] = 1; // 假设右下角为出口处的通道\n}\n// 用于添加楼梯的功能函数\nvoid addStair(int from_layer, int from_row, int from_col, int to_layer, int \ndistance) {\n stairs.push_back(std::make_tuple(from_layer, from_row, from_col, to_layer, \ndistance));\n}\n// 用于添加出口的功能函数\nvoid addExit(int layer, int row, int col) {\n exits.push_back(std::make_pair(layer, row, col));\n}\nint main() {\n // 初始化迷宫\n initializeMaze();\n // 添加楼梯示例\n addStair(0, 10, 10, 1, 5); // 从第一层的 (10, 10) 到第二层的 (10, 10) ，距离为 5\n // 添加出口示例\n addExit(1, 99, 99); // 在第二层的 (99, 99) 处添加一个出口\n // 你的其他代码和函数调用\n return 0;\n}\n文件格式规范 \n示例文件内容 \n代码实现 \n使用 C++ 读取此格式的文件，你可以使用标准输入输出库（ fstream）。I M N // 迷宫的层数、行数和列数\n// 接下来 M*N*2 行，每行代表每一层每个位置的状态（ 0 或 1 ）\n[Layer 1]\n0 1 1 0 ... ( 总共 N 个数字 )\n...\n[M 行]\n[Layer 2]\n0 0 1 1 ... ( 总共 N 个数字 )\n...\n[M 行]\nE // 出口数量\nlayer row col // 出口层和坐标\n...\n[E 行]\nS // 楼梯数量\nfrom_layer from_row from_col to_layer to_row to_col distance // 楼梯信息\n...\n[S 行]\n2 3 3\n1 1 1\n1 0 1\n1 1 1\n1 1 0\n0 0 1\n1 1 1\n2\n0 2 2\n1 0 2\n2\n0 1 1 1 1 1 3\n1 2 2 0 2 2 2\n#include <iostream>\n#include <fstream>\n#include <vector>\n#include <tuple>\n#include <sstream>\nconst int MAX_LAYERS = 2;\nint maze[MAX_LAYERS][100][100]; // 假设一个较大的固定尺寸，也可以根据实际情况动态分\n配\nstd::vector<std::tuple<int, int, int, int, int, int, int>> stairs;\nstd::vector<std::tuple<int, int, int>> exits;\n这段代码首先定义了迷宫数组、楼梯和出口的向量。 readMazeData 函数从指定的文件名读取数\n据，将其存储在全局数据结构中。注意这里没有处理动态尺寸迷宫，你可能需要根据具体情况调整\n数组的大小或使用动态数据结构如 std::vector。\n说明\n检查了文件格式的设计符合题目要求的输入，且涵盖了数据结构所需的全部信息，void readMazeData(const std::string& filename) {\n std::ifstream file(filename);\n if (!file.is_open()) {\n std::cerr << \"Failed to open file.\\n\";\n return;\n }\n int M, N;\n file >> M >> N;\n for (int l = 0; l < MAX_LAYERS; ++l) {\n for (int r = 0; r < M; ++r) {\n for (int c = 0; c < N; ++c) {\n file >> maze[l][r][c];\n }\n }\n }\n int E;\n file >> E;\n int layer, row, col;\n for (int i = 0; i < E; ++i) {\n file >> layer >> row >> col;\n exits.push_back(std::make_tuple(layer, row, col));\n }\n int S;\n file >> S;\n int from_layer, from_row, from_col, to_layer, to_row, to_col, distance;\n for (int i = 0; i < S; ++i) {\n file >> from_layer >> from_row >> from_col >> to_layer >> to_row >> \nto_col >> distance;\n stairs.push_back(std::make_tuple(from_layer, from_row, from_col, \nto_layer, to_row, to_col, distance));\n }\n file.close();\n}\nint main() {\n std::string filename = \"maze_data.txt\";\n readMazeData(filename);\n // 这里可以添加代码以验证迷宫数据或进一步处理\n return 0;\n}\n4.3 实现 Dijkstra 算法 \n初始化：创建距离数组 vector<vector<vector<int>>> dist，初始化为极大值，除了起点设为\n0。\n优先队列 ：使用优先队列（最小堆）来存储和排序探索的节点，优先探索代价最小的节点。\n探索邻居 ：对于每个节点，检查其四个方向的邻居（如果在迷宫内且为通道）。如果通过当前节点\n到达邻居节点的总成本更低，更新邻居节点的成本并将其加入队列。\n处理楼梯 ：同样地，检查当前节点是否有楼梯连接到另一层的节点，如果是，并且使用楼梯到达的\n总成本更低，更新对应节点的成本并加入队列。\n继续我们的迷宫问题解决方案，我们将实现 Dijkstra 算法来找到从迷宫的入口到出口的最短路径。\n我们已经设置了读取迷宫、楼梯和出口数据的函数，下一步是实现 Dijkstra 算法。\n实现 Dijkstra 算法 \n我们将创建一个 dijkstra 函数，这个函数将使用一个优先队列来保证每次都处理当前最短未处\n理路径。这里，我们将使用 C++ 的 priority_queue 和其他标准库组件。\n#include <iostream>\n#include <vector>\n#include <queue>\n#include <tuple>\n#include <climits> // For INT_MAX\n// 节点定义\nstruct Node {\n int layer, row, col, cost;\n bool operator>(const Node& other) const {\n return cost > other.cost;\n }\n};\n// 优先队列，用于 Dijkstra 算法\nstd::priority_queue<Node, std::vector<Node>, std::greater<Node>> pq;\n// 距离矩阵\nint dist[MAX_LAYERS][100][100]; // 注意这里使用静态数组大小，可以根据需求调整\n// Dijkstra 算法实现\nvoid dijkstra(int start_layer, int start_row, int start_col) {\n // 初始化距离数组为最大值\n for (int l = 0; l < MAX_LAYERS; ++l) {\n for (int r = 0; r < 100; ++r) { // 假设最大尺寸为 100x100\n for (int c = 0; c < 100; ++c) {\n dist[l][r][c] = INT_MAX;\n }\n }\n }\n // 开始节点距离为 0\n dist[start_layer][start_row][start_col] = 0;\n pq.push({start_layer, start_row, start_col, 0});\n // 方向数组，表示四个可能的移动方向（上下左右）\n const int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};\n while (!pq.empty()) {\n Node current = pq.top();\n pq.pop();\n if (current.cost > dist[current.layer][current.row][current.col]) \ncontinue;\n // 检查四个方向的相邻节点\n for (int i = 0; i < 4; ++i) {\n int next_row = current.row + dir[i][0];\n int next_col = current.col + dir[i][1];\n if (next_row >= 0 && next_row < 100 && next_col >= 0 && next_col < \n100 && maze[current.layer][next_row][next_col] == 1) {\n int next_cost = current.cost + 1; // 步行代价为 1\n if (next_cost < dist[current.layer][next_row][next_col]) {\n dist[current.layer][next_row][next_col] = next_cost;\n pq.push({current.layer, next_row, next_col, next_cost});\n }\n }\n }\n // 检查是否有楼梯连接\n for (const auto& stair : stairs) {\n int from_layer, from_row, from_col, to_layer, to_row, to_col, \nstair_cost;\n std::tie(from_layer, from_row, from_col, to_layer, to_row, to_col, \nstair_cost) = stair;\n if (from_layer == current.layer && from_row == current.row && \nfrom_col == current.col) {\n int next_cost = current.cost + stair_cost;\n if (next_cost < dist[to_layer][to_row][to_col]) {\n dist[to_layer][to_row][to_col] = next_cost;\n pq.push({to_layer, to_row, to_col, next_cost});\n }\n }\n }\n }\n}\nint main() {\n std::string filename = \"maze_data.txt\";\n readMazeData(filename);\n // 假设迷宫入口是 (0, 0, 0)\n dijkstra(0, 0, 0);\n // 假设输出到某个出口的最短距离\n for (const auto& exit : exits) {\n int layer, row, col;\n std::tie(layer, row\n, col) = exit;\n if (dist[layer][row][col] != INT_MAX) {\n说明 \n1. 初始化：我们设置所有点的距离为无限大（ INT_MAX），除了起点的距离设为 0 。\n2. 优先队列 ：使用优先队列处理节点，始终先处理当前成本最低的节点。\n3. 邻居处理 ：检查每个节点的四个方向是否可通行，并更新距离。\n4. 楼梯处理 ：检查当前节点是否有楼梯连接到另一层的节点，如果是，更新距离并加入队列。\n这段代码应该可以为你提供一个从入口到出口的最短路径解决方案的完整实现。\n说明\n在之前核心函数 d 基础上，结合数据结构的定义，实现了具体的算法代码。\n4.4 搜索和输出最短路径 \n运行 Dijkstra 算法从起点开始，不断探索直到找到任一出口或所有可达节点都被探索完毕。\n输出从起点到最近出口的最短路径成本，或者如果找不到路径则输出 “ 无解 ” 。\n在前面的代码中，我们已经实现了 Dijkstra 算法的主要部分，并设置了节点的成本更新。现在，我\n们将完成最后一步：运行 Dijkstra 算法，找到最近的出口，并输出从起点到最近出口的最短路径成\n本。如果找不到可行的路径，我们将输出 “ 无解 ” 。\n实现搜索和输出最短路径 \n我们已经有了迷宫、楼梯和出口的信息，并能使用 Dijkstra 算法计算最短路径。现在，我们将确保\n算法可以输出从起点到最近出口的最短路径成本，并正确处理无解的情况。\n修改主函数以实现搜索和输出 std::cout << \"Shortest path to exit (\" << layer << \", \" << row << \n\", \" << col << \"): \" << dist[layer][row][col] << std::endl;\n } else {\n std::cout << \"No path to exit (\" << layer << \", \" << row << \", \" << \ncol << \")\" << std::endl;\n }\n }\n return 0;\n}\n#include <iostream>\n#include <climits> // For INT_MAX\n#include <vector>\n#include <tuple>\n// 全局变量，已定义的结构和迷宫信息保持不变\n// 假定我们有如下函数定义：\n// void readMazeData(const std::string& filename); // 读取迷宫数据\n// void dijkstra(int start_layer, int start_row, int start_col); // 实现的 \nDijkstra 算法\nint main() {\n std::string filename = \"maze_data.txt\";\n解释和说明 \n1. 初始化：我们初始化最短路径成本为最大整数值，并假设最初没有找到任何出口。\n2. 寻找最短路径 ：在所有出口中找到具有最小成本的出口。我们遍历每个出口，检查是否存在到\n达该出口的路径（成本小于 INT_MAX），并记录最小成本和相应的出口位置。\n3. 输出结果 ：根据是否找到出口，输出从起点到最近出口的最短路径成本或 “ 无解 ” 。如果没有找\n到任何出口的路径，输出 “ 无解 ” 。\n这样，我们就完成了从迷宫入口到出口的最短路径搜索和输出。这个程序现在能够处理包括楼梯和\n多个出口的复杂迷宫，并给出求解结果。\n说明\n 在主函数中调用了处理文件输入的函数、 Dijkstra 函数，从 0 ， 0 ， 0 开始进行遍历。\n4.5 错误处理和边界条件检查 \n确保处理所有可能的边界条件，例如迷宫全是障碍物、没有出口、出口或楼梯位置错误等。\n检查输入数据的有效性，确保不会引起程序崩溃。 readMazeData(filename);\n // 假设迷宫入口是 (0, 0, 0) ，这个应该根据具体情况调整\n dijkstra(0, 0, 0);\n // 寻找到最短路径到任一出口\n int min_path_cost = INT_MAX;\n std::tuple<int, int, int> closest_exit; // 用于存储最近出口的位置\n bool found_exit = false;\n for (const auto& exit : exits) {\n int layer, row, col;\n std::tie(layer, row, col) = exit;\n if (dist[layer][row][col] < min_path_cost) {\n min_path_cost = dist[layer][row][col];\n closest_exit = exit;\n found_exit = true;\n }\n }\n // 输出最短路径成本或 “ 无解 ”\n if (found_exit) {\n int layer, row, col;\n std::tie(layer, row, col) = closest_exit;\n std::cout << \"Shortest path to exit (\" << layer << \", \" << row << \", \" \n<< col << \"): \" << min_path_cost << std::endl;\n } else {\n std::cout << \"No path to any exit\" << std::endl;\n }\n return 0;\n}\n在第五步中，我们将集中处理程序中可能出现的错误和边界条件，以确保程序的健壯性和可靠性。\n错误处理和边界条件检查对于任何软件项目都是至关重要的部分，可以防止程序在遇到意外输入或\n情况时崩溃。\n错误处理和边界条件检查的实现 \n下面列举一些关键的错误处理和边界条件，这些应该在代码中进行检查和处理：\n1. 文件读取错误 ：检查文件是否成功打开。\n2. 输入数据有效性 ：验证输入数据（迷宫尺寸、楼梯和出口的位置）是否合理。\n3. 迷宫尺寸合理性 ：确保输入的迷宫尺寸在可接受的范围内，并且每层的行和列数是正数。\n4. 楼梯和出口位置的合法性 ：确保所有楼梯和出口的位置均在迷宫范围内。\n5. 楼梯的连接逻辑性 ：检查楼梯的起始层和目标层是否存在，并且楼梯不应从某一层通向相同\n层。\n6. 迷宫入口可达性 ：确保入口位置是通道而不是障碍。\n7. 数据结构溢出 ：防止数组或向量操作时越界。\n8. 无出口或无通道情况 ：当迷宫没有任何出口或完全被障碍物封闭时应给出正确反应。\n示例代码增加错误处理 \n我们可以在现有的代码框架中添加一些错误处理和检查代码，以下是如何在 C++ 中实现这些检查的\n示例：\n#include <iostream>\n#include <fstream>\n#include <limits>\n#include <vector>\n#include <tuple>\n// 省略之前的结构和全局变量定义\nvoid readMazeData(const std::string& filename) {\n std::ifstream file(filename);\n if (!file.is_open()) {\n std::cerr << \"Error: Failed to open file \" << filename << std::endl;\n exit(EXIT_FAILURE);\n }\n int M, N, layer, row, col, from_layer, from_row, from_col, to_layer, \nto_row, to_col, distance, S, E;\n if (!(file >> M >> N)) {\n std::cerr << \"Error: Invalid maze dimensions in file.\" << std::endl;\n exit(EXIT_FAILURE);\n }\n // 检查迷宫尺寸合法性\n if (M <= 0 || N <= 0 || M > 100 || N > 100) {\n std::cerr << \"Error: Maze dimensions are out of allowed range.\" << \nstd::endl;\n exit(EXIT_FAILURE);\n }\n // 初始化迷宫\n for (int l = 0; l < MAX_LAYERS; ++l) {\n for (int r = 0; r < M; ++r) {\n for (int c = 0; c < N; ++c) {\n if (!(file >> maze[l][r][c]) || (maze[l][r][c] != 0 && \nmaze[l][r][c] != 1)) {\n std::cerr << \"Error: Invalid maze data.\" << std::endl;\n exit(EXIT_FAILURE);\n }\n }\n }\n }\n if (!(file >> E) || E < 0) {\n std::cerr << \"Error: Invalid number of exits.\" << std::endl;\n exit(EXIT_FAILURE);\n }\n while (E--) {\n if (!(file >> layer >> row >> col) || layer < 0 || layer >= \nMAX_LAYERS || row < 0 || row >= M || col < 0 || col >= N) {\n std::cerr << \"Error: Invalid exit coordinates.\" << std::endl;\n exit(EXIT_FAILURE);\n }\n exits.push_back(std::make_tuple(layer, row, col));\n }\n if (!(file >> S) || S < 0) {\n std::cerr << \"Error: Invalid number of stairs.\" << std::endl;\n exit\n(EXIT_FAILURE);\n }\n while (S--) {\n if (!(file >> from_layer >> from_row >> from_col >> to_layer >> \nto_row >> to_col >> distance) ||\n from_layer < 0 || from_layer >= MAX_LAYERS || to_layer < 0 || \nto_layer >= MAX_LAYERS ||\n from_row < 0 || from_row >= M || from_col < 0 || from_col >= N \n||\n to_row < 0 || to_row >= M || to_col < 0 || to_col >= N || \ndistance < 1) {\n std::cerr << \"Error: Invalid stair data.\" << std::endl;\n exit(EXIT_FAILURE);\n }\n stairs.push_back(std::make_tuple(from_layer, from_row, from_col, \nto_layer, to_row, to_col, distance));\n }\n file.close();\n}\nint main() {\n try {\n std::string filename = \"maze_data.txt\";\n在这个代码示例中，我们添加了对文件读取失败、输入数据无效、数组越界等多种潜在错误的检\n查。这些检查有助于确保程序在遇到非预期输入或数据时不会崩溃，并能给出有用的错误信息。这\n些基本的错误处理措施将提高程序的健壮性和用户体验。\n说明\n逐行阅读，确认覆盖到了常见的一场情况，将以上代码整合为完整的代码，放入 vscode 中 build 成功\n未见报错，开始进入测试\n4.6 添加路径打印代码 \nQ：为我在算法中增加一个输出，提示当前找到了一条出口的路径，并输出该路径\n已经修改了 Dijkstra 算法的实现以包含一种机制，用于跟踪并打印到达出口的路径。下面是关键改\n动的解释：\n1. 增加 prev 数组：这个三维向量用于记录从起始点到每个点的路径。它存储了每个点的前一\n个点的位置，从而可以追溯整条路径。\n2. 打印路径功能 ：新增了一个 print_path 函数，该函数使用 prev 数组来追踪并打印从起点\n到任何出口的完整路径。当找到一条到达出口的路径时，会从出口点开始回溯到起始点。\n3. 在找到出口时打印路径 ：在 dijkstra 函数的主循环中，每次访问到一个节点时，都会检查\n该节点是否是出口。如果是，它不仅会打印到达该出口的总成本，还会调用 print_path 来\n输出完整路径。 readMazeData(filename);\n dijkstra(0, 0, 0);\n // 输出最短路径代码省略\n } catch (const std::exception& e) {\n std::cerr << \"An exception occurred: \" << e.what() << std::endl;\n }\n return 0;\n}\nstd::tuple<int, int, int> prev[MAX_LAYERS][MAX_DIM][MAX_DIM];\nvoid print_path(std::tuple<int, int, int> start, std::tuple<int, int, int> \nend) {\n std::stack<std::tuple<int, int, int>> path;\n for (auto at = end; at != start; at = prev[std::get<0>(at)][std::get<1>\n(at)][std::get<2>(at)]) {\n path.push(at);\n }\n path.push(start);\n while (!path.empty()) {\n auto at = path.top();\n path.pop();\n int l, r, c;\n std::tie(l, r, c) = at; // Avoiding structured bindings for \ncompatibility\n std::cout << \"(\" << l << \", \" << r << \", \" << c << \") \";\n }\n std::cout << std::endl;\n}\n这样的实现确保每当找到一条到达出口的路径时，都能够立即报告并显示这条路径。这对于验证和\n调试寻路算法非常有用，尤其是在处理复杂迷宫时，能够确保算法的正确性和效率\n说明\n为了保证最短路径的正确性，我主动要求添加方便观测寻找路径过程的代码，以防无法及时看出较\n为复杂的寻路过程。\n5 运行与测试 \nQ：接下来，让我们开始测试。为了逐步证明该代码的可行性与处理特殊情况的正确性，你认为应该拟定\n哪几种数据、覆盖到哪几种情况？\n要确保你的迷宫解决程序能够可靠地工作并处理各种情况，你应该创建一系列测试用例来覆盖不同\n的边界条件和特殊情况。以下是一些推荐的测试场景，这些场景将帮助验证代码的正确性和鲁棒\n性：\n1. 基本功能测试 \n单层小迷宫 ：一个简单的迷宫，如 3x3 或 5x5 ，有明确的入口和出口，无楼梯。\n两层小迷宫 ：相同大小，但包括楼梯，检查是否能正确处理楼梯和多层逻辑。\n2. 边界条件测试 \n空迷宫：没有任何单元的迷宫。\n迷宫全是障碍 ：没有任何通道的迷宫。\n迷宫无出口 ：迷宫中没有定义任何出口。\n迷宫出口不可达 ：迷宫中的出口由障碍物完全阻挡。\n3. 特殊逻辑测试 \n多楼梯连接 ：一个迷宫层中有多个楼梯连接到另一层，测试路径选择逻辑。\n楼梯循环 ：楼梯之间存在循环（例如，从 A 到 B 再到 A ），确保程序不会在循环中无限运行。\n楼梯直接通向出口 ：测试楼梯是否能直接到达出口位置。\n4. 性能测试 \n大尺寸迷宫性能测试 ：用大尺寸迷宫（如 100x100 ）测试程序的性能和响应时间，确保算法\n能在合理时间内完成计算。\n如何实施测试 \n创建多个迷宫配置文件 ：每个测试用例应有其配置文件（例如： maze_test1.txt，\nmaze_test2.txt等），每个文件对应上述测试中的一个场景。\n修改程序读取 ：使程序能够通过命令行参数或修改文件名来读取不同的测试配置文件。\n自动化测试脚本 ：如果可能，编写一个简单的脚本来自动运行所有测试，并检查输出是否符合\n预期结果。\n通过这些测试，你可以全面评估程序的功能，确保它在各种情况下都能正确工作。这样的测试也有\n助于在发布之前发现和修复潜在的问题。\n说明\n以此为指导，开始逐一设计测试用例、预测预期输出、运行程序、检查实际输出。由于迷宫算法的\n过程较为复杂，为了完整展示每一步过程来观察算法的运行情况，决定将针对各种情况的每一个测试用\n例单独列出进行分析对比。\n5.1 基本功能测试 \n5.1.1 单层小迷宫 \n一个简单的迷宫，如 3x3 或 5x5 ，有明确的入口和出口，无楼梯。\n为了进行单层小迷宫的测试，我们将设定一个 3x3 的迷宫布局。此迷宫将具备一个明确的入口和一\n个出口，并且不包含任何楼梯。下面是迷宫的配置文件内容以及预期的输出结果。\n测试文件内容 ( 假设文件名为 single_layer_maze.txt) \n文件内容说明 \n第一行： 1 3 3 表示迷宫有 1 层，每层是一个 3x3 的网格。\n接下来三行描述了迷宫的布局，其中 1 表示通道， 0 表示障碍。迷宫的入口假设在左上角 \n(0,0)，出口在右下角 (0,2,2) 。\n接下来的行 1 表示有一个出口。\n紧接着的行 0 2 2 指明出口的位置在第一层的 (2,2) 位置。\n最后的行 0 表示没有楼梯。\n计算最短路径 \n1. 从 (0, 0) 向右到 (0, 1) 。\n2. 从 (0, 1) 向右到 (0, 2) 。\n3. 从 (0, 2) 向下到 (1, 2) 。\n4. 从 (1, 2) 向下到 (2, 2) 。\n这条路径总共包含 4 个步骤，每个步骤的成本为 1 。\n预期输出结果 \n这表示从入口到出口的最短路径长度是 4 ，路径完全沿着迷宫的最右侧或最左侧进行，避开中间行\n的障碍物。此输出应反映在测试和实际程序运行中看到的结果。\n说明\n首次运行测试用例，发现代码缺少对于单层迷宫输入的标记，会将后续的输入信息视为第二层迷\n宫，故要求修改了输入逻辑，允许输入层数来决定此次输入迷宫的层数。修改后成功运行得到了预期结\n果，证明抵达出口、使用楼梯的基本功能测试通过\n修改后代码输出结果1 3 3\n1 1 1\n1 0 1\n1 1 1\n1\n0 2 2\n0\nShortest path to nearest exit: 4\n结果分析\n起点：从坐标 (0, 0) 开始，这里的成本为 0 。\n节点更新 :\n从 (0, 0) 到 (0, 1) 和 (0, 0) 到 (0, 1) 的成本更新为 1 。\n从 (0, 1) 到 (0, 2) 的成本更新为 2 。\n从 (0, 0) 到 (0, 2) 和 (0, 2) 到 (0, 2) 的成本分别更新为 2 和 4 。\n从 (0, 2) 到 (0, 2) 的成本更新为 3 。\n从 (0, 0) 绕过障碍 (1,0) 到 (0, 2) 的成本更新为 4 。\n算法最终找到了从起点 (0, 0) 到出口 (2, 2) 的最短路径，成本为 4 。这条路径是合理的，因为它避开了中\n间的障碍，绕路通过 (0,1) 和 (0,2) 到达了目的地。\n测试点通过。\n5.2.2 两层小迷宫 \n相同大小，但包括楼梯，检查是否能正确处理楼梯和多层逻辑。\n为了测试一个两层的小迷宫，我们会设置一个 3x3 的迷宫，其中包括楼梯连接两层，从而检查程序\n是否能正确处理多层逻辑和楼梯连接。下面是一个具体的测试输入文件内容以及预期的输出结果。\n测试文件内容（假设文件名为 two_layer_maze.txt） Layer 1:\n1 1 1\n1 0 1\n1 1 1\n1 exits:\nExit at layer 1, row 2, column 2\n0 stairs:\nPath to exit at (0, 2, 2) with cost 4:\n(0, 0, 0) (0, 1, 0) (0, 2, 0) (0, 2, 1) (0, 2, 2)\nShortest path to nearest exit: 4\n2 3 3\n1 1 1\n1 0 1\n1 1 1\n1 1 1\n1 0 1\n1 1 1\n1\n1 0 0\n1\n0 2 2 1 2 2 2\n文件内容说明 \n第一行： 2 3 3 表示迷宫有 2 层，每层是一个 3x3 的网格。\n接下来两组三行描述了每层迷宫的布局，其中 1 表示通道， 0 表示障碍。\n第十行： 1 表示有两个出口。\n第十一行和第十二行： 1 0 0 指明出口位置在第二层的 (0,0) 。\n第十三行： 1 表示有一个楼梯。\n第十四行： 0 2 2 1 2 2 2 表示一个楼梯从第一层的 (2,2) 位置连接到第二层的 (2,2) 位置，\n楼梯的成本为 2 。\n预期输出结果 \n假设迷宫的入口在第一层的左上角 (0,0) ，算法需要找到到任一出口的最短路径。由于存在楼梯直接\n连接第一层的 (2,2) 到第二层的 (2,2) ，且第二层存在 (0,0) 出口，最优路径应该会利用这个楼梯。\n1. 从 (0,0,0) 到 (0,2,2) 走四步。\n2. 从 (0,2,2) 到 (1,2,2) 通过楼梯，成本增加 2 。\n3. 从 (1,2,2) 到 (0,0,0) 走四步。\n总步骤： 4 （第一层行走） + 2 （楼梯） + 4 （第二层行走） = 10 步。\n预期输出 :\n此测试将验证算法是否能够正确识别和使用楼梯，同时考虑多层结构的最短路径问题。\n输出结果：\n结果分析：\n由输出过程可以看出，从起点 (0,0) 开始，算法正确地探索了所有可达的节点，楼梯的使用正确加入了额\n外的成本（ 2 ），并且成功地从第一层跳转到了第二层。Shortest path to nearest exit: 10\nLayer 1:\n1 1 1\n1 0 1\n1 1 1\nLayer 2:\n1 1 1\n1 0 1\n1 1 1\n1 exits:\nExit at layer 2, row 0, column 0\n1 stairs:\nStair from layer 1, row 2, column 2 to layer 2, row 2, column 2 with cost 2\nPath to exit at (1, 0, 0) with cost 10:\n(0, 0, 0) (0, 1, 0) (0, 2, 0) (0, 2, 1) (0, 2, 2) (1, 2, 2) (1, 1, 2) (1, 0, 2) \n(1, 0, 1) (1, 0, 0)\nShortest path to nearest exit: 10\n该测试结果证明，算法能够正确使用楼梯并处理楼梯的 cost ，测试点通过。\n5.2 边界条件测试 \n5.2.1 空迷宫 \n没有任何单元的迷宫。\n设计一个测试用例来模拟空迷宫情况是相当直接的。在这种情况下，由于迷宫没有任何单元，也不\n可能有楼梯或出口。以下是具体的测试文件内容及其预期的输出。\n测试文件内容（假设文件名为 empty_maze.txt） \n文件内容说明 \n第一行： 1 0 0 表示迷宫有 1 层，但每层的行数和列数都是 0 ，即没有任何单元。\n第二行： 0 表示没有出口。\n第三行： 0 表示没有楼梯。\n预期输出结果 \n由于迷宫中没有任何单元，程序理应能够处理这种情况而不发生错误。预期输出应该是表明没有可\n达的路径，因为既没有入口也没有出口。理想的输出应该是某种形式的错误消息或者明确指示无解\n的信息。\n预期输出 ：\n考虑的错误处理 \n1. 维度检查 ：在读取迷宫数据时，程序应检查迷宫的行数和列数是否大于零。如果不是，应输出\n错误消息，并说明迷宫的维度不符合要求。\n2. 出口和楼梯验证 ：由于迷宫大小为 0 ，即使文件中声明有出口或楼梯，程序也应忽略这些数\n据，并可能输出错误消息，因为在没有单元的迷宫中不可能有出口或楼梯。\n这种测试用例有助于确保程序能够优雅地处理极端或非标准的输入情况，防止运行时错误或不适当\n的行为。\n实际输出\n分析结果\n从实际输出来看，程序已经很好地处理了空迷宫的异常情况。这表明它正确地识别出输入数据中的迷宫\n尺寸或层数是无效的。这个错误处理是合理的，因为没有行或列的迷宫实际上无法存在任何路径或单\n元。程序在检测到这种情况后立即终止，这是预期的正确行为。1 0 0\n0\n0\nError: Invalid maze dimensions or layer count.\nError: Invalid maze dimensions or layer count.\n测试点通过。\n5.2.2 迷宫全是障碍 \n没有任何通道的迷宫。\n为测试一个完全由障碍物组成的迷宫，我们可以设计一个具体的测试用例，其中迷宫的每个单元都\n被障碍物占据。这种情况应当被程序识别并合理地处理，通常应该返回表示没有可行路径的输出。\n测试文件内容（假设文件名为 all_obstacles_maze.txt） \n文件内容说明 \n第一行： 1 3 3 表示迷宫有 1 层，每层是一个 3x3 的网格。\n接下来三行表示迷宫每个单元的状态，其中 0表示该单元是障碍物。\n第五行： 1 表示有一个出口（尽管在实际情况中这个出口是不可达的）。\n第六行： 0 2 2 表示出口假定在位置 (2,2) ，尽管由于障碍物的存在这个出口是不可达的。\n最后一行： 0 表示没有楼梯。\n预期输出结果 \n在这种情况下，因为迷宫中没有任何通道，所以没有任何路径可以从入口（如果存在的话）到达出\n口。程序应该能够识别这一点，并输出表明无解的信息。\n预期输出 ：\n考虑的错误处理 \n程序应当检查迷宫的初始入口点是否是通道。如果入口点是障碍，程序应当直接报告无解。在这种\n全障碍的迷宫情况下，程序不仅应检查入口，而且还应验证是否所有路径都被障碍阻塞了。\n此测试用例有助于确保程序能够处理那些极端情况，即迷宫完全不可通行。这是对程序健壮性的一\n个重要验证。1 3 3\n0 0 0\n0 0 0\n0 0 0\n1\n0 2 2\n0\nNo path to any exit\n结果分析\n程序尝试从起点（ 0, 0, 0 ）开始探索，由于所有相邻单元都是障碍，所以没有进一步的节点可以访问。最\n终输出了 \"No path to any exit\"，准确地指出了迷宫中不存在到任何出口的路径。\n测试点通过\n5.2.3 迷宫无出口 \n迷宫中没有定义任何出口。\n为了设计一个测试用例，其中迷宫中没有定义任何出口，我们可以创建一个正常的迷宫布局，但在\n描述出口数量时指定为 0 。这种情况下，程序应该能够正确处理并输出表示迷宫中没有出口的信\n息。\n测试文件内容（假设文件名为 no_exits_maze.txt） \n文件内容说明 \n第一行： 1 3 3 表示迷宫有 1 层，每层是一个 3x3 的网格。\n接下来三行描述了迷宫的布局，其中 1 表示通道， 0 表示障碍。\n第五行： 0 表示迷宫中没有出口。\n最后一行： 0 表示没有楼梯。\n预期输出结果 \n由于迷宫中没有定义任何出口，理想的程序输出应该是表明无法找到出口的信息。程序需要处理这\n种情况并优雅地输出适当的消息。\n预期输出 ：\n或者更一般地：Layer 1:\n0 0 0\n0 0 0\n0 0 0\n1 exits:\nExit at layer 1, row 2, column 2\n0 stairs:\nNo path to any exit\n1 3 3\n1 1 1\n1 0 1\n1 1 1\n0\n0\nNo exits defined in the maze.\n考虑的错误处理 \n在这种测试情况下，程序的逻辑应该包括：\n1. 出口数量检查 ：在开始寻找路径之前，程序应检查出口的数量。如果数量为 0 ，则直接返回没\n有出口的信息。\n2. 避免不必要的计算 ：由于没有出口，程序不应尝试进行任何路径查找或成本计算，应直接返回\n结果。\n3. 用户友好的输出 ：程序应提供清晰的输出，说明为何没有返回路径（即没有出口可达）。\n此测试用例有助于确保程序能够正确处理缺乏出口的情况，这在实际应用中可能由于配置错误或数\n据输入错误而发生。正确地处理这种情况不仅可以提高程序的健壮性，也能提升用户体验，防止用\n户对程序的反应感到困惑。\n输出分析\n算法正确加载了迷宫布局，并输出了 No path to any exit。这个信息正确地反映了迷宫中没有出口\n的情况。\n测试点通过\n5.2.4 迷宫出口不可达 \n迷宫中的出口由障碍物完全阻挡。\n为了设计一个测试用例，其中迷宫的出口被障碍物完全阻挡，我们可以创建一个具有明确通道和障\n碍的迷宫布局，但出口位置完全被障碍物围绕。这种情况下，程序应正确识别出出口不可达，并输\n出适当的信息。\n测试文件内容（假设文件名为 exit_blocked_maze.txt） No path to any exit\nLayer 1:\n1 1 1\n1 0 1\n1 1 1\n0 exits:\n0 stairs:\nNo path to any exit\n1 5 5\n1 1 1 1 1\n1 0 0 0 1\n1 0 0 0 1\n1 0 0 0 1\n1 1 1 1 1\n1\n0 3 3\n0\n文件内容说明 \n第一行： 1 5 5 表示迷宫有 1 层，每层是一个 5x5 的网格。\n接下来五行描述了迷宫的布局，其中 1 表示通道， 0 表示障碍。\n注意，出口位置 (3, 3) 被四周的 0（障碍物）完全围绕。\n第七行： 1 表示有一个出口。\n第八行： 0 3 3 指明出口位置在 (0,3,3) ，注意这个位置实际上是被障碍物完全围绕的，因此\n不可达。\n最后一行： 0 表示没有楼梯。\n预期输出结果 \n由于迷宫中的出口位置被障碍物完全阻挡，程序应该能够识别出无法到达任何出口的情况，并输出\n表明出口不可达的信息。\n预期输出 ：\n考虑的错误处理 \n程序应当在确定路径之前，检查出口是否被障碍物完全包围。如果出口不可达：\n1. 出口可达性检查 ：程序应验证出口周围是否至少有一个通道格，这是出口可达性的前提。\n2. 优化程序反应 ：在无法到达出口时，程序不应浪费资源去尝试找到一条路径。应当直接报告出\n口不可达的情况。\n3. 用户友好的输出 ：程序应提供明确的输出，说明为何没有返回路径（即出口被障碍阻挡）。\n此测试用例有助于确保程序能够正确处理那些虽然存在出口但实际上不可达的情况，从而提高程序\n的健壮性和用户体验。\n说明\n实际上该四种测试用例本质上都是为了测试 “ 无法抵达出口 ” 的情况，初次测试后发现迷宫出口不可达\n的程序意外中断，检查后发现是 gpt 提供的输入格式有误，将出口输入的层数漏了，更正后顺利执行，测\n试通过\n修改代码后输出结果\n结果分析No path to any exit\nLayer 1:\n1 1 1 1 1\n1 0 0 0 1\n1 0 0 0 1\n1 0 0 0 1\n1 1 1 1 1\n1 exits:\nExit at layer 1, row 3, column 3\n0 stairs:\nNo path to any exit\n探索过程 ：从左上角 (0, 0) 开始，算法正确地识别并更新从起点到其它可达节点的最短路径。这包括从 \n(0, 0) 向右至 (0, 4) 和从 (0, 0) 向下至 (4, 0) 。因为内部全是障碍，算法无法进入中心区域。\n探索结果 ：算法在探索了所有可访问的节点后，并未找到任何出口。最终输出为 “No path to any exit” ，\n表明尽管算法遍历了所有可能的路径，但没有找到通往出口的路线。\n结论：算法有效地处理了所有节点，即使在没有出口的情况下，也没有出现错误或异常中断。\n测试点通过\n5.3 特殊逻辑测试 \n5.3.1 多楼梯连接 \n一个迷宫层中有多个楼梯连接到另一层，测试路径选择逻辑。\n为了测试迷宫中多个楼梯连接的情况，并验证路径选择逻辑的有效性，我们可以设计一个含有多个\n楼梯连接的迷宫，其中楼梯连接不同的层和位置。这个测试用例将检验算法是否能正确处理从一层\n到另一层的多个路径选择，并找到最短路径。\n测试用例：多楼梯连接 \n文件名：multi_staircase_maze.txt \n文件内容说明 \n迷宫尺寸和层数 ：迷宫有两层，每层为 10x10 。\n楼梯设置 ：设置多个楼梯在策略性位置连接两层。\n出口设置 ：在第二层设置出口，检验楼梯使用后路径的选择。\n示例迷宫文件内容 \n2 10 10\n1 1 1 1 1 1 1 1 1 1\n1 0 0 0 0 0 0 0 0 1\n1 0 1 1 1 1 1 1 0 1\n1 0 1 0 0 0 0 1 0 1\n1 0 1 1 1 1 1 1 0 1\n1 0 0 0 0 0 0 0 0 1\n1 1 1 1 1 1 1 1 1 1\n1 0 0 0 0 0 0 0 0 1\n1 0 1 1 1 1 1 1 0 1\n1 1 1 1 1 1 1 1 1 1\n1 1 1 1 1 1 1 1 1 1\n1 0 0 0 0 0 0 0 0 1\n1 0 1 1 1 1 1 1 0 1\n1 0 1 0 0 0 0 1 0 1\n1 0 1 1 1 1 1 1 0 1\n1 0 0 0 0 0 0 0 0 1\n1 1 1 1 1 1 1 1 1 1\n1 0 0 0 0 0 0 0 0 1\n1 0 1 1 1 1 1 1 0 1\n1 1 1 1 1 1 1 1 1 1\n2\n1 9 9\n迷宫结构描述 \n每层是一个 10x10 的迷宫，具有通道（ 1）和障碍（ 0）。\n第一层与第二层之间有 4 个楼梯，位于 (5,5) ， (2,2) ， (7,7) ，和 (9,2) ，楼梯 cost 分别为 1 2 3 1\n第二层有两个出口，分别在 (9,9) 和 (9,0) 。\n预期输出结果 \n该测试用例旨在评估算法是否能够利用多个楼梯有效地选择最短路径。\n迷宫设计应确保楼梯的选择显著影响到达出口的总成本。\n预期输出 ：\n根据楼梯和出口的配置，算法应输出到达最近出口的最短路径成本。例如，如果楼梯在 (9,2) 直接\n通向一个较近的出口，那么应输出此路径的成本。\n这种测试确保了路径选择逻辑在处理楼梯和多层连接时的有效性和准确性\n输出结果1 9 0\n4\n0 5 5 1 5 5 1\n0 2 2 1 2 2 2\n0 7 7 1 7 7 3\n0 9 2 1 9 2 1\nLayer 1:\n1 1 1 1 1 1 1 1 1 1\n1 0 0 0 0 0 0 0 0 1\n1 0 1 1 1 1 1 1 0 1\n1 0 1 0 0 0 0 1 0 1\n1 0 1 1 1 1 1 1 0 1\n1 0 0 0 0 0 0 0 0 1\n1 1 1 1 1 1 1 1 1 1\n1 0 0 0 0 0 0 0 0 1\n1 0 1 1 1 1 1 1 0 1\n1 1 1 1 1 1 1 1 1 1\nLayer 2:\n1 1 1 1 1 1 1 1 1 1\n1 0 0 0 0 0 0 0 0 1\n1 0 1 1 1 1 1 1 0 1\n1 0 1 0 0 0 0 1 0 1\n1 0 1 1 1 1 1 1 0 1\n1 0 0 0 0 0 0 0 0 1\n1 1 1 1 1 1 1 1 1 1\n1 0 0 0 0 0 0 0 0 1\n1 0 1 1 1 1 1 1 0 1\n1 1 1 1 1 1 1 1 1 1\n2 exits:\nExit at layer 2, row 9, column 9\nExit at layer 2, row 9, column 0\n4 stairs:\n可以看出，由于存在两个出口，该算法找到了两条路径，最终选择了 1 ， 9 ， 0 出口的路径，使用了位于\n0，9， 2处 cost 为 1 的楼梯\n测试点通过。\n5.3.2 楼梯循环 \n楼梯之间存在循环（例如，从 A 到 B 再到 A ），确保程序不会在循环中无限运行。\n为了测试迷宫处理程序在存在楼梯循环的情况下的行为，确保程序能正确处理并避免因循环而导致\n无限运行，我们可以设计一个具有楼梯循环的迷宫。这种测试用例将帮助验证算法能否有效识别并\n防止因循环路径而无限递归或循环。\n测试用例：楼梯循环 \n文件名：staircase_loop_maze.txt \n文件内容说明 \n迷宫尺寸和层数 ：迷宫有两层，每层为 5x5 。\n楼梯设置 ：设置楼梯形成从第一层到第二层再返回第一层的循环。\n出口设置 ：在第二层设置一个出口，检查是否能够避开楼梯循环，正确找到出口。\n示例迷宫文件内容 Stair from layer 1, row 5, column 5 to layer 2, row 5, column 5 with cost 1\nStair from layer 1, row 2, column 2 to layer 2, row 2, column 2 with cost 2\nStair from layer 1, row 7, column 7 to layer 2, row 7, column 7 with cost 3\nStair from layer 1, row 9, column 2 to layer 2, row 9, column 2 with cost 1\nPath to exit at (1, 9, 9) with cost 19:\n(0, 0, 0) (0, 1, 0) (0, 2, 0) (0, 3, 0) (0, 4, 0) (0, 5, 0) (0, 6, 0) (0, 7, 0) \n(0, 8, 0) (0, 9, 0) (0, 9, 1) (0, 9, 2) (1, 9, 2) (1, 9, 3) (1, 9, 4) (1, 9, 5) \n(1, 9, 6) (1, 9, 7) (1, 9, 8) (1, 9, 9)\nPath to exit at (1, 9, 0) with cost 14:\n(0, 0, 0) (0, 1, 0) (0, 2, 0) (0, 3, 0) (0, 4, 0) (0, 5, 0) (0, 6, 0) (0, 7, 0) \n(0, 8, 0) (0, 9, 0) (0, 9, 1) (0, 9, 2) (1, 9, 2) (1, 9, 1) (1, 9, 0)\nShortest path to nearest exit: 14\n2 5 5\n1 1 1 1 1\n1 0 0 0 1\n1 1 1 0 1\n1 0 1 1 1\n1 1 1 1 1\n1 1 1 1 1\n1 0 0 0 1\n1 1 1 0 1\n1 0 1 1 1\n1 1 1 1 1\n1\n1 4 4\n2\n0 2 4 1 2 4 1\n1 2 5 0 2 5 1\n迷宫结构描述 \n第一层和第二层都是 5x5 的网格，其中大部分区域都是可通行的（ 1），有一些障碍（ 0）。\n楼梯连接形成循环：\n从第一层的 (2,4) 到第二层的 (2,4) ，然后从第二层的 (2,5) 返回第一层的 (2,5) 。\n出口位于第二层的 (4,4) 。\n预期输出结果 \n算法应识别并避免在楼梯之间形成的循环，从而不会导致无限运行。\n应能够找到从起始点到第二层出口 (4,4) 的有效路径。\n预期输出 ：\n重要考虑因素 \n路径更新逻辑 ：算法需要在更新路径时检查是否已经访问过当前层的同一位置，避免重复进入\n相同的楼梯循环。\n循环检测 ：实现楼梯使用时的循环检测机制，确保在确定最短路径时排除无限循环的可能性。\n此测试用例将确保路径寻找算法在面对复杂的楼梯连接情况时仍能正确执行，不会因设计缺陷或逻\n辑错误导致程序异常。这是测试迷宫路径寻找算法健壮性的一个重要方面。\n输出结果\n结果分析Shortest path to nearest exit: [ 具体步数，取决于迷宫的具体布局和起始点位置 ]\nLayer 1:\n1 1 1 1 1\n1 0 0 0 1\n1 1 1 0 1\n1 0 1 1 1\n1 1 1 1 1\nLayer 2:\n1 1 1 1 1\n1 0 0 0 1\n1 1 1 0 1\n1 0 1 1 1\n1 1 1 1 1\n1 exits:\nExit at layer 2, row 4, column 4\n2 stairs:\nStair from layer 1, row 2, column 4 to layer 2, row 2, column 4 with cost 1\nStair from layer 2, row 2, column 5 to layer 1, row 2, column 5 with cost 1\nPath to exit at (1, 4, 4) with cost 9:\n(0, 0, 0) (0, 0, 1) (0, 0, 2) (0, 0, 3) (0, 0, 4) (0, 1, 4) (0, 2, 4) (1, 2, 4) \n(1, 3, 4) (1, 4, 4)\nShortest path to nearest exit: 9\n从过程输出可以看出，它仅使用了一次楼梯，即从一层抵达二层，并没有再次使用二层原路返回一层的\n楼梯，这是因为楼下的原节点已经被设置成访问过的状态，故不会再次被放入列表中，以此防止楼梯被\n重复使用，从根源上阻止可能存在的死循环。\n5.3.3 楼梯直接通向出口 \n测试楼梯是否能直接到达出口位置。\n为了测试楼梯是否能直接通向出口位置，我们可以设计一个两层的迷宫，其中楼梯直接通向第二层\n的出口。这样可以验证算法是否能够正确地识别和利用楼梯直接到达出口。\n测试用例：楼梯直接通向出口 \n文件名：stair_to_exit_maze.txt \n文件内容说明 \n迷宫尺寸和层数 ：迷宫有两层，每层为 5x5 。\n楼梯设置 ：楼梯从第一层通向第二层的出口位置。\n出口设置 ：在第二层的出口位置设定。\n示例迷宫文件内容 \n迷宫结构描述 \n第一层：\n第一层的 (0, 0) 是起点。楼梯位置在 (0, 0) 。\n第二层：2 5 5\n1 1 1 1 1\n1 0 0 0 1\n1 1 1 0 1\n1 0 1 1 1\n1 1 1 1 1\n1 1 1 1 1\n1 0 0 0 1\n1 1 1 0 1\n1 0 1 1 1\n1 1 1 1 1\n1\n1 4 4\n1\n0 0 0 1 4 4 5\n1 1 1 1 1\n1 0 0 0 1\n1 1 1 0 1\n1 0 1 1 1\n1 1 1 1 1\n第二层的 (4, 4) 是出口。楼梯从第一层的 (0, 0) 到第二层的 (4, 4) ，楼梯成本为 5 。\n预期输出结果 \n算法应识别楼梯，并通过楼梯直接到达出口。\n最短路径成本应为 5 （楼梯的成本）。\n预期输出 ：\n输出结果\n结果分析\n起点 (0, 0, 0) ，成本为 0 。\n更新到 (0, 1, 0)，成本为 1 。\n更新到 (0, 0, 1)，成本为 1 。\n使用楼梯到 (1, 4, 4) ，总成本为 5 。\n(0, 1, 0)，成本为 1 ：\n更新到 (0, 2, 0)，成本为 2 。\n(0, 0, 1)，成本为 1 ：\n更新到 (0, 0, 2)，成本为 2 。1 1 1 1 1\n1 0 0 0 1\n1 1 1 0 1\n1 0 1 1 1\n1 1 1 1 1\nShortest path to nearest exit: 5\nLayer 1:\n1 1 1 1 1\n1 0 0 0 1\n1 1 1 0 1\n1 0 1 1 1\n1 1 1 1 1\nLayer 2:\n1 1 1 1 1\n1 0 0 0 1\n1 1 1 0 1\n1 0 1 1 1\n1 1 1 1 1\n1 exits:\nExit at layer 2, row 4, column 4\n1 stairs:\nStair from layer 1, row 0, column 0 to layer 2, row 4, column 4 with cost 5\nPath to exit at (1, 4, 4) with cost 5:\n(0, 0, 0) (1, 4, 4)\nShortest path to nearest exit: 5\n使用楼梯后到达 (1, 4, 4)，成本为 5 ，这里是出口节点。探索后该迷宫不存在其他出口，故只有这一\n条路径。\n测试点通过\n说明\n该部分的测试用例针对了楼梯的使用在整个图中的影响，设计了较为复杂的楼梯使用情况。由于提\n前要求了打印路径输出的函数，根据每一次找到出口时返回打印的路径，能够清晰观测到路径的走向和\n不同 cost 的对比。\n5.4 性能测试 \n用大尺寸迷宫（如 100x100 ）测试程序的性能和响应时间，确保算法能在合理时间内完成计算。\n为了测试程序在大尺寸迷宫（如 100x100 ）上的性能和响应时间，我们可以设计一个迷宫文件，并\n设置多个出口和楼梯。这样可以确保算法能够处理复杂的路径搜索，同时验证其性能。\n测试用例：大尺寸迷宫 \n文件名：large_maze_test.txt \n文件内容说明 \n迷宫尺寸和层数 ：迷宫有两层，每层为 100x100 。\n出口设置 ：在两个不同的层设置出口。\n楼梯设置 ：设置几个楼梯连接不同的层。\n示例迷宫文件内容 \n2 100 100\n# 第一层\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 \n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 \n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n# ...\n# Repeat similar lines for first layer with some obstacles and pathways\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 \n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 \n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n# 第二层\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 \n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 \n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n# ...\n# Repeat similar lines for second layer with some obstacles and pathways\n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 \n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 \n1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n2\n0 99 99\n1 99 99\n1\n0 1 1 1 98 98 5\n迷宫结构描述 \n两层迷宫，每层 100x100 ：生成的迷宫包含一些障碍和通道。\n出口：\n第一层出口在 (99, 99) 。\n第二层出口在 (99, 99) 。\n楼梯：\n第一层的 (1, 1) 到第二层的 (98, 98) ，成本为 5 。\n预期输出结果 \n算法应识别并处理大尺寸迷宫，找到最短路径并输出路径成本。\n测试主要关注算法的性能和响应时间。\n预期输出 ：\n由于该迷宫过于庞大，为了直观能够展示结果，选择将两层全部设为通路 1 ，但是设置两个出口和一个楼\n梯，使用楼梯抵达二层出口更近，故预期输出应当为 2+5+2=9\n输出结果Shortest path to nearest exit: [Calculated Path Cost]\n从最后几行可以看出，算法找到了两条路径，但是并没有将一层出口的 cost 作为最终结果输出，而是输出\n了使用楼梯后抵达的更近的出口即 1 99 99 处的路径长度，符合预期，且除去输出过程后，在运行后立刻\n输出了答案，证明性能较好。\n测试点通过。\n说明\n自行靠复制粘贴完成了通路完整的大迷宫的 txt 输入文件，用人类智能取代人工智能预测了预期输\n出，运行后输出一致# 前略迷宫结构 2*10000*10000 的打表\nPath to exit at (0, 99, 99) with cost 198:\n(0, 0, 0) (0, 1, 0) (0, 2, 0) (0, 3, 0) (0, 4, 0) (0, 5, 0) (0, 6, 0) (0, 7, 0) \n(0, 8, 0) (0, 9, 0) (0, 10, 0) (0, 11, 0) (0, 12, 0) (0, 13, 0) (0, 14, 0) (0, \n15, 0) (0, 16, 0) (0, 17, 0) (0, 18, 0) (0, 19, 0) (0, 20, 0) (0, 21, 0) (0, 22, \n0) (0, 23, 0) (0, 24, 0) (0, 25, 0) (0, 26, 0) (0, 27, 0) (0, 28, 0) (0, 29, 0) \n(0, 30, 0) (0, 31, 0) (0, 32, 0) (0, 33, 0) (0, 34, 0) (0, 35, 0) (0, 36, 0) (0, \n37, 0) (0, 38, 0) (0, 39, 0) (0, 40, 0) (0, 41, 0) (0, 42, 0) (0, 43, 0) (0, 44, \n0) (0, 45, 0) (0, 46, 0) (0, 47, 0) (0, 48, 0) (0, 49, 0) (0, 49, 1) (0, 50, 1) \n(0, 51, 1) (0, 52, 1) (0, 53, 1) (0, 54, 1) (0, 55, 1) (0, 55, 2) (0, 56, 2) (0, \n57, 2) (0, 57, 3) (0, 57, 4) (0, 58, 4) (0, 58, 5) (0, 59, 5) (0, 60, 5) (0, 61, \n5) (0, 61, 6) (0, 62, 6) (0, 62, 7) (0, 62, 8) (0, 62, 9) (0, 63, 9) (0, 63, 10) \n(0, 63, 11) (0, 64, 11) (0, 65, 11) (0, 66, 11) (0, 67, 11) (0, 67, 12) (0, 67, \n13) (0, 67, 14) (0, 67, 15) (0, 67, 16) (0, 67, 17) (0, 67, 18) (0, 67, 19) (0, \n67, 20) (0, 67, 21) (0, 67, 22) (0, 67, 23) (0, 67, 24) (0, 67, 25) (0, 67, 26) \n(0, 67, 27) (0, 67, 28) (0, 67, 29) (0, 67, 30) (0, 67, 31) (0, 67, 32) (0, 67, \n33) (0, 67, 34) (0, 67, 35) (0, 68, 35) (0, 69, 35) (0, 70, 35) (0, 70, 36) (0, \n70, 37) (0, 70, 38) (0, 70, 39) (0, 70, 40) (0, 70, 41) (0, 70, 42) (0, 70, 43) \n(0, 70, 44) (0, 70, 45) (0, 70, 46) (0, 70, 47) (0, 70, 48) (0, 70, 49) (0, 70, \n50) (0, 70, 51) (0, 71, 51) (0, 71, 52) (0, 71, 53) (0, 72, 53) (0, 72, 54) (0, \n72, 55) (0, 72, 56) (0, 72, 57) (0, 72, 58) (0, 72, 59) (0, 72, 60) (0, 72, 61) \n(0, 72, 62) (0, 72, 63) (0, 73, 63) (0, 74, 63) (0, 75, 63) (0, 75, 64) (0, 76, \n64) (0, 77, 64) (0, 78, 64) (0, 79, 64) (0, 79, 65) (0, 79, 66) (0, 80, 66) (0, \n80, 67) (0, 81, 67) (0, 82, 67) (0, 83, 67) (0, 83, 68) (0, 83, 69) (0, 83, 70) \n(0, 83, 71) (0, 84, 71) (0, 85, 71) (0, 86, 71) (0, 86, 72) (0, 86, 73) (0, 86, \n74) (0, 86, 75) (0, 87, 75) (0, 88, 75) (0, 88, 76) (0, 88, 77) (0, 89, 77) (0, \n89, 78) (0, 89, 79) (0, 89, 80) (0, 89, 81) (0, 89, 82) (0, 89, 83) (0, 89, 84) \n(0, 89, 85) (0, 89, 86) (0, 89, 87) (0, 90, 87) (0, 91, 87) (0, 91, 88) (0, 92, \n88) (0, 92, 89) (0, 93, 89) (0, 93, 90) (0, 93, 91) (0, 93, 92) (0, 94, 92) (0, \n94, 93) (0, 94, 94) (0, 95, 94) (0, 96, 94) (0, 97, 94) (0, 98, 94) (0, 98, 95) \n(0, 98, 96) (0, 98, 97) (0, 99, 97) (0, 99, 98) (0, 99, 99)\nPath to exit at (1, 99, 99) with cost 9:\n(0, 0, 0) (0, 1, 0) (0, 1, 1) (1, 98, 98) (1, 99, 98) (1, 99, 99)\nShortest path to nearest exit: 9\n6 总结 \n本次实验，我结合了 gpt 辅助编程，深刻认识到这一代码辅助工具和 Github 异曲同工都是 copy ，但是要知\n道copy到哪里、知道怎么发问 copy 结果、知道怎么让 copy 下来的代码成功跑起来。\ncopy到哪里：让 gpt 教我，将问题等效化成抽象的数据结构本质问题，据此可以提问让其推荐并展开讲解\n具体的算法，充分发挥教学作用\n怎么发问 copy 结果：让我教 gpt ，循循善诱让它分解成具体的步骤模块，可以先提供伪代码实现， gpt 学\n我也跟着学，下一步在上一步的基础上逐步完善，直接输出结果很容易不是一堆简写就是一堆假设外加\n一堆幸运报错，改了后面忘了前面，生成了也等于没生成\n怎么让 copy 下来的代码成功跑起来：在测试之前尤其是针对较为复杂的算法，要求它逐步添加较为完整\n的打印输出函数，以供想偷懒又不能完全偷懒的程序员检查。在本题中两个个输出的关键点分别对应了\n两个模块，分别是：迷宫结构出口楼梯的情况（检查 txt 输入是否存在问题）、记录查找路径每找到一个\n出口打印输出（人类肉眼很容易遗漏设计测试迷宫的路径，无法分辨几条路径中哪条最短、走得对不\n对，手动数数工作量太大，输出以便检查）\n总而言之，这是一次酣畅淋漓的和 gpt 斗智斗勇的学习体验，真正让我体会到了什么叫做把人工智障教成\n人工智能，最终谁在教谁还不一定，让我对解决数据结构问题有了更深刻的认识，不得不感叹当年哪里\n有这么好的条件，但也意识到：我们必须成为学会使用新工具的程序员，而不是被新工具替代的程序\n员。
|
||
"""
|
||
dim = "交互过程或设计结果（10分）：\n9-10分：与AI的交互具有逻辑并且连贯，对AI的能够进行再次提问，整体结构完整且有条理，每个功能模块都包括交流和代码。\n7-8分：与AI的交互连贯，能够根据AI的回复进行下一轮问答，分模块与AI进行交互，每个模块都能较好完成且实现。\n5-6分：勉强完成任务，包含代码但是与AI交互的过程比较简单，与AI交互较有逻辑，整体文本的结构有一定的条理性，分模块与AI进行交互，每个模块都完成良好。\n3-4分：提问无条理、互动断裂，AI 使用被动，设计内容不完整或逻辑支离破碎，完成度较差，没有分模块与AI交互。\n0-2分：结构混乱，几乎无有效内容，仅有零碎交互记录，设计表达混乱、目标模糊，不能解决问题。\n"
|
||
result = getDim(content, dim)
|
||
print(result) |