图论经典A-Star(A*) Algorithm最短路径，networkx，Python（1）
A-Star Algorithm，即为A*（A星）算法，图的最短路径。
（1）A-Star(A*)算法需要事先知道起点和终点才能求出最优路径。A-Star算法大量运用在游戏编程中的人物角色选路AI程序中。现代游戏编程，涉及到路径选择和规划的，大部分基于A*算法实现。然而，如果算法启动前不知道终点（起点已知），那么无法使用A-Star算法。
（2）A*算法核心是启发函数 F = G+H，启发函数驱动A*算法。假设当前节点是V，G是节点V到出发点的距离，H是节点V到终点的距离。A*算法应用在空间平面的距离计算，通常由两种：欧几里德解析几何距离，曼哈顿距离。用的较多的是曼哈顿距离。
（3）A*算法工作过程：出发点start和终点goal已经知道，假设现在选定了某个节点V，对于某个节点V，V到出发点start的曼哈顿距离算出为G，V到终点goal的曼哈顿距离为H，则节点V的启发函数值F=G+H。
A*需要维护两个列表：open_list和close_list，当选定节点V后，把所有与V邻接的节点放入open_list中，把这些新加入的点的父记为V，然后把节点V放入到close_list。此时查找open_list中所有节点的具有最小F值的节点 V' （此处是 V' 撇，不是 V，表示V选好后，进行第二轮选点的那个节点），V' 选出来后，再次把 V' 所有相邻的节点加入到open_list中，同时把 V' 从open_list中删掉，并把V' 加入到close_list中去。
在查找 V' 的邻接节点步骤中，如果邻接的节点已经在close_list中，则忽略，同时，如果 V' 的某一个邻接点N已经在open_list中，则比较当前节点 V' 到N的距离
（4）最终路径的产生：从终点开始。逆向的从终点开始，找出终点保存的父节点指向谁，然后逆向，然后再找到终点的父节点的父节点......，一路逆行查找，直到查找到父节点为出发点为止，即为A*选出来的路径。
现在，我用python简单写了一个A-Star算法的实现，networkx主要用来绘制图和装配与节点相关的内容：
import random
import time
import networkx as nx
import matplotlib.pyplot as plt
G_DIS = 'g_dis'
H_DIS = 'h-dis'
F = 'F'
WALKABLE = 'walkable'
PARENT = 'parent'
def my_graph():
M = 7
N = 9
G = nx.grid_2d_graph(m=M, n=N)
pos = nx.spring_layout(G, iterations=100)
nx.draw_networkx(G, pos=pos,
# labels=labels, #labels = dict(((i, j), 'Phil') for i, j in G.nodes())
font_size=8,
font_color='white',
node_color='green',
node_size=500,
width=1)
START = (2, 1)
GOAL = (M - 1 - 1, N - 1 - 1)
obstacle = 20 # 障碍物（断点、不可达点）数量
road_closed_nodes = dummy_nodes(G) # obstacle_nodes(G, START, GOAL, obstacle, M, N)
nx.draw_networkx_nodes(
G, pos,
nodelist=road_closed_nodes,
node_size=500,
node_color="red",
node_shape="x",
# alpha=0.3,
label='x'
)
print('G.nodes(data=True)', G.nodes(data=True))
print('G.edges(data=True)', G.edges(data=True))
path = a_star(G, START, GOAL)
print('路线', path)
nx.draw_networkx_nodes(
G, pos,
nodelist=path,
node_size=400,
node_color="red",
node_shape='o',
# alpha=0.3,
# label='NO'
)
# 逆向的从父节点找出A*选的路。
path_edges = []
for i in range(len(path)):
if (i + 1) == len(path):
break
path_edges.append((path[i], path[i + 1]))
print('path_edges', path_edges)
# 把path着色加粗重新描边
nx.draw_networkx_edges(G, pos,
edgelist=path_edges,
width=8,
alpha=0.5,
edge_color="r")
plt.axis('off')
plt.show()
# 障碍物点
def obstacle_nodes(G, START, GOAL, obstacle, M, N):
road_closed_nodes = []
for i in range(obstacle):
time.sleep(0.01)
n = (random.randint(0, M - 1), random.randint(0, N - 1))
if n == START or n == GOAL:
continue
if n in road_closed_nodes:
continue
G.nodes[n][WALKABLE] = False
road_closed_nodes.append(n)
return road_closed_nodes
def dummy_nodes(G):
fun_nodes = []
n1 = (1, 3)
G.nodes[n1][WALKABLE] = False
fun_nodes.append(n1)
n2 = (1, 4)
G.nodes[n2][WALKABLE] = False
fun_nodes.append(n2)
n3 = (1, 5)
G.nodes[n3][WALKABLE] = False
fun_nodes.append(n3)
n4 = (1, 6)
G.nodes[n4][WALKABLE] = False
fun_nodes.append(n4)
n5 = (2, 6)
G.nodes[n5][WALKABLE] = False
fun_nodes.append(n5)
n6 = (3, 6)
G.nodes[n6][WALKABLE] = False
fun_nodes.append(n6)
n7 = (4, 6)
G.nodes[n7][WALKABLE] = False
fun_nodes.append(n7)
n8 = (5, 6)
G.nodes[n8][WALKABLE] = False
fun_nodes.append(n8)
n9 = (5, 5)
G.nodes[n9][WALKABLE] = False
fun_nodes.append(n9)
n10 = (5, 4)
G.nodes[n10][WALKABLE] = False
fun_nodes.append(n10)
n11 = (5, 3)
G.nodes[n11][WALKABLE] = False
fun_nodes.append(n11)
return fun_nodes
# A*寻路
def a_star(G, START, GOAL):
open_list = []
close_list = []
vertex = START
loop_flag = True
while loop_flag:
print('-----')
if vertex == GOAL:
print('到达', vertex)
close_list.append(vertex)
# loop_flag = False
break
print('选中', vertex)
close_list.append(vertex)
for node in nx.neighbors(G, vertex):
# 如果n在close_list或者不可行，忽略
try:
walkable = G.nodes[node][WALKABLE]
except:
walkable = True
print('walkable', walkable)
if (not walkable) or (node in close_list):
continue
print('遍历', node)
if node in open_list:
print(node, '在open_list')
node_g_dis = G.nodes[node][G_DIS]
vertex_g_dis = G.nodes[vertex][G_DIS]
sum_g_dis = manhattan(vertex, node) + vertex_g_dis
# 更新权值
if sum_g_dis < node_g_dis:
G.nodes[node][PARENT] = vertex
G.nodes[node][G_DIS] = sum_g_dis
G.nodes[node][F] = sum_g_dis + manhattan(GOAL, node)
else:
G.nodes[node][G_DIS] = manhattan(node, START)
h_dis = manhattan(node, GOAL)
G.nodes[node][H_DIS] = h_dis
sum_f_dis = G.nodes[node][G_DIS] + h_dis
G.nodes[node][F] = sum_f_dis
G.nodes[node][PARENT] = vertex
open_list.append(node)
# print('G.nodes(data=True)', G.nodes(data=True))
print('open_list', open_list)
f_list = []
for n in open_list:
f_list.insert(0, (n, G.nodes[n]))
print('f_list', f_list)
min_f = min(f_list, key=lambda x: x[1][F])
print('min_f', min_f)
point = min_f[0]
print('F最小点', point)
open_list.remove(min_f[0])
print('close_list', close_list)
print('open_list', open_list)
vertex = point
t = GOAL
path = [t]
is_find = False
while not is_find:
for n in G.nodes(data=True):
if n[0] == t:
parent = n[1][PARENT]
path.append(parent)
if parent == START:
is_find = True
break
t = parent
list.reverse(path)
return path
# 计算曼哈顿距离
def manhattan(u, v):
dis = abs(u[0] - v[0]) + abs(u[1] - v[1])
return dis
if __name__ == '__main__':
my_graph()
运行代码，跑几轮，看看程序选的路线如何。出发点是START，目的地是GOAL。图中标记红色叉（X）的节点是故意随机生成的断点、障碍物、陷阱，特意用来挑战A-Star算法智商 :-)，图中红‘X’表明这个节点不可通行，不能用于选路。障碍物点数量越多，选路难度越大，本例是20个（obstacle = 20）障碍物点。注意本例的随机障碍物点生成规则，程序生成的随机障碍物点如果刚好是起点或终点，则忽略；如果生成的随机障碍物点刚好已经在之前生成过，则同意忽略。这意味着，可能每次生成的随机障碍物点zong's不等于20，而是<=20。
最终的红色圆点即为出发点到终点的路线节点，把节点用淡红色粗线连起来，即为A*算法选出来的路线。
在本例出发点是(1,1)，终点是(5,7)。出发点和终点和程序代码开始的M，N值相关。
下面是运行了几轮程序，A*选择的路线（ 起点(1,1) -> 终点(5,7) ，红色点连成的淡红色（red，alpha=0.5）粗线为形成的路线）截图：
程序当前存在一些问题，对障碍物点没做特殊处理，只是不让障碍物刚好是起点和终点。如果随机生成的障碍物点把出发点和终点隔绝死，或者中间某处路隔绝断，程序就就选不到路运行错误。后续还需要对这个程序改进和优化。
下面来些有趣的内容：给A-Star算法挖坑，看它会不会跳进去 :-)
现在，针对A*算法的特点，我造一堵特殊的墙，一个凹形的墙。看看A星算法是否会跳进这堵墙形成的坑。实验的做法是修改起点和终点，把起点修改为(3,1)，终点修改为(3,7)。同时，不再随机生成障碍点，而是在(3,1)和(3,7)之间特意挑选一些位置、写死一批（9个点）不可通行的节点（仍然用X标记），这批不可通行的节点形成一个连续的凹形阻挡面，正面对(3,1)节点，程序运行几轮的截图：
A-Star聪明的绕过了这个大坑（凹形墙），顺利达到(3,7)点。
（未完待续...）
https://zhangphil.blog.csdn.net/article/details/121171499