大模型应用：最优路径规划实践：A*算法找最优解，大模型做自然语言解释.91

Ne0inhk

21 Mar 2026 — 26 min read

一、引言

算法是个很有意义的课题，尽管大模型让我们不需要像以前学习机器学习那样，需要很深的数学基础，但结合算法来应用大模型确实是个很有趣的事情，传统算法经过数十年发展，已在路径规划、优化计算等领域达到极高的精确度；另一方面，大语言模型的崛起让人机交互变得前所未有的自然流畅。然而，一个不容忽视的现实是：再精确的算法，如果用户看不懂、不会用，就只是实验室里的玩具；再流畅的表达，如果缺乏技术可靠性，就只是华丽的空谈。

想象这样一个场景：导航系统为你计算出了一条理论上最优的路线，却只能用一串坐标告诉你怎么走；或者，一个能言善道的助手热情地为你指路，却把你带进了死胡同。这两种情况，本质上都是技术能力与用户体验之间的断裂。这种断裂并非偶然，而是单一技术路线的固有局限。算法擅长计算却不善表达，模型善于沟通却难以精确，各有所长，也各有所短。因此，真正的突破不在于让某一方变得更强大，而在于让两者形成互补协作的关系，用各自的长处弥补对方的短板。

这是我们今天想探讨得A*算法与大模型融合的核心价值所在。A*算法如同精密的"空间计算大脑"，保证路径的数学最优性；大模型则如同清晰的"表达嘴巴"，让算法结果变得可理解、可执行。二者结合，才能跨越技术与用户之间的鸿沟，打造出真正可用的智能导航系统，既有数学的严谨，又有人文的温度。

二、基础介绍

1. A* 算法

1.1 算法介绍：

A* 算法是整个智能导航系统的计算核心，数学层面的最优路径搜索，负责在复杂的图结构或空间网格中进行启发式搜索，找到从起点到终点的最优路径。它通过评估函数智能地探索搜索空间：

f(n) = g(n) + h(n)

其中：

g(n)：代表从起点到当前节点的实际代价；
h(n)：代表从当前节点到目标点的估计代价，重要的启发函数；
f(n)：总代价，A* 每次选 f (n) 最小的节点走；

这一算法的核心价值在于保证路径的数学最优性，无论是追求最短距离、最快时间还是最省资源，A* 都能在满足约束条件的前提下找到理论上的最优解。它像一位精密的数学家，默默计算着每一个可能的路径组合，确保最终输出的路线在技术层面是无懈可击的。

然而，A* 算法的输出本质上是冷冰冰的坐标序列或节点列表。它知道怎么走最优，却无法解释为什么这样走，更无法用人类自然的方式告诉用户"前方路口右转，看到红色建筑后直行"。这就是它的局限，精于计算，拙于表达。

1.2 A* 算法的最优说明：

只要启发函数h(n) 满足可采纳性，即永远不大于真实代价，A*就一定能找到最短路径，且效率远高于暴力搜索。

1.3 最常用启发函数：

- 1. 网格地图（四向移动）：曼哈顿距离

适用场景：只能上下左右四个方向移动的网格地图
计算公式：h = |x₁ - x₂| + |y₁ - y₂|
含义说明：横向距离差的绝对值 + 纵向距离差的绝对值
示例：
- 起点坐标：(2, 3)
- 终点坐标：(7, 8)
- 启发值 h = |2-7| + |3-8| = 5 + 5 = 10

- 2. 网格地图（八向/任意方向）：欧几里得距离

适用场景：可以向八个方向或任意角度移动的地图
计算公式：h = √[(x₁ - x₂)² + (y₁ - y₂)²]
含义说明：两点之间直线距离的平方根
示例：
- 起点坐标：(2, 3)
- 终点坐标：(7, 8)
- 启发值 h = √[(2-7)² + (3-8)²] = √(25 + 25) = √50 ≈ 7.07

核心原则：启发函数 h(n) 必须≤实际代价，才能保证 A* 找到最优路径，即启发函数需满足可采纳性

1.4 A* 算法完整执行流程：

流程说明：

1. 初始化起点、终点、障碍物地图
2. 维护两个集合：
- open list：待检查的节点
- closed list：已经检查过的节点
3. 把起点加入 open list
4. 循环：
- 从 open list 中选出 f (n) 最小的节点作为当前节点
- 把当前节点移入 closed list
- 如果当前节点是终点 → 回溯得到完整路径
- 遍历当前节点的上下左右 / 八邻域邻居
- 对每个有效邻居：
  - 不在 closed list 且不是障碍物
  - 计算新的 g、h、f
  - 若更优，则更新父节点、加入 open list
5. 回溯父节点，从终点倒推回起点 → 得到最优路径

2. 大模型加持

大模型是整个智能导航系统的交互核心，基于自然语言层面的路径解释，负责将 A* 算法输出的结构化路径数据转化为人类可理解、可执行的自然语言指令。它能够理解用户的意图，将抽象的坐标和步骤转化为流畅的导航描述，并能根据上下文进行多轮对话交互。

大模型的核心价值在于降低技术门槛，让算法结果"能用、易懂"：

它可以将"坐标点序列 [(116.4, 39.9), (116.41, 39.91), ...]"转化为"从当前位置出发，
沿主干道向北行驶约 5 公里，在第二个红绿灯路口左转，
看到加油站后继续直行 200 米即达目的地"。

这种转化不仅仅是语言风格的改变，更是人机交互体验的本质提升。但大模型也有其局限，它可能产生幻觉，数值计算不够精确，无法保证路径的数学最优性。因此，它需要与精确算法配合使用，而非独立承担路径规划的核心计算任务。

3. 组合价值

3.1 算法 = 大脑的空间计算

纯算法的痛点，A* 只会输出：

坐标序列：(0,0) → (1,0) → (2,1) → …
步骤编号：Step1、Step2、Step3

不利于理解，既看不懂，也用不了，此时的算法价值体现：

A* 算法如同系统的大脑，负责所有需要精确计算和逻辑推理的任务。
它在后台默默工作，处理复杂的空间关系、代价函数和优化目标，确保每一条推荐路径都经得起数学验证。
没有这个“大脑”，系统就失去了精确性和可靠性。

3.2 大模型 = 嘴巴的清晰表达

大模型如同系统的嘴巴，负责将所有计算结果以人类友好的方式表达出来。
它理解用户的语言，回应用户的疑问，并根据不同用户的表达习惯调整输出风格。
没有这个"嘴巴"，再精确的计算结果也无法被用户有效理解和使用。

简而言之，大模型做这 4 件事：

1. 把路径坐标 → 自然语言导航例：向右走2格，再向上走1格，绕过障碍物
2. 把抽象任务 → 结构化步骤例：旅行规划、学习路径、解题流程
3. 支持自然语言输入用户说：“帮我规划从家到公司的路线”
4. 人性化解释为什么这么走？最近？最快？最省钱？

3.3 二者结合的必要性

只有大脑没有嘴巴：系统能算出最优路径，但用户看不懂、不会用，最终沦为算法玩具。
只有嘴巴没有大脑：系统能说会道，但给出的路线可能绕远、甚至无法通行，缺乏技术可靠性。
大脑 + 嘴巴结合：系统既能保证路径的数学最优性，又能让用户轻松理解和执行，这才是真正可用的智能导航系统。

A* + 大模型结合使用：

用户自然语言请求 → 大模型解析：起点、终点、约束、偏好 → A*算法计算最优路径↓大模型把路径翻译成可阅读、可执行的自然语言导航 → 返回给用户

4. 工作流

从用户请求到智能输出，整个系统的工作流程形成一条清晰的数据流转链路：

第一步：意图理解

用户发起自然语言请求，如"帮我规划一条从酒店到博物馆的路线，我想沿途看看老街"。
大模型首先进行意图识别，提取关键信息（起点、终点、偏好约束），将其转化为结构化查询参数。

第二步：路径计算

结构化参数传递给 A* 算法层，算法在地图数据中进行启发式搜索；
考虑距离、时间、用户偏好等多重因素，返回最优路径的坐标序列和关键节点信息。

第三步：结果解释

路径数据再次交由大模型进行自然语言生成，将坐标序列转化为流畅的导航指令；
并根据用户偏好添加个性化建议，如"沿途会经过百年老街，建议预留 30 分钟参观"。

第四步：交互反馈

用户可以通过多轮对话进一步调整需求，如"避开高速公路"或"想路过某家餐厅"，系统会重新调用 A* 算法计算新路径；
并由大模型生成更新后的导航说明，形成完整的交互闭环。

三、整体执行流程

支持自然语言、结构化两种输入，大模型做解析；
A* 负责核心计算，大模型负责交互和解释；
增加用户确认环节，支持大模型迭代优化解释结果。

步骤说明：

1. 用户输入：用户提交导航请求，可以是自然语言或结构化坐标
2. 输入类型判断：自然语言 → 进入大模型解析；结构化坐标 → 直接进入路径计算
3. 大模型解析：从自然语言中提取起点、终点、约束条件、场景信息
4. A*算法计算：基于提取的信息进行最优路径搜索
5. 输出路径+代价：返回最优路径坐标序列和总代价
6. 大模型Prompt构建：为路径生成构建提示词模板
7. 大模型生成解释：将路径数据转化为自然语言导航说明
8. 输出结果：向用户展示导航结果
9. 用户确认：满意 → 流程结束；不满意 → 大模型优化解释，重新生成
10. 结束：用户确认满意后流程终止

四、示例分析

1. A* 算法基础示例

绕开障碍物探索左右路径；

import heapq import matplotlib.pyplot as plt import matplotlib.patches as patches def manhattan(a, b): return abs(a[0] - b[0]) + abs(a[1] - b[1]) def a_star(start, end, grid): rows = len(grid) cols = len(grid[0]) open_heap = [] heapq.heappush(open_heap, (0, start)) came_from = {} g_score = {(i, j): float('inf') for i in range(rows) for j in range(cols)} g_score[start] = 0 directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] while open_heap: f_current, current = heapq.heappop(open_heap) if current == end: path = [] while current in came_from: path.append(current) current = came_from[current] path.append(start) return path[::-1] for dx, dy in directions: x = current[0] + dx y = current[1] + dy neighbor = (x, y) if 0 <= x < rows and 0 <= y < cols: if grid[x][y] == 1: continue tentative_g = g_score[current] + 1 if tentative_g < g_score[neighbor]: came_from[neighbor] = current g_score[neighbor] = tentative_g f = tentative_g + manhattan(neighbor, end) heapq.heappush(open_heap, (f, neighbor)) return None if __name__ == "__main__": # 0=可走, 1=障碍 grid = [ [0, 1, 0, 0, 0], [0, 1, 0, 1, 0], [0, 0, 0, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0], ] start = (0, 0) end = (4, 4) path = a_star(start, end, grid) print("最优路径坐标：") print(path) # 设置中文字体 plt.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei'] plt.rcParams['axes.unicode_minus'] = False plt.rcParams['font.family'] = 'sans-serif' # 创建图形 fig, ax = plt.subplots(figsize=(10, 10)) rows = len(grid) cols = len(grid[0]) # 绘制网格 for i in range(rows): for j in range(cols): if grid[i][j] == 1: # 障碍物 - 深灰色 rect = patches.Rectangle((j, rows-1-i), 1, 1, linewidth=1, edgecolor='black', facecolor='#555555') ax.add_patch(rect) else: # 可行走区域 - 浅灰色 rect = patches.Rectangle((j, rows-1-i), 1, 1, linewidth=1, edgecolor='black', facecolor='#e0e0e0') ax.add_patch(rect) # 绘制路径 if path: # 提取x,y坐标（注意y轴翻转） path_x = [p[1] + 0.5 for p in path] path_y = [rows - 1 - p[0] + 0.5 for p in path] ax.plot(path_x, path_y, 'b-', linewidth=3, label='最优路径', alpha=0.8) # 绘制路径箭头 for i in range(len(path) - 1): x1, y1 = path[i][1] + 0.5, rows - 1 - path[i][0] + 0.5 x2, y2 = path[i+1][1] + 0.5, rows - 1 - path[i+1][0] + 0.5 dx, dy = x2 - x1, y2 - y1 ax.arrow(x1, y1, dx * 0.6, dy * 0.6, head_width=0.15, head_length=0.15, fc='blue', ec='blue', alpha=0.7) # 绘制起点 ax.plot(start[1] + 0.5, rows - 1 - start[0] + 0.5, 'go', markersize=20, label='起点', zorder=5) ax.text(start[1] + 0.5, rows - 1 - start[0] + 0.5, '起点', ha='center', va='center', fontsize=10, color='white', fontweight='bold', fontfamily='Microsoft YaHei', zorder=6) # 绘制终点 ax.plot(end[1] + 0.5, rows - 1 - end[0] + 0.5, 'ro', markersize=20, label='终点', zorder=5) ax.text(end[1] + 0.5, rows - 1 - end[0] + 0.5, '终点', ha='center', va='center', fontsize=10, color='white', fontweight='bold', fontfamily='Microsoft YaHei', zorder=6) # 设置坐标轴 ax.set_xlim(0, cols) ax.set_ylim(0, rows) ax.set_aspect('equal') ax.set_xticks(range(cols + 1)) ax.set_yticks(range(rows + 1)) ax.grid(True, alpha=0.3) # 设置标题和标签 ax.set_title('A* 算法路径搜索可视化', fontsize=16, fontweight='bold', fontfamily='Microsoft YaHei') ax.set_xlabel('X 坐标', fontsize=12, fontfamily='Microsoft YaHei') ax.set_ylabel('Y 坐标', fontsize=12, fontfamily='Microsoft YaHei') # 添加图例 ax.legend(loc='upper left', fontsize=10) # 添加说明文本 info_text = ( f"起点: {start}\n" f"终点: {end}\n" f"路径长度: {len(path) if path else 0}\n" f"障碍物数量: {sum(row.count(1) for row in grid)}" ) ax.text(cols - 0.2, rows - 0.2, info_text, ha='right', va='top', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8), fontsize=10, fontfamily='Microsoft YaHei') plt.tight_layout() plt.savefig('91.A算法_路径搜索可视化.png', dpi=150, bbox_inches='tight') plt.show()

输出结果：

最优路径坐标：
[(0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4)]

结果图示：

2. 大模型融合实践

1. A*路径规划引擎：实现带地形代价的A*算法，在网格地图中搜索最优路径。基础移动代价为1，山地等地形增加额外代价，障碍物不可通行，保证路径数学最优。
2. 混元大模型集成：调用混元API将A*输出的坐标序列转化为自然语言导航。支持旅行规划、解题指导、任务流程三种场景，每种场景有定制化的Prompt模板。
3. 路径可视化：使用Matplotlib绘制完整地图：白色=平地、黑色=障碍物、黄橙色=山路，蓝色线条标注最优路径，绿色/红色标记起点终点。

import os import json import matplotlib.pyplot as plt import numpy as np from openai import OpenAI plt.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei', 'Arial Unicode MS', 'DejaVu Sans'] plt.rcParams['axes.unicode_minus'] = False plt.rcParams['font.family'] = 'sans-serif' # 配置腾讯混元API api_key = 'sk-*******************************gmm0sBVXvZ5NP8Ze' client = OpenAI( api_key=api_key, base_url="https://api.hunyuan.cloud.tencent.com/v1", ) def call_llm(prompt, model="hunyuan-lite"): """调用腾讯混元大模型生成自然语言导航""" try: completion = client.chat.completions.create( model=model, messages=[ {"role": "system", "content": "你是一个专业的路径解释助手,输出简洁、易懂、可执行的自然语言内容。"}, {"role": "user", "content": prompt} ], temperature=0.3 # 低随机性,保证结果稳定 ) return completion.choices[0].message.content except Exception as e: return f"调用混元大模型失败: {str(e)}" def build_llm_prompt(path, grid, cost_map, scene_type): """ 构建大模型的Prompt，适配不同场景 :param path: A*输出的路径坐标列表 :param grid: 网格地图 :param cost_map: 代价地图 :param scene_type: 场景类型（travel/study/task） :return: 结构化Prompt """ # 1. 路径解析：把坐标转化为"步骤+方向+代价" path_steps = [] for i in range(1, len(path)): prev = path[i-1] curr = path[i] # 方向判断 if curr[0] > prev[0]: direction = "向下（北）" elif curr[0] < prev[0]: direction = "向上（南）" elif curr[1] > prev[1]: direction = "向右（东）" elif curr[1] < prev[1]: direction = "向左（西）" # 代价计算：基础代价1 + 地形额外代价 base_cost = 1 terrain_cost = cost_map[curr[0]][curr[1]] step_cost = base_cost + terrain_cost path_steps.append({ "步骤": i, "从": prev, "到": curr, "方向": direction, "基础代价": base_cost, "地形代价": terrain_cost, "单步总代价": step_cost }) # 2. 场景化Prompt scene_prompts = { "travel": f""" 你是旅行规划助手，请根据以下A*算法计算的最优路径，生成自然语言旅行导航： 1. 地图说明：0=平地（易走），1=障碍物（不可走），代价>0=山路（难走）； 2. 路径步骤：{path_steps}； 3. 总代价：{sum([s['单步总代价'] for s in path_steps])}； 要求： - 用口语化的旅行导航语言，避免坐标； - 提示山路/障碍等注意事项； - 给出总行程和难度评价； - 示例格式： 「从起点出发，先向北走200米（平地），再向东绕开障碍物，接着向东北走500米（山路，注意防滑），最终到达终点。全程约700米，难度中等。」 """, "study": f""" 你是解题步骤助手，请根据以下A*算法计算的最优解题路径，生成自然语言解题指导： 1. 路径步骤：{path_steps}（每个坐标代表一个解题状态，步骤代表推理环节）； 2. 代价说明：代价越高，该步骤难度越大； 要求： - 把抽象步骤转化为"解题思路+具体操作"； - 标注高难度步骤的注意事项； - 示例格式： 「解题第一步：先梳理已知条件（难度低），第二步：推导中间公式（难度中等），第三步：代入数值计算（难度高，注意单位换算），最终得到答案。」 """, "task": f""" 你是任务流程助手，请根据以下A*算法计算的最优任务路径，生成自然语言任务清单： 1. 路径步骤：{path_steps}（每个坐标代表一个任务节点，步骤代表执行顺序）； 2. 代价说明：代价越高，该任务耗时/成本越高； 要求： - 按优先级排序，标注每个任务的耗时/成本； - 提示避开"障碍物"（风险点）； - 示例格式： 「任务1：收集需求（耗时1小时，低成本）→ 任务2：设计方案（耗时3小时，中成本，避开需求变更风险）→ 任务3：落地执行（耗时5小时，高成本）→ 完成。」 """ } return scene_prompts[scene_type] def visualize_path(grid, path, cost_map, start, end): """ 可视化A*算法找到的路径 :param grid: 网格地图 :param path: 路径坐标列表 :param cost_map: 代价地图 :param start: 起点坐标 :param end: 终点坐标 """ fig, ax = plt.subplots(figsize=(10, 10)) # 转换为numpy数组方便处理 grid_array = np.array(grid) cost_array = np.array(cost_map) # 创建颜色映射 # 0=平地(白色), 1=障碍物(黑色), >0=山路(渐变黄到橙) color_grid = np.zeros_like(grid_array, dtype=float) for i in range(len(grid_array)): for j in range(len(grid_array[0])): if grid_array[i][j] == 1: color_grid[i][j] = 1.0 # 障碍物 elif cost_array[i][j] > 0: color_grid[i][j] = 0.5 + cost_array[i][j] * 0.1 # 山路渐变 # 绘制网格背景 cmap = plt.cm.colors.ListedColormap(['white', 'lightyellow', 'orange', 'red']) ax.imshow(color_grid, cmap=cmap, origin='upper', interpolation='nearest') # 绘制网格线 for i in range(len(grid_array) + 1): ax.axhline(i - 0.5, color='gray', linewidth=0.5, alpha=0.3) ax.axvline(i - 0.5, color='gray', linewidth=0.5, alpha=0.3) # 标注代价数值 for i in range(len(grid_array)): for j in range(len(grid_array[0])): if grid_array[i][j] == 0: if cost_array[i][j] > 0: ax.text(j, i, f'代价:{cost_array[i][j]}', ha='center', va='center', fontsize=8, color='red') # 绘制路径 if path and len(path) > 1: path_array = np.array(path) ax.plot(path_array[:, 1], path_array[:, 0], 'b-', linewidth=3, label='最优路径', alpha=0.8) # 绘制路径节点 ax.scatter(path_array[:, 1], path_array[:, 0], c='blue', s=100, zorder=5, edgecolors='white', linewidth=2) # 标记起点和终点 ax.scatter(start[1], start[0], c='green', s=300, marker='o', label='起点', zorder=10, edgecolors='black', linewidth=2) ax.text(start[1], start[0], '起点', ha='center', va='center', fontsize=10, fontweight='bold', color='white', zorder=11) ax.scatter(end[1], end[0], c='red', s=300, marker='s', label='终点', zorder=10, edgecolors='black', linewidth=2) ax.text(end[1], end[0], '终点', ha='center', va='center', fontsize=10, fontweight='bold', color='white', zorder=11) # 添加图例和标题 ax.legend(loc='upper left', fontsize=12, framealpha=0.9) ax.set_title('A*算法路径规划可视化\n白色=平地 | 黑色=障碍物 | 黄色/橙色=山路', fontsize=14, pad=20) ax.set_xlabel('X坐标', fontsize=12) ax.set_ylabel('Y坐标', fontsize=12) ax.grid(True, alpha=0.3) # 调整布局 plt.tight_layout() # 保存图片 plt.savefig('A星算法路径可视化.png', dpi=300, bbox_inches='tight') print(f"\n图片已保存为: A星算法路径可视化.png") plt.show() plt.close() # ------------- 完整流程测试 ------------- if __name__ == "__main__": # 先定义A*算法（需要导入或实现） import heapq def a_star_advanced(start, end, grid, cost_map): """ A*算法实现，考虑地形代价 :param start: 起点坐标 :param end: 终点坐标 :param grid: 地图网格 :param cost_map: 代价地图 :return: 路径列表, 总代价 """ def heuristic(a, b): return abs(a[0] - b[0]) + abs(a[1] - b[1]) open_set = [] heapq.heappush(open_set, (0 + heuristic(start, end), 0, start)) came_from = {} g_score = {start: 0} cost = {start: 1} while open_set: _, current_g, current = heapq.heappop(open_set) if current == end: path = [] while current in came_from: path.append(current) current = came_from[current] path.append(start) path.reverse() return path, g_score[end] for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]: neighbor = (current[0] + dx, current[1] + dy) if 0 <= neighbor[0] < len(grid) and 0 <= neighbor[1] < len(grid[0]): if grid[neighbor[0]][neighbor[1]] == 1: continue new_cost = 1 + cost_map[neighbor[0]][neighbor[1]] tentative_g_score = g_score[current] + new_cost if neighbor not in g_score or tentative_g_score < g_score[neighbor]: came_from[neighbor] = current g_score[neighbor] = tentative_g_score f_score = tentative_g_score + heuristic(neighbor, end) heapq.heappush(open_set, (f_score, tentative_g_score, neighbor)) return None, float('inf') # 1. 定义地图和代价 grid = [ [0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 1, 0, 1, 0], [0, 0, 0, 1, 0, 1, 0], [0, 1, 1, 1, 0, 1, 0], [0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0] ] cost_map = [ [0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 2, 0, 0], [0, 2, 0, 0, 2, 0, 0], [0, 0, 0, 0, 2, 0, 0], [0, 2, 2, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 2, 0, 2, 0] ] start = (0, 0) end = (6, 6) # 2. 执行A*算法 path, total_cost = a_star_advanced(start, end, grid, cost_map) if path: print(f"\n=== A*算法计算结果 ===") print(f"路径: {path}") print(f"总代价: {total_cost}") # 3. 输出总代价计算过程 print(f"\n=== 总代价计算过程 ===") total_calculated = 0 for i in range(1, len(path)): prev = path[i-1] curr = path[i] # 方向判断 if curr[0] > prev[0]: direction = "向下（北）" elif curr[0] < prev[0]: direction = "向上（南）" elif curr[1] > prev[1]: direction = "向右（东）" else: direction = "向左（西）" base_cost = 1 terrain_cost = cost_map[curr[0]][curr[1]] step_cost = base_cost + terrain_cost total_calculated += step_cost print(f"步骤{i}: 从{prev} 到{curr} ({direction})") print(f" └─ 基础移动代价: {base_cost} + 地形额外代价: {terrain_cost} = 单步代价: {step_cost}") print(f"\n总代价 = {total_calculated}") print(f"(验证: {total_calculated} == {total_cost} -> {'✓ 通过' if total_calculated == total_cost else '✗ 失败'})") # 4. 可视化路径 visualize_path(grid, path, cost_map, start, end) # 5. 构建旅行场景的Prompt prompt = build_llm_prompt(path, grid, cost_map, "travel") # 6. 调用混元大模型 llm_response = call_llm(prompt) # 7. 输出结果 print("\n=== 混元大模型自然语言导航 ===") print(llm_response) else: print("未找到可行路径")

Prompt 工程要点：

结构化输入：把 A * 的路径、代价、障碍物等信息结构化，避免大模型误解；
场景化指令：不同场景用不同的语言风格（旅行 = 口语化，解题 = 专业，任务 = 结构化）；
低温度参数：temperature=0.1~0.3，保证输出稳定（路径解释需准确，而非创意）。

大模型输出校验：

增加 “事实校验” 环节：让大模型输出后，核对路径步骤是否与 A * 结果一致；
示例校验 Prompt：“请检查你输出的导航步骤是否与路径坐标 {path} 一致，若不一致请修正。”

输出结果：

=== A*算法计算结果 ===
路径: [(0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0), (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6)]
总代价: 18

=== 总代价计算过程 ===
步骤1: 从(0, 0) 到(1, 0) (向下（北）)
└─ 基础移动代价: 1 + 地形额外代价: 0 = 单步代价: 1
步骤2: 从(1, 0) 到(2, 0) (向下（北）)
└─ 基础移动代价: 1 + 地形额外代价: 0 = 单步代价: 1
步骤3: 从(2, 0) 到(3, 0) (向下（北）)
└─ 基础移动代价: 1 + 地形额外代价: 0 = 单步代价: 1
步骤4: 从(3, 0) 到(4, 0) (向下（北）)
└─ 基础移动代价: 1 + 地形额外代价: 0 = 单步代价: 1
步骤5: 从(4, 0) 到(5, 0) (向下（北）)
└─ 基础移动代价: 1 + 地形额外代价: 0 = 单步代价: 1
步骤6: 从(5, 0) 到(6, 0) (向下（北）)
└─ 基础移动代价: 1 + 地形额外代价: 0 = 单步代价: 1
步骤7: 从(6, 0) 到(6, 1) (向右（东）)
└─ 基础移动代价: 1 + 地形额外代价: 0 = 单步代价: 1
步骤8: 从(6, 1) 到(6, 2) (向右（东）)
└─ 基础移动代价: 1 + 地形额外代价: 2 = 单步代价: 3
步骤9: 从(6, 2) 到(6, 3) (向右（东）)
└─ 基础移动代价: 1 + 地形额外代价: 2 = 单步代价: 3
步骤10: 从(6, 3) 到(6, 4) (向右（东）)
└─ 基础移动代价: 1 + 地形额外代价: 0 = 单步代价: 1
步骤11: 从(6, 4) 到(6, 5) (向右（东）)
└─ 基础移动代价: 1 + 地形额外代价: 2 = 单步代价: 3
步骤12: 从(6, 5) 到(6, 6) (向右（东）)
└─ 基础移动代价: 1 + 地形额外代价: 0 = 单步代价: 1

总代价 = 18
(验证: 18 == 18 -> ✓ 通过)

图片已保存为: A星算法路径可视化.png

=== 混元大模型自然语言导航 ===
「从起点开始，先向北走100米（平地），然后一直向北走500米（山路，小心路滑），最后向东走100米就到了。整个行程大概700米，难度算是中等哦！」

结果图示：

五、总结

A*算法和大模型的结合，核心就是互补，A*算法负责把事做对，找最最优的路径，算得准、不跑偏，但它输出的那些坐标，普通人看了一脸懵；大模型就负责把事说清，不用复杂术语，把冰冷的坐标变成能直接照着走的话，让算法真正能用起来，而不是藏在代码里的玩具。算法我们经历的也很多，其实不用一味追求算法多复杂，也不用觉得大模型多高深，能落地、能解决实际问题才最重要。

结合今天的示例，先跑通基础流程，把 A*算法的路径算出来，再用现成的大模型模板，把路径翻译成自然语言，先实现核心功能，再慢慢打磨细节。另外，Prompt 一定要写规范，别直接丢坐标给大模型，先做好路径预处理，这样大模型输出的内容才准、才实用。总的来说，二者结合的关键，就是让算法的理性和大模型的感性结合起来，既保证路径最优，又保证普通人能看懂、能用好，这才是这种技术融合的真正意义。