本文博客链接:http://blog.csdn.net/jdh99,作者:jdh,转载请注明.
环境：
主机:WIN10
python版本:3.5
开发环境:pyCharm
一致代价搜索是宽度搜索的进化版。本算法是最优算法。
本算法每次扩展的是当前路径消耗g(n)最小的节点n。
算法流程分析：
数据结构：
- frontier：边缘。存储未扩展的节点。优先级队列，按路径消耗来排列
- explored：探索集。存储的是状态
流程：
- 如果边缘为空，则返回失败。操作：EMPTY?(frontier)
- 否则从边缘中选择一个叶子节点。操作：POP(frontier)
- 目标测试：通过返回，否则将叶子节点的状态放在探索集
- 遍历叶子节点的所有动作
- 每个动作产生子节点
- 如果子节点的状态不在探索集或者边缘，则插入到边缘集合。操作：INSERT(child, frontier)
- 否则如果边缘集合中如果存在此状态且有更高的路径消耗，则用子节点替代边缘集合中的状态
分析最优性：
A是起点，C是终点。
一致代价搜索算法执行：
- A放入frontier
- ---第1次
- 从frontier中取出A（此时路径消耗最小）检测发现不是目标
- A放入explored
- 遍历A的子节点，D和B放入frontier
- ---第2次
- 从frontier中取出D（此时路径消耗最小）检测发现不是目标
- D放入explored
- 遍历D的子节点，C放入frontier
- ---第3次
- 从frontier中取出B（此时路径消耗最小）检测发现不是目标
- B放入explored
- 遍历B的子节点，E放入frontier
- ---第4次
- 从frontier中取出E（此时路径消耗最小）检测发现不是目标
- E放入explored
- 遍历E的子节点，C准备放入frontier，发现此时frontier已有C，但路径消耗为8大于7，则替代frontier中的C
- ---第5次
- 从frontier中取出C（此时路径消耗最小）检测发现是目标，成功
- 最优路径：A->B->E->C
从上例可以看出，一致代价搜索具有最优性，关键在于frontier中存储是按路径消耗顺序来排序的。
算法性能分析：
- 完备的
- 不是最优的
- 时间/空间复杂度
import pandas as pd
from pandas import Series, DataFrame
# 城市信息：city1 city2 path_cost
_city_info = None
# 按照路径消耗进行排序的FIFO,低路径消耗在前面
_frontier_priority = []
# 节点数据结构
class Node:
def __init__(self, state, parent, action, path_cost):
self.state = state
self.parent = parent
self.action = action
self.path_cost = path_cost
def main():
global _city_info
import_city_info()
while True:
src_city = input('input src city\n')
dst_city = input('input dst city\n')
# result = breadth_first_search(src_city, dst_city)
result = uniform_cost_search(src_city, dst_city)
if not result:
print('from city: %s to city %s search failure' % (src_city, dst_city))
else:
print('from city: %s to city %s search success' % (src_city, dst_city))
path = []
while True:
path.append(result.state)
if result.parent is None:
break
result = result.parent
size = len(path)
for i in range(size):
if i < size - 1:
print('%s->' % path.pop(), end='')
else:
print(path.pop())
def import_city_info():
global _city_info
data = [{'city1': 'Oradea', 'city2': 'Zerind', 'path_cost': 71},
{'city1': 'Oradea', 'city2': 'Sibiu', 'path_cost': 151},
{'city1': 'Zerind', 'city2': 'Arad', 'path_cost': 75},
{'city1': 'Arad', 'city2': 'Sibiu', 'path_cost': 140},
{'city1': 'Arad', 'city2': 'Timisoara', 'path_cost': 118},
{'city1': 'Timisoara', 'city2': 'Lugoj', 'path_cost': 111},
{'city1': 'Lugoj', 'city2': 'Mehadia', 'path_cost': 70},
{'city1': 'Mehadia', 'city2': 'Drobeta', 'path_cost': 75},
{'city1': 'Drobeta', 'city2': 'Craiova', 'path_cost': 120},
{'city1': 'Sibiu', 'city2': 'Fagaras', 'path_cost': 99},
{'city1': 'Sibiu', 'city2': 'Rimnicu Vilcea', 'path_cost': 80},
{'city1': 'Rimnicu Vilcea', 'city2': 'Craiova', 'path_cost': 146},
{'city1': 'Rimnicu Vilcea', 'city2': 'Pitesti', 'path_cost': 97},
{'city1': 'Craiova', 'city2': 'Pitesti', 'path_cost': 138},
{'city1': 'Fagaras', 'city2': 'Bucharest', 'path_cost': 211},
{'city1': 'Pitesti', 'city2': 'Bucharest', 'path_cost': 101},
{'city1': 'Bucharest', 'city2': 'Giurgiu', 'path_cost': 90},
{'city1': 'Bucharest', 'city2': 'Urziceni', 'path_cost': 85},
{'city1': 'Urziceni', 'city2': 'Vaslui', 'path_cost': 142},
{'city1': 'Urziceni', 'city2': 'Hirsova', 'path_cost': 98},
{'city1': 'Neamt', 'city2': 'Iasi', 'path_cost': 87},
{'city1': 'Iasi', 'city2': 'Vaslui', 'path_cost': 92},
{'city1': 'Hirsova', 'city2': 'Eforie', 'path_cost': 86}]
_city_info = DataFrame(data, columns=['city1', 'city2', 'path_cost'])
# print(_city_info)
def breadth_first_search(src_state, dst_state):
global _city_info
node = Node(src_state, None, None, 0)
# 目标测试
if node.state == dst_state:
return node
frontier = [node]
explored = []
while True:
if len(frontier) == 0:
return False
node = frontier.pop(0)
explored.append(node.state)
if node.parent is not None:
print('deal node:state:%s\tparent state:%s\tpath cost:%d' % (node.state, node.parent.state, node.path_cost))
else:
print('deal node:state:%s\tparent state:%s\tpath cost:%d' % (node.state, None, node.path_cost))
# 遍历子节点
for i in range(len(_city_info)):
dst_city = ''
if _city_info['city1'][i] == node.state:
dst_city = _city_info['city2'][i]
elif _city_info['city2'][i] == node.state:
dst_city = _city_info['city1'][i]
if dst_city == '':
continue
child = Node(dst_city, node, 'go', node.path_cost + _city_info['path_cost'][i])
print('\tchild node:state:%s path cost:%d' % (child.state, child.path_cost))
if child.state not in explored and not is_node_in_frontier(frontier, child):
# 目标测试
if child.state == dst_state:
print('\t\t this child is goal!')
return child
frontier.append(child)
print('\t\t add child to child')
def is_node_in_frontier(frontier, node):
for x in frontier:
if node.state == x.state:
return True
return False
def uniform_cost_search(src_state, dst_state):
global _city_info, _frontier_priority
node = Node(src_state, None, None, 0)
frontier_priority_add(node)
explored = []
while True:
if len(_frontier_priority) == 0:
return False
node = _frontier_priority.pop(0)
if node.parent is not None:
print('deal node:state:%s\tparent state:%s\tpath cost:%d' % (node.state, node.parent.state, node.path_cost))
else:
print('deal node:state:%s\tparent state:%s\tpath cost:%d' % (node.state, None, node.path_cost))
# 目标测试
if node.state == dst_state:
print('\t this node is goal!')
return node
explored.append(node.state)
# 遍历子节点
for i in range(len(_city_info)):
dst_city = ''
if _city_info['city1'][i] == node.state:
dst_city = _city_info['city2'][i]
elif _city_info['city2'][i] == node.state:
dst_city = _city_info['city1'][i]
if dst_city == '':
continue
child = Node(dst_city, node, 'go', node.path_cost + _city_info['path_cost'][i])
print('\tchild node:state:%s path cost:%d' % (child.state, child.path_cost))
if child.state not in explored and not is_node_in_frontier(_frontier_priority, child):
frontier_priority_add(child)
print('\t\t add child to frontier')
elif is_node_in_frontier(_frontier_priority, child):
# 替代为路径消耗少的节点
frontier_priority_replace_by_priority(child)
def frontier_priority_add(node):
"""
:param Node node:
:return:
"""
global _frontier_priority
size = len(_frontier_priority)
for i in range(size):
if node.path_cost < _frontier_priority[i].path_cost:
_frontier_priority.insert(i, node)
return
_frontier_priority.append(node)
def frontier_priority_replace_by_priority(node):
"""
:param Node node:
:return:
"""
global _frontier_priority
size = len(_frontier_priority)
for i in range(size):
if _frontier_priority[i].state == node.state and _frontier_priority[i].path_cost > node.path_cost:
print('\t\t replace state: %s old cost:%d new cost:%d' % (node.state, _frontier_priority[i].path_cost,
node.path_cost))
_frontier_priority[i] = node
return
if __name__ == '__main__':
main()
input src city
Zerind
input dst city
Urziceni
dealnode:state:Zerind parentstate:None path cost:0
childnode:state:Oradea path cost:71
add child to frontier
childnode:state:Arad path cost:75
add child to frontier
dealnode:state:Oradea parentstate:Zerind path cost:71
childnode:state:Zerind path cost:142
childnode:state:Sibiu path cost:222
add child to frontier
dealnode:state:Arad parentstate:Zerind path cost:75
childnode:state:Zerind path cost:150
childnode:state:Sibiu path cost:215
replace state: Sibiu old cost:222 new cost:215
childnode:state:Timisoara path cost:193
add child to frontier
dealnode:state:Timisoara parentstate:Arad path cost:193
childnode:state:Arad path cost:311
childnode:state:Lugoj path cost:304
add child to frontier
dealnode:state:Sibiu parentstate:Arad path cost:215
childnode:state:Oradea path cost:366
childnode:state:Arad path cost:355
childnode:state:Fagaras path cost:314
add child to frontier
childnode:state:Rimnicu Vilcea path cost:295
add child to frontier
dealnode:state:Rimnicu Vilcea parentstate:Sibiu path cost:295
childnode:state:Sibiu path cost:375
childnode:state:Craiova path cost:441
add child to frontier
childnode:state:Pitesti path cost:392
add child to frontier
dealnode:state:Lugoj parentstate:Timisoara path cost:304
childnode:state:Timisoara path cost:415
childnode:state:Mehadia path cost:374
add child to frontier
dealnode:state:Fagaras parentstate:Sibiu path cost:314
childnode:state:Sibiu path cost:413
childnode:state:Bucharest path cost:525
add child to frontier
dealnode:state:Mehadia parentstate:Lugoj path cost:374
childnode:state:Lugoj path cost:444
childnode:state:Drobeta path cost:449
add child to frontier
dealnode:state:Pitesti parentstate:Rimnicu Vilcea pathcost:392
childnode:state:Rimnicu Vilcea path cost:489
childnode:state:Craiova path cost:530
childnode:state:Bucharest path cost:493
replace state: Bucharest old cost:525 newcost:493
dealnode:state:Craiova parentstate:Rimnicu Vilcea pathcost:441
childnode:state:Drobeta path cost:561
childnode:state:Rimnicu Vilcea path cost:587
childnode:state:Pitesti path cost:579
dealnode:state:Drobeta parentstate:Mehadia path cost:449
childnode:state:Mehadia path cost:524
childnode:state:Craiova path cost:569
dealnode:state:Bucharest parentstate:Pitesti path cost:493
childnode:state:Fagaras path cost:704
childnode:state:Pitesti path cost:594
childnode:state:Giurgiu path cost:583
add child to frontier
childnode:state:Urziceni path cost:578
add child to frontier
dealnode:state:Urziceni parentstate:Bucharest path cost:578
this node is goal!
from city: Zerind tocity Urziceni search success
Zerind->Arad->Sibiu->RimnicuVilcea->Pitesti->Bucharest->Urziceni
可见，本算法能找出最优解。在导航过程中，用Zerind->Arad->Sibiu替代了Zerind->Oradea->Sibiu，用Sibiu->Rimnicu Vilcea->Pitesti->Bucharest替代了Sibiu->Rimnicu Vilcea->Pitesti->Bucharest。
1039
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
