1.算法描述
A*搜寻算法俗称A星算法,是比较流行的启发式搜索算法之一，被广泛应用于路径优化领域。它的独特之处是检查最短路径中每个可能的节点时引入了全局信息，对当前节点距终点的距离做出估计，并作为评价该节点处于最短路线上的可能性的量度。
A*改变它自己行为的能力基于启发式代价函数，启发式函数在游戏中非常有用。在速度和精确度之间取得折衷将会让你的游戏运行得更快。在很多游戏中，你并不真正需要得到最好的路径，仅需要近似的就足够了。而你需要什么则取决于游戏中发生着什么，或者运行游戏的机器有多快。
在本实验中，为了解决罗马尼亚度假问题而引入的A算法，目的是为了寻找一个城市到另一个城市的最短路径，A算法
扩展：本来想些启发式算法的，但是突然迷茫了一下，可以以后再写，好好的学一学。当我写这些东西的时候，我发现，自己还不是很懂。
以上多数文字直接来源于度娘百科，没有过多的修改。我对于A*算法的描述，着实少之又少，感觉自己又回到了最初的懵懂状态。
我需要一个比较好的数据集来解释自己想要时候的，直接用数据来描述自己想要表达的。
2.问题描述
旅行商问题：
In the following map with 20 cities, please find a route from Zerind to Bucharest using A search.*
[在一个拥有20个城市的图中，使用A星算法，找到一条最优路径从塞尔维亚到罗马尼亚]
解释：上述图中，线上的数字表示两个城市的实际距离。
右侧的数字表示到Bucharest[终点]的估计距离。
每个城市的首字母都不一样，可以数字化。
3.算法原理
A*算法是一种搜索算法，在算法过程中引入了F，G，H三个量。
下面引入具体数据，来演示A*算法：
.
说明：
注意事项：
过程：
.
.
.
.
， ，
.
， ， ，
.
， ， ， ，
.
， ， ， ，
.
， ， ， ， ，
.
， ， ， ， ， ，
.
， ， ， ， ， ， ， ，
.回溯： ， ， ， ， ， ， ，
最终结果：
具体的实验过程中需要用某种数据结构来保存父节点，以便回溯，而且最终G结点的F值，就是实际路程。
自我感觉良好，上面的那一段我输入了好长时间。不知道是什么原因，过程特别的卡顿，我猜是因为要解析好多的符号，可能需要消耗时间，比较少的时候还好，很多的话，就不如插入一张图片。这也是浏览器加载的时候需要注意的，加载一张图远比加载好多图来得快，所以会将好多图标都绘制在一张图上，在网页中只显示图片中的某一部分，这样一来，打开这样的网页，图片就只加载了一次。
流程图如下：
这是很久以前绘制的流程图，可能不是很准确但是是根据伪代码画出来的，应该不会有错。
伪代码：
4.算法源码
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# redefine place
A = 0 # Arad
B = 1 # Bucharest
C = 2 # Craiova
D = 3 # Dobreta
E = 4 # Eforie
F = 5 # Fagaras
G = 6 # Giurgiu
H = 7 # Hirsova
I = 8 # Iasi
L = 9 # Lugoj
M = 10 # Mehadia
N = 11 # Neamt
O = 12 # Oradea
P = 13 # Pitesti
R = 14 # Rimnicu Vilcea
S = 15 # Sibiu
T = 16 # Timisoara
U = 17 # Urziceni
V = 18 # Vaslui
Z = 19 # Zerind
# 构建一个20*20的矩阵
PLACES_NUM = 20
# 地图
class Graph:
def __init__(self):
self.romania_graph = [[0] * PLACES_NUM for i in range(PLACES_NUM)]
def add_edge(self, _from, _to, _value):
if _from < PLACES_NUM:
if _to < PLACES_NUM:
self.romania_graph[_from][_to] = _value
self.romania_graph[_to][_from] = _value
def get_edge(self, _from, _to):
return self.romania_graph[_from][_to]
#问题的最终解
class Stack:
def __init__(self):
self.stack = []
def push(self, value):
self.stack.append(value)
return
def pop(self):
return self.stack.pop()
def is_empty(self):
if self.stack:
return False
return True
# CLOSED表
class Queue:
def __init__(self):
self.queue = []
def put(self, value):
self.queue.append(value)
return
def get(self):
return self.queue.pop(0)
def contain(self, value):
return value in self.queue
def is_empty(self):
if self.queue:
return False
return True
# OPEN表
class PriorityQueue:
def __init__(self):
self.queue = []
def put(self, node_cost):
"""
:param node_cost: [value,cost]
"""
self.queue.append(node_cost)
def get(self):
if self.queue:
min_i = 0
min_cost = self.queue[min_i][1]
for i in range(len(self.queue)):
if self.queue[i][1] < min_cost:
min_i = i
min_cost = self.queue[i][1]
return self.queue.pop(min_i)
def contain(self,value):
for i in range(len(self.queue)):
if self.queue[i][0]==value:
return self.queue[i],True
return None,False
def is_empty(self):
if self.queue:
return False
return True
# initialize undirected graph
# 初始化无向图
def init_graph():
graph = Graph()
graph.add_edge(O, Z, 71)
graph.add_edge(O, S, 151)
graph.add_edge(A, Z, 75)
graph.add_edge(A, S, 140)
graph.add_edge(A, T, 118)
graph.add_edge(T, L, 111)
graph.add_edge(L, M, 70)
graph.add_edge(M, D, 75)
graph.add_edge(D, C, 120)
graph.add_edge(S, R, 80)
graph.add_edge(S, F, 99)
graph.add_edge(R, C, 146)
graph.add_edge(F, B, 211)
graph.add_edge(R, P, 97)
graph.add_edge(C, P, 138)
graph.add_edge(P, B, 101)
graph.add_edge(B, G, 90)
graph.add_edge(B, U, 85)
graph.add_edge(U, H, 98)
graph.add_edge(U, V, 142)
graph.add_edge(V, I, 92)
graph.add_edge(I, N, 87)
graph.add_edge(H, E, 86)
return graph
def a_star(graph, h, _root, _goal):
g = [0] * PLACES_NUM # g(n) value 现阶段搜索过程中的每个结点的g(n)记录@
parents = [0] * PLACES_NUM # temporary parents 现阶段搜索过程中的每个节点的父结点记录@
pq_open = PriorityQueue() # open queue 初始化open表@
q_close = Queue() # closed queue 初始化closed表@
s_path = Stack() # solution nodes path s_path中作为走过路径记录@
s_parent = Stack() # solution nodes' parents path s_parent中作为open表每次pop的记录@
pq_open.put([_root, 0]) #将初始结点存入OPEN表中@
while pq_open.is_empty()==False:
parrent_node=pq_open.get()
if parrent_node[0]==_goal:
break
q_close.put(parrent_node[0])
for i in range(20):
length=graph.get_edge(parrent_node[0],i)
if length!=0:
node,result=pq_open.contain(i)
f=parrent_node[1]-h[parrent_node[0]]+length+h[i]
if q_close.contain(i):
continue
elif result==True:
if node[1]>f:
node.pop()
parents[i]=parrent_node[0]
pq_open.put([i,f])
else:
parents[i]=parrent_node[0]
pq_open.put([i,f])
path=[]
cost=0
print("parents:",parents)
p=_goal
while p!=_root:
cost+=graph.get_edge(p,parents[p])
path.append(p);
p=parents[p]
length=len(path)-1
print('path:',_root,end='')
for i in range(length+1):
print(" -->",path[length-i],end='')
print()
return cost
if __name__ == '__main__':
graph = init_graph()
# 怎么才能够获取到这个矩阵
h = (366, 0, 160, 242, 161,
178, 77, 151, 226, 244,
241, 234, 380, 98, 193,
253, 329, 80, 199, 374)
# place_str = input()
# places = place_str.split()
# cost = a_star(graph, h, eval(places[0]), eval(places[1]))
print("node","A"," B")
cost = a_star(graph, h,eval('A'),eval('B'))
print('cost:',cost)
print()
print("node","C"," B")
cost = a_star(graph, h,eval('C'),eval('B'))
print('cost:',cost)
print()
print("node","U"," B")
cost = a_star(graph, h,eval('U'),eval('B'))
print('cost:',cost)
print()
备注：
- 保存好源码之后，自己多写几个print来看一看各个数据都是什么，避免超级低级的错误。
- 源码总注释比较少，为何？因为有了流程图，以及上面的展示，A*算法的思想还是很容易就可以理解的，而且算法部分的代码很容易就能够看懂。
话说我也不知道是为什么，我上传代码之后竟然没有高亮显示，感觉很奇怪，是不是我等级尚低，修为尚浅，还是因为之前的代码都是MATLAB代码。- 代码最后的部分，注释掉的三行是用来控制台输入的，但是鉴于Sublime Text3中input()函数不好用，我直接弄成了固定的测试数据。
- 代码中最后的cost计算，可以直接从A*算法中得到，
并不需要使用回溯的方法，所以我这里这样写，纯属画蛇添足，但是因为要输出路径，所以顺带算了一下。
5.算法输出
6.总结
不难。但是却囿于有限的知识，而不能够将其进行扩展，A*算法是一种比较好的寻路算法，在游戏中会经常使用到，在Unity中有特定的寻路算法，也有一部分人是自己写的算法，自己写的话有什么好处呢？
倘若是自己写的寻路算法，在寻路的时候，可以给AI加上好多东西，这样可以让AI看上去不是那么傻？现在还是有一些疑惑的，寻路的时候是将地图当成了一个类似于坐标系一样的东西，中间遇到障碍物就会换路，而且是找到一条路径之后，AI才会出发，也就是说AI提前就知道一条路径，o( ￣︶￣ )o。
那么怎么把现在的这种数据跟游戏中寻路数据对应起来呢？好晕。找了一些个链接，有时间的时候可以看一看，或者就最近这一段时间看一看。
链接如下：
- A星算法详解(个人认为最详细,最通俗易懂的一个版本)
- A* Pathfinding for Beginners(不用外网)
- 堪称最好最全的A*算法详解（译文）
- Amit’s A* Pages(不用外网)
应该尝试用各种编程语言写该算法，因为不能容忍自己的菜！！！
