A*寻路算法python版（第二版）

最新推荐文章于 2024-07-16 15:39:06 发布
最新推荐文章于 2024-07-16 15:39:06 发布
阅读量1.8w 收藏 80
点赞数 15
文章标签： A* python 深拷贝 路径规划 启发函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wqzhang2017/article/details/79691559
版权

    这一周的工作主要是将上一周改的python版代码调试正常。由于对python语言特定语法结构理解的还是不深，所以的遇到了很多坑，万幸最后还是一一填上了，随着不断的调试对于python的有了进一步的认识。先交代一下最大的坑，就是对于python嵌套列表的深拷贝和浅拷贝的不了解和错误使用，导致代码运行时出现了各种诡异的现象。总结如下，共勉！

    首先讲一下在应用嵌套列表时对于深浅拷贝的个人理解：

    比如：a = [['c','d'],5,4,'g']，列表a是一个内部嵌套了一层列表['c','d']的列表，如果要将a中的数据拷贝到列表b中，以下给出3种操作方式，正确与否会详细说明，仅通过3种方式来交代深拷贝和浅拷贝的区别：

    1).b = a,这一种方式其实是将b映射到a的存储位置上，不是真正的拷贝，一旦b中的元素被修改，a中的元素也同样会被修改

    2).b = a[:],这一种方式是浅拷贝。其实如果a内部没有嵌套列表，如 ['c','d',5,4,'g']，这种方式是正确的，因为浅拷贝会拷贝到列表a很浅的一部分，即最外层。这样b不会被映射到a的存储位置上，两者存储空间互不干扰。但是现在a内部嵌套了一个列表，再用浅拷贝操作，这样b中的元素会部分映射到a，猜也能猜到就是列表内部嵌套的一层['c','d']会被b与a共享，而列表中剩下的元素是存储在不同的位置，不会被共享。所以这样就会导致诡异的现象：你以为拷贝成功了，但只要修改一个列表中共享位置的元素，之前的副本中的元素全部也被修改，注意浅拷贝的另一种方式是b = copy.copy(a),但是需要在前面import copy工具箱。

    3).b = copy.deepcopy(a),这一种方式是深拷贝，需要import copy工具箱，这种方式顾名思义，就是将列表中嵌套的列表也都拷贝到另一个存储位置上，所以要想只将a的元素的值复制一份给b，而不想a与b之间还有任何牵连需要进行深拷贝操作。

    用python编的这套A*算法，基本步骤与c++版本一致，主要是由于python中有列表这种数据结构，所以将c++中结构体和类变量以嵌套列表的方式来表示，现以c++与python对比的方式将一些重要数据结构作出说明：

    以chessboard棋盘这个概念的数据结构为例

    在c++中，我使用的是结构体来定义棋盘，具体如下：

    结构体定义：

struct PARENT_POSITION//父指针
{
	int x;
	int y;
};

struct CHESS_BOARD_UNIT
{
	PARENT_POSITION ParentPosition;
	int g_value;
	int h_value;
	int f_value;
	char flag;//标识此单元是：2起点/3终点/1障碍物/0通路
};

    结构体数组定义：

CHESS_BOARD_UNIT chessboard[chess_size][chess_size] = { 0 };//chessboard初始化为0

    若操作地图上3行5列点的父指针的横坐标，操作如下：

    chessboard[3][5].ParentPosition.x= 5


    在python中，我使用的是列表来定义棋盘，具体如下：

    这里注意，与c++的区别是python定义列表不用预先分配好这个列表的大小，想用直接往里存就可以了。

    chessboard = [] #用python定义就是如此简单！！！

    而chessboard具体的数据结构必须是在存放完所有元素之后才能确定！实际上chessboard的每一个方格元素的结构是

    A = [[parent.x,parent.y],g_value,h_value,f_value,flag]，与c++版本中数据结构得顺序是一致的

    以下将存放元素的具体代码贴出：

	i = 0 
	while i <20:
		j = 0
		while j<20:
			#将棋盘读入到flag中
			if 's' == chessboardTemp[i][j]: #检测并记录起始点坐标
				print('起始点坐标！！！[%d,%d]'%(i,j))
				Start_x = i
				Start_y = j
			if 'e' == chessboardTemp[i][j]: #检测并记录终止点坐标
				print('终止点坐标！！！[%d,%d]'%(i,j))
				End_x = i
				End_y = j
			if 'b' == chessboardTemp[i][j]: #检测并记录终止点坐标
				print('障碍点坐标！！！[%d,%d]'%(i,j))

			item=[[0,0],0,0,0,chessboardTemp[i][j]]#结构：A = [[parent.x,parent.y],g_value,h_value,f_value,flag]
			#print(item[4])
			itemLine.append(copy.deepcopy(item)) #结构：B = [A,A,A,A,A....,A]一行20个,一定要传切片[:]！！！
			print(itemLine[j][4])
			j+=1
		print(fileLine)
		chessboard.append(copy.deepcopy(itemLine)) #结构：[B,B,B,B,...,B] 20列，一定要传切片！！！
		itemLine = []#超级大bug：将itemLine清空（查了一晚上！！！！）
		fileLine = ifile.readline()#读取下一行数据
		i+=1

    说明一下这段代码的简单流程，chessboardTemp是一个列表，列表中的元素是从txt文件中读取的每一行字符串（即每行地图），两层循环的工作就是要将表示地图的每一个字符存放到 A = [[parent.x,parent.y],g_value,h_value,f_value,flag]的flag位置上。

item = [[0,0],0,0,0,chessboardTemp[i][j]]就相当于c++中棋盘中的一个方格的结构体，itemLine.append(copy.deepcopy(item))操作循环20次就是要将一行20个方格排列在一个列表里，构成chessboard的一行itemLine = [item,item,item,item,...,item]。

而chessboard.append(copy.deepcopy(itemLine))操作循环20次相当于chessboard = [itemLine,itemLine,itemLine,...,itemLine]

构成了chessboard的20行，即整个chessboard的数据结构就被建立起来了。

    同样，若操作地图上3行5列点的父指针的横坐标，操作如下：

    chessboard[3][5][0][0] = 5 #言简意赅！！！


    现将寻路结果截图：


    下面将python版本的全部代码贴出

    注意：

    1.此版本调试信息我忘了加开关，所以会在控制台打出大量调试信息，下一版再修正！

    2.要预先在.py文件的相同目录下建立地图txt文件（代码中名为‘123.txt’），现将地图贴出：

########b###########
########b###########
##s#####b###########
########b########e##
########b###########
########b###########
######b#b###########
######b#bbbbbb######
######b######b######
#########b###b######
#########b###b######
#########b###b#bbb##
#########b##########
####################
####################
####################
####################
####################
####################
####################

    代码：

#coding=utf-8
import copy
chess_size =  20
FILE_STORAGE_WAY =  '123.txt'	#随机数据文件存放路径

Start_x = 0
Start_y = 0
End_x = 0
End_y = 0	

OpenListPosition = 0 #指针标记open列表数组当前存放元素个数（position总指向最后一个元素的后一位置）
CloseListPosition = 0 #指针标记Close列表数组当前存放元素个数（position总指向最后一个元素的后一位置） 

OpenList = []#open列表(定义成数组形式)
CloseList = []#close列表

chessboard = []	

def openListIncraseSort():
	global OpenListPosition
	global OpenList
	flag = 0
	i = 0
	#for (int i = 0; i < OpenListPosition; i++)//冒泡法由大到小排序
	while i < OpenListPosition:
		#for (int j = 0; j < OpenListPosition - i; j++)
		j = 0
		while j<OpenListPosition - 1:##############- 1
			if OpenList[j][2] < OpenList[j + 1][2]:#若OpenList[j].f_value < OpenList[j + 1].f_value，交换，从大到小排列
			
				ChessUnit_x = OpenList[j][0]
				ChessUnit_y = OpenList[j][1]
				f_value 	= OpenList[j][2]

				OpenList[j][0]= OpenList[j + 1][0]
				OpenList[j][1]= OpenList[j + 1][1]
				OpenList[j][2]= OpenList[j + 1][2]

				OpenList[j + 1][0] = ChessUnit_x
				OpenList[j + 1][1] = ChessUnit_y
				OpenList[j + 1][2] = f_value

				flag = 1 #将交换标志位置1
			j+=1 #循环变量增加1
			#if
		#while2
		if (0 == flag):
			break #内层循环一次都没交换，说明已经排好序
		flag = 0 #将标志位重新清0
		i+=1 #循环变量增加1
	print('===调试用===openListIncraseSort()')#调试用，输出openListIncraseSort
	print('===调试用===按f_value排序后的OpenList =')
	print(OpenList)


def dealCurrentNeibors(CurrentUnit):#判断当前结点周围8个点状态，计算g、h、f值，将周围每个点的父指针指向当前结点
	global OpenListPosition
	global CloseListPosition
	global OpenList
	global CloseList
	global chessboard
	OpenListFlag = 0
	CloseListFlag = 0

	ObstacleEast = 0	#标识当前点东边是否有障碍物
	ObstacleSouth = 0	#标识当前点南边是否有障碍物
	ObstacleWest = 0	#标识当前点西边是否有障碍物
	ObstacleNorth = 0	#标识当前点北边是否有障碍物

	#CloseListUnit EastUnit, SourthEastUnit, SourthUnit, SourthWestUnit, WestUnit, NorthWestUnit, NorthUnit, NorthEastUnit;//东，东南，南，西南，西，西北，北，东北
	CurrentNeibors = []#列表，按顺序存放当前结点的东，东南，南，西南，西，西北，北，东北方向的邻结点
	OpenlistTemp = []#列表，存放openlist【x,y,f_value】中的【x,y】
	for temp in OpenList:
		OpenlistTemp.append([temp[0],temp[1]])
	print('===调试用===dealCurrentNeibors():OpenlistTemp=')#调试用，输出OpenlistTemp
	print(OpenlistTemp)#调试用，输出OpenlistTemp
	#东方y+1
	item = [CurrentUnit[0],CurrentUnit[1] + 1]
	CurrentNeibors.append(item)

	#东南方x+1,y+1
	item = [CurrentUnit[0] + 1,CurrentUnit[1] + 1]
	CurrentNeibors.append(item)

	#南方x+1
	item = [CurrentUnit[0] + 1,CurrentUnit[1]]
	CurrentNeibors.append(item)

	#西南方x+1,y-1
	item = [CurrentUnit[0] + 1,CurrentUnit[1]-1]
	CurrentNeibors.append(item)

	#西方y-1
	item = [CurrentUnit[0],CurrentUnit[1]-1]
	CurrentNeibors.append(item)

	#西北方x-1,y-1
	item = [CurrentUnit[0]-1,CurrentUnit[1]-1]
	CurrentNeibors.append(item)

	#北方x-1
	item = [CurrentUnit[0]-1,CurrentUnit[1]]
	CurrentNeibors.append(item)

	#东北方x-1,y+1
	item = [CurrentUnit[0]-1,CurrentUnit[1]+1]
	CurrentNeibors.append(item)
	print('===调试用===CurrentUnit=(%d,%d)'%(CurrentUnit[0],CurrentUnit[1]))#调试用	
	print(chessboard[6][6][4])
	print(chessboard[6][8][4])

	print('===调试用===dealCurrentNeibors():CurrentNeibors=')#调试用
	print(CurrentNeibors)#调试用
	#对当前方格东、南、西、北四个方向的临近方格依次检测
	i = 0
	while i<8:
		#当前中间结点到邻近结点的距离。约定：东南西北四个方向距离为10，四个斜方向距离为14
		if i%2 == 0:
			currenToNeibor = 10
		else:
			currenToNeibor = 14
		print('===调试用===dealCurrentNeibors():currenToNeibor=[%d]'%currenToNeibor)#调试用
		print('===调试用===dealCurrentNeibors():CurrentUnit[0]=[%d] CurrentUnit[1]=[%d]'%(CurrentUnit[0],CurrentUnit[1]))
		print('===调试用===dealCurrentNeibors():chessboard[CurrentUnit[0]][CurrentUnit[1]][1]=[%d]'%chessboard[CurrentUnit[0]][CurrentUnit[1]][1])			
		#超出边界点
		if CurrentNeibors[i][0] < 0 or CurrentNeibors[i][0]>19 or CurrentNeibors[i][1] < 0 or CurrentNeibors[i][1]>19:
			print('===调试用===dealCurrentNeibors():超出边界点！！！(%d,%d)'%(CurrentNeibors[i][0],CurrentNeibors[i][1]))
			#continue #结束判断
				
		# print('===调试用===dealCurrentNeibors():currenToNeibor=[%d],i=[%d]'%(currenToNeibor,i))#调试用
		# print('===调试用===dealCurrentNeibors():CurrentNeibors[%d][0]=[%d]'%(i,CurrentNeibors[i][0]))#调试用
		# print('===调试用===dealCurrentNeibors():CurrentNeibors[%d][1]=[%d]'%(i,CurrentNeibors[i][1]))#调试用
		# print('===调试用===dealCurrentNeibors():chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][4]=')
		# print(chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][4])

		#终点
		elif 'e' == chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][4]:#flag
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][0][0] = CurrentUnit[0]#[0][0]parent.x
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][0][1] = CurrentUnit[1]#[0][1]parent.y
			print('===调试用===dealCurrentNeibors():找到终点！！！(%d,%d)'%(CurrentNeibors[i][0],CurrentNeibors[i][1]))#调试用
			return 1

		#障碍物点
		elif 'b' == chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][4]:#flags
			print('===调试用===dealCurrentNeibors():找到障碍物点！！！(%d,%d)'%(CurrentNeibors[i][0],CurrentNeibors[i][1]))#调试用
			if i == 0:
				ObstacleEast = 1 #标识当前点东边有障碍物
				print('===调试用===dealCurrentNeibors():ObstacleEast = %d'%ObstacleEast)
			elif i == 2:
				ObstacleSouth = 1 #标识当前点南边有障碍物
				print('===调试用===dealCurrentNeibors():ObstacleSouth = %d'%ObstacleSouth)
			elif i == 4:
				ObstacleWest = 1 #标识当前点西边有障碍物
				print('===调试用===dealCurrentNeibors():ObstacleWest = %d'%ObstacleWest)
			elif i == 6:
				ObstacleNorth = 1 #标识当前点北边有障碍物
				print('===调试用===dealCurrentNeibors():ObstacleNorth = %d'%ObstacleNorth)				

		#将该临近点与closelist中的点逐个比较
		elif CurrentNeibors[i] in CloseList:#python牛逼！
			print('===调试用===dealCurrentNeibors():CurrentNeibors[%d]是closelist中的点！！！(%d,%d)'%(i,CurrentNeibors[i][0],CurrentNeibors[i][1]))
			print('===调试用===dealCurrentNeibors():CloseList=')
			print(CloseList)
			#continue#结束判断

		#将该临近点与openlist中的点逐个比较
		elif CurrentNeibors[i] in OpenlistTemp:#python牛逼！
			print('===调试用===dealCurrentNeibors():CurrentNeibors[i] in OpenlistTemp：')#调试用
			print('===调试用===dealCurrentNeibors():CurrentNeibors[i]=')
			print(CurrentNeibors[i])
			print('===调试用===dealCurrentNeibors():OpenlistTemp=')
			print(OpenlistTemp)
			#若该临近点的g值大于从起点经由当前结点到该临近结点的g值，将该临近结点的父指针指向当前结点，并更改该临近结点的g值，f值
			if chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1] > chessboard[CurrentUnit[0]][CurrentUnit[1]][1] + currenToNeibor:
				#将该临近结点的父指针指向当前结点
				chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][0][0] = CurrentUnit[0]#[0][0]parent.x
				chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][0][1] = CurrentUnit[1]#[0][1]parent.y
				print('===调试用===dealCurrentNeibors():修改(%d,%d)结点的父节点（%d,%d）'%(CurrentNeibors[i][0],CurrentNeibors[i][1],CurrentUnit[0],CurrentUnit[1]))
				#更改该临近结点的g值，f值
				chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1] = chessboard[CurrentUnit[0]][CurrentUnit[1]][1] + currenToNeibor#g_value+currenToNeibor
				chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][3] = chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1] + chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][2]#[1]g[2]h[3]f
				counter=0
				while len(OpenList)-counter > 0:#大bug，漏掉了此处，导致openlist中的f_value值没有被更新！！！注意修改list值不能用for
					if CurrentNeibors[i][0] == OpenList[counter][0] and CurrentNeibors[i][1] == OpenList[counter][1]:#找到openlist中要修改f_value的位置
						OpenList[counter][2] = chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][3]#更新openlist中的f值
						break
					counter+=1
		#可作为通路点
		elif '#' == chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][4]:
			#将邻居结点的指针指向当前结点
			print('===调试用===dealCurrentNeibors():CurrentUnit[0]=[%d] CurrentUnit[1]=[%d]'%(CurrentUnit[0],CurrentUnit[1]))
			print('===调试用===dealCurrentNeibors():chessboard[CurrentUnit[0]][CurrentUnit[1]][1]=[%d]'%chessboard[CurrentUnit[0]][CurrentUnit[1]][1])			
			
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][0][0] = CurrentUnit[0]#[0][0]parent.x
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][0][1] = CurrentUnit[1]#[0][1]parent.y
			print('===调试用===dealCurrentNeibors():(%d,%d)结点的父节点为（%d,%d）'%(CurrentNeibors[i][0],CurrentNeibors[i][1],CurrentUnit[0],CurrentUnit[1]))

			#print('===调试用===dealCurrentNeibors():chessboard=')	
			#print(chessboard)	

			#计算该临近结点的g值，h值（曼哈顿距离），f值
			#temptest = chessboard[CurrentUnit[0]][CurrentUnit[1]][1][:] + currenToNeibor
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1] = chessboard[CurrentUnit[0]][CurrentUnit[1]][1] + currenToNeibor#一条诡异的程序
			print(type(chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1]))
			print(type(chessboard[CurrentUnit[0]][CurrentUnit[1]][1]))
			print(type(currenToNeibor))
		
			print('===调试用===dealCurrentNeibors():CurrentNeibors[i][0]=[%d] CurrentNeibors[i][1]=[%d]'%(CurrentNeibors[i][0],CurrentNeibors[i][1]))
			print('===调试用===dealCurrentNeibors():CurrentUnit[0]=[%d] CurrentUnit[1]=[%d]'%(CurrentUnit[0],CurrentUnit[1]))
			print('===调试用===dealCurrentNeibors():chessboard[CurrentUnit[0]][CurrentUnit[1]][1]=[%d]'%chessboard[CurrentUnit[0]][CurrentUnit[1]][1])			
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][2] = 10 * (abs(CurrentNeibors[i][0] - End_x) + abs(CurrentNeibors[i][1] - End_y))
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][3] = chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1] + chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][2]
			print('===调试用===dealCurrentNeibors():g_value=[%d]'%chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1])
			print('===调试用===dealCurrentNeibors():h_value=[%d]'%chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][2])
			print('===调试用===dealCurrentNeibors():f_value=[%d]'%chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][3])

			print('===调试用===dealCurrentNeibors():CurrentUnit[0]=[%d] CurrentUnit[1]=[%d]'%(CurrentUnit[0],CurrentUnit[1]))
			print('===调试用===dealCurrentNeibors():chessboard[CurrentUnit[0]][CurrentUnit[1]][1]=[%d]'%chessboard[CurrentUnit[0]][CurrentUnit[1]][1])			

			#将该临近点存入openlist中
			temp = [CurrentNeibors[i][0],CurrentNeibors[i][1],chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][3]]
			OpenList.append(temp) 
			print('===调试用===dealCurrentNeibors():OpenList.append(temp),temp=')
			print(temp)
			print('===调试用===dealCurrentNeibors():OpenList.append(temp),OpenList')
			print(OpenList)
			OpenListPosition+=1
			print('===调试用===dealCurrentNeibors():CurrentUnit[0]=[%d] CurrentUnit[1]=[%d]'%(CurrentUnit[0],CurrentUnit[1]))
			print('===调试用===dealCurrentNeibors():chessboard[CurrentUnit[0]][CurrentUnit[1]][1]=[%d]'%chessboard[CurrentUnit[0]][CurrentUnit[1]][1])			
			#print('===调试用===OpenList.append(temp),OpenListPosition = [%d]',%OpenListPosition)
		i+=2#循环变量增加2

	#对当前方格东南、西南、西北、东北四个方向的临近方格依次检测
	i = 1
	while i < 8 :
		#i+=2#循环变量增加2
		#当前中间结点到邻近结点的距离。约定：东南西北四个方向距离为10，四个斜方向距离为14
		if i%2 == 0:
			currenToNeibor = 10
		else:
			currenToNeibor = 14
		print('===调试用===dealCurrentNeibors():ObstacleEast = %d'%ObstacleEast)
		print('===调试用===dealCurrentNeibors():ObstacleSouth = %d'%ObstacleSouth)
		print('===调试用===dealCurrentNeibors():ObstacleWest = %d'%ObstacleWest)
		print('===调试用===dealCurrentNeibors():ObstacleNorth = %d'%ObstacleNorth)
		#print('===调试用===i=[%d]'%i)#调试用

		print('===调试用===dealCurrentNeibors():currenToNeibor=[%d]'%currenToNeibor)#调试用

		if 1 == ObstacleEast  and (1 == i or 7 == i): #若东方格是障碍物，则东南、东北都不能通行
			print('===调试用===i=[%d]'%i)#调试用
			i+=2
			continue

		if 1 == ObstacleSouth and (1 == i or 3 == i): #若南方格是障碍物，则东南、西南都不能通行
			print('===调试用===i=[%d]'%i)#调试用
			i+=2
			continue

		if 1 == ObstacleWest and (3 == i or 5 == i): #若西方格是障碍物，则西南、西北都不能通行
			print('===调试用===i=[%d]'%i)#调试用
			i+=2
			continue

		if 1 == ObstacleNorth and (5 == i or 7 == i): #若北方格是障碍物，则西北、东北都不能通行
			print('===调试用===i=[%d]'%i)#调试用
			i+=2
			continue

		#超出边界点
		if CurrentNeibors[i][0] < 0 or CurrentNeibors[i][0]>19 or CurrentNeibors[i][1] < 0 or CurrentNeibors[i][1]>19:
			print('===调试用===dealCurrentNeibors():超出边界点！！！(%d,%d)'%(CurrentNeibors[i][0],CurrentNeibors[i][1]))
			#continue #结束判断

		#终点
		elif 'e' == chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][4]:#flag
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][0][0] = CurrentUnit[0]#[0][0]parent.x
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][0][1] = CurrentUnit[1]#[0][1]parent.y
			print('===调试用===dealCurrentNeibors():找到终点！！！[%d][%d]'%(CurrentNeibors[i][0],CurrentNeibors[i][1]))#调试用			
			return 1

		#障碍物点
		elif 'b' == chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][4]:#flags
			print('===调试用===dealCurrentNeibors():找到障碍物点！！！[%d][%d]'%(CurrentNeibors[i][0],CurrentNeibors[i][1]))#调试用
			

		#将该临近点与closelist中的点逐个比较
		elif CurrentNeibors[i] in CloseList:#python牛逼！
			print('===调试用===dealCurrentNeibors():CurrentNeibors[%d]是closelist中的点！！！(%d,%d)'%(i,CurrentNeibors[i][0],CurrentNeibors[i][1]))
			#continue#结束判断

		#将该临近点与openlist中的点逐个比较
		elif CurrentNeibors[i] in OpenlistTemp:#python牛逼！
			print('===调试用===dealCurrentNeibors():CurrentNeibors[i] in OpenlistTemp：')#调试用
			print('===调试用===dealCurrentNeibors():CurrentNeibors[i]=')
			print(CurrentNeibors[i])
			print('===调试用===dealCurrentNeibors():OpenlistTemp=')
			print(OpenlistTemp)
			#若该临近点的g值大于从起点经由当前结点到该临近结点的g值，将该临近结点的父指针指向当前结点，并更改该临近结点的g值，f值
			if chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1] > chessboard[CurrentUnit[0]][CurrentUnit[1]][1] + currenToNeibor:
				#将该临近结点的父指针指向当前结点
				chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][0][0] = CurrentUnit[0]#[0][0]parent.x
				chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][0][1] = CurrentUnit[1]#[0][1]parent.y
				print('===调试用===dealCurrentNeibors():修改(%d,%d)结点的父节点（%d,%d）'%(CurrentNeibors[i][0],CurrentNeibors[i][1],CurrentUnit[0],CurrentUnit[1]))

				#更改该临近结点的g值，f值
				chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1] = chessboard[CurrentUnit[0]][CurrentUnit[1]][1] + currenToNeibor#g_value+currenToNeibor
				chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][3] = chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1] + chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][2]#[1]g[2]h[3]f
				counter=0
				while len(OpenList)-counter > 0:#大bug，漏掉了此处，导致openlist中的f_value值没有被更新！！！注意修改list值不能用for
					if CurrentNeibors[i][0] == OpenList[counter][0] and CurrentNeibors[i][1] == OpenList[counter][1]:#找到openlist中要修改f_value的位置
						OpenList[counter][2] = chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][3]#更新openlist中的f值
						break
					counter+=1
		#可作为通路点
		elif '#' == chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][4]:#flag
			#将邻居结点的指针指向当前结点
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][0][0] = CurrentUnit[0]#[0][0]parent.x
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][0][1] = CurrentUnit[1]#[0][1]parent.y
			print('===调试用===dealCurrentNeibors():(%d,%d)结点的父节点为（%d,%d）'%(CurrentNeibors[i][0],CurrentNeibors[i][1],CurrentUnit[0],CurrentUnit[1]))

			#计算该临近结点的g值，h值（曼哈顿距离），f值
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1] = chessboard[CurrentUnit[0]][CurrentUnit[1]][1] + currenToNeibor
			print('===调试用===dealCurrentNeibors():CurrentUnit[0]=[%d] CurrentUnit[1]=[%d]'%(CurrentUnit[0],CurrentUnit[1]))
			print('===调试用===dealCurrentNeibors():chessboard[CurrentUnit[0]][CurrentUnit[1]][1]=[%d]'%chessboard[CurrentUnit[0]][CurrentUnit[1]][1])			
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][2] = 10 * (abs(CurrentNeibors[i][0] - End_x) + abs(CurrentNeibors[i][1] - End_y))
			chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][3] = chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1] + chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][2]
			print('===调试用===dealCurrentNeibors():g_value=[%d]'%chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][1])
			print('===调试用===dealCurrentNeibors():h_value=[%d]'%chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][2])
			print('===调试用===dealCurrentNeibors():f_value=[%d]'%chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][3])

			#将该临近点存入openlist中
			temp = [CurrentNeibors[i][0],CurrentNeibors[i][1],chessboard[CurrentNeibors[i][0]][CurrentNeibors[i][1]][3]]
			OpenList.append(temp) 
			print('===调试用===dealCurrentNeibors():OpenList.append(temp),temp=')
			print(temp)
			print('===调试用===dealCurrentNeibors():OpenList.append(temp),OpenList')
			print(OpenList)
			OpenListPosition+=1
		#	print('===调试用===OpenList.append(temp),OpenListPosition = [%d]',%OpenListPosition)
		i+=2#循环变量增加2
	return 0

def FileReadMatrix():	#将文件中的数据读回至chess_size*chess_size矩阵
	global Start_x
	global Start_y
	global End_x
	global End_y
	
	itemLine = []
	fileLine = []
	chessboardTemp = []
	ifile = open(FILE_STORAGE_WAY,'r')	#作为只读文件打开
	fileLine = ifile.readline()
	while len(fileLine)>0:#将迷宫从txt文件中读入到chessboardTemp列表中
		print(fileLine)
		print(fileLine[0:20])
		chessboardTemp.append(fileLine[0:20])
		fileLine = ifile.readline()
	print(chessboardTemp)
	print(chessboardTemp[2][2])
	i = 0 
	while i <20:
		j = 0
		while j<20:
			#将棋盘读入到flag中
			if 's' == chessboardTemp[i][j]: #检测并记录起始点坐标
				print('起始点坐标！！！[%d,%d]'%(i,j))
				Start_x = i
				Start_y = j
			if 'e' == chessboardTemp[i][j]: #检测并记录终止点坐标
				print('终止点坐标！！！[%d,%d]'%(i,j))
				End_x = i
				End_y = j
			if 'b' == chessboardTemp[i][j]: #检测并记录终止点坐标
				print('障碍点坐标！！！[%d,%d]'%(i,j))

			
			item = [[0,0],0,0,0,chessboardTemp[i][j]]#结构：A = [[parent.x,parent.y],g_value,h_value,f_value,flag]
			#print(item[4])
			itemLine.append(copy.deepcopy(item)) #结构：B = [A,A,A,A,A....,A]一行20个,一定要传切片[:]！！！
			print(itemLine[j][4])
			j+=1
		print(fileLine)
		chessboard.append(copy.deepcopy(itemLine)) #结构：[B,B,B,B,...,B] 20列，一定要传切片！！！
		itemLine = []#超级大bug：将itemLine清空（查了一晚上！！！！）
		fileLine = ifile.readline()#读取下一行数据
		i+=1
	print(chessboard[2][2][4])
	#print(chessboard[6][8][4])
	#print(chessboard)
def printPath():
	PathUnit = []#逆序存放单路径结点（终点->起点）
	PathUnitList = []#逆序存放所有路径结点（终点->起点）
	#获取终点的坐标								  
	PathUnit = [End_x,End_y]

	#cout << "(" << PathUnit.ChessUnit_x << "," << PathUnit.ChessUnit_y << ")" << endl;//输出终点坐标
	print('(%d,%d)'%(PathUnit[0],PathUnit[1]))	
	#记录从end起第一个最佳路径结点
	PathUnit = [chessboard[End_x][End_y][0][0],chessboard[End_x][End_y][0][1]]
	i = 0 #循环变量
	while not(PathUnit[0] == Start_x and PathUnit[1] == Start_y): #记录从终点到起点之间的最佳路径
		PathUnitList.append(copy.deepcopy(PathUnit))#重大bug！！！必须传拷贝，不然循环插入到会修改上一次PathUnit的值
		chessboard[PathUnitList[i][0]][PathUnitList[i][1]][4] = '*'#将最佳路径点用"*"表示
		#cout << "(" << PathUnitList[i].ChessUnit_x << "," << PathUnitList[i].ChessUnit_y << ")" << endl;//输出路径结点坐标
		#输出路径结点坐标
		print('(%d,%d)'%(PathUnit[0],PathUnit[1]))	
		#获取当前结点的父节点坐标																		
		PathUnit[0] = chessboard[PathUnitList[i][0]][PathUnitList[i][1]][0][0]
		PathUnit[1] = chessboard[PathUnitList[i][0]][PathUnitList[i][1]][0][1]
		i+=1
	#cout << "(" << Start_x << "," << Start_y << ")" << endl;//输出终点坐标
	print('(%d,%d)'%(Start_x,Start_y))	#输出终点坐标
	'''
	for (int i = 0; i < chess_size; i++)
	{
		for (int j = 0; j < chess_size; j++)
		{
			cout << chessboard[i][j].flag;
		}
		cout << endl;
	}
	'''
	
	temp =''
	i=0
	while i<20:
		j=0
		while j<20:
			temp += chessboard[i][j][4]
			j+=1
		print(temp)
		temp =''#清空行输出变量
		i+=1
	

def main():
	global OpenListPosition
	global CloseListPosition
	global OpenList
	global CloseList
	global Start_x
	global Start_y

	FileReadMatrix()
	
	item = [Start_x,Start_y,0]#将起始点x坐标，y坐标，f值封装到列表item中
	print(item)
	OpenList.append(item)#将item插入到Openlist中

	OpenListPosition += 1#将起始结点存入openlist，position标记为1（position总指向最后一个元素的后一位置）
	
	while OpenListPosition > 0: #若openlist不为空
		openListIncraseSort() #openlist列表按f值大小降序排序（将最小f值点放在最后，这样只需将position减1就代表移出该点）
		#将openlist中f值最小的点移入closelist中
		item = [OpenList[OpenListPosition - 1][0],OpenList[OpenListPosition - 1][1]]
		CloseList.append(item)
		# print(CloseList)#调试用
		#openlist移出f值最小元素，清除原位置该元素信息
		OpenList.pop()#移除openlist中最后的那个元素
		print('===调试用===main():移除最小元素之后的openlist=')
		print(OpenList)
		OpenListPosition  -= 1 #将OpenListPosition减1，表示从openlist中移出最后一点，即f值最小的点
		#print(OpenListPosition)
		CloseListPosition += 1 #将ClosePosition加1，记录closelist中增加一个元素
		
		#将f最小结点信息插入到CurrentUnit中
		CurrentUnit = [CloseList[CloseListPosition - 1][0],CloseList[CloseListPosition - 1][1]]
		print('===调试用===main():CloseListPosition=[%d]'%CloseListPosition)
		print('===调试用===main():CloseList=')
		print('===调试用===main():CloseList=')
		print(CloseList)
		#判断当前结点周围8个点状态，计算g、h、f值，将周围每个点的父指针指向当前结点
		if dealCurrentNeibors(CurrentUnit) == 1:
			print('===调试用===main():找到终点，跳出循环')
			print('===调试用===main():找到终点，跳出循环')
			print('===调试用===main():找到终点，跳出循环')
			break
	#dealCurrentNeibors(CurrentUnit)
	print('===调试用===OpenListPosition=[%d]'%OpenListPosition)
	#while
	printPath()

	#return 0

main()


向日葵不开的xia天
关注
  • 15
    点赞
  • 踩
  • 80
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
Python版的A*寻路算法
03-02
Python2.x版的A*寻路算法，实现了基本的A*算法，可以显示寻路图，测试运行pathFinder.py，输入地图文件a_map.txt，起点7,0 终点7,9
python寻路算法：A* 算法实现
热门推荐
marble_xu的博客
02-22 1万+
python寻路算法：A* 算法实现A* 算法简介关键代码介绍保存基本信息的地图类搜索到的节点类算法主函数介绍代码的初始化完整代码 A* 算法简介 A* 算法需要维护两个数据结构：OPEN 集和 CLOSED 集。OPEN 集包含所有已搜索到的待检测节点。初始状态，OPEN集仅包含一个元素：开始节点。CLOSED集包含已检测的节点。初始状态，CLOSED集为空。每个节点还包含一个指向父节点的指针，...
Python最短寻路算法，个人实现版本
最新发布
Python私教
07-16 520
这个题目的原题比较复杂，我给个简化版本。第一步，是找到自己所在的位置，因为是个图，所谓图，我的理解就是一个二维数组，所以用一个双重循环，能够轻松找到自己的位置，也就是N所在的点。我们从N出发，总共有四个方向，每个方向都要走一遍，到了下一个点以后又有四个方向，每个点都要走一遍，这里图太多，我就只画一个示例。所谓的边缘就是二维数组索引的最值，比如你的右边没有数了，你就不能往下走了，你的上边没有数了，你就不能往上走了。我们往每个方向走，本质上就是行索引或者列索引的改变，走的时候，还需要将走了几步给记下来。
python迷宫寻路_迷宫寻路问题——A*算法
weixin_39611769的博客
12-08 3060
迷宫寻路问题——A*算法迷宫寻路问题是人工智能中的有趣问题，如何表示状态空间和搜索路径是寻路问题的重点，本文的主要内容是A*搜索算法的理解和应用，首先对基本知识和算法思想进行了解，再通过其对迷宫问题求解应用，编写 Python 程序进行深入学习。1. 搜索区域我们假设某个人要从 Start 点到达 End 点，存在墙壁把这两个点层层隔开，如下图所示，绿色部分代表起点 Start 和终点 End，红...
python模拟实现A*寻路算法
Rorschach:Blog
09-03 7796
一、简介 亮点之间寻找最短路径，同时要考虑到存在障碍物遮挡到情况。 二、具体说明 说明可以参考下面的链接，对A*算法实现的描述。 三、具体实现 1、实现功能 2、寻路具体流程 3、关于F值 f = g + h g表示当前移动到下一个点的消耗，平移为1，斜移动为 sqrt((x1-x2）**2 +(y1-y2)**2); h表示当前移动到终点的消耗，不考虑斜移，不考虑障碍物 具体原理请查看下面的...
A*算法Python实现
02-01
A星算法的Python实现，在控制台直接执行脚本可以看到模拟图
A*寻路算法(Python)
weixin_43300894的博客
05-28 2819
一、题目描述 在一个迷宫游戏里，有一些小怪物要去攻击主角，现在希望给这些小怪物加上聪明的AI，让他们可以自动绕过迷宫中的障碍物，寻找到主角所在。 二、解题思路 迷宫游戏里的场景通常都是由小方格组成。假设我们有一个7*5大小的迷宫，图中红色格子是终点，绿色格子是起点，蓝色格子是一堵墙。 ...
python游戏寻路_python模拟实现A*寻路算法
weixin_36371906的博客
02-04 1493
一、简介两点之间寻找最短路径，要考虑到存在障碍物遮挡和斜线移动的情况。二、具体说明说明可以参考下面的链接，对A*算法实现的描述。三、具体实现1、实现功能 2、寻路具体流程 3、关于F值f = g + hg表示当前移动到下一个点的消耗，平移为1，斜移动为 sqrt((x1-x2)**2 +(y1-y2)**2);h表示当前移动到终点的消耗，不考虑斜移，不考虑障碍物具体原理请查看下面的参考链接。完整实...
漫画算法python版下载_漫画算法：小灰的算法之旅 PDF 全格式完整版
weixin_39933484的博客
12-03 4519
给大家带来的一篇关于算法相关的电子书资源，介绍了关于漫画算法、小灰、算法之旅方面的内容，本书是由电子工业出版社出版，格式为PDF，资源大小115.22 MB，魏梦舒编写，目前豆瓣、亚马逊、当当、京东等电子书综合评分为：7.1。内容介绍本资源为完整全格式完整版(非试看版)小灰的算法经典故事给算法这颗“子弹”包上了“糖衣”，让算法的杀伤力潜藏于内，表面已不可怕，萌萌达Q弹讨人喜欢。从基本数据结构，到各...
启发式搜索算法（A*）educoder
weixin_51374749的博客
04-22 903
人工智能---启发式搜索算法
最快速的寻路算法 Jump Point Search
腾讯技术工程
11-13 6528
作者：runzhiwang，腾讯 TEG 后台开发工程师本文介绍一种跳点搜索算法 JPS 以及其四个优化算法，其寻路速度最快可是 A*算法的 273 倍。文中的 JPS-Bit 和 JP...
A*算法（python编程）
10-26
用于机器人导航的A*算法，帮助你深刻理解算法原理，直接运行即可！
python-pathfinding:通用寻路算法的实现
05-26
python路径查找 python 2和3的寻路算法 当前，此库中捆绑了7个路径查找器，即： 一种* 迪克斯特拉 最佳第一 双向A * 广度优先搜索（BFS） 迭代深度A *（IDA *） 最小生成树（MSP） Dijkstra和A *考虑了地图上字段的权重。 受到启发 安装 该库由pypi提供，因此您可以使用pip安装当前的稳定版本： pip install pathfinding 参见 用法示例 一个使用A *查找路径的简单用法示例。 导入所需的库： from pathfinding . core . diagonal_movement import DiagonalMovement from pathfinding . core . grid import Grid from pathfinding . finder . a_star import ASta
基于A*算法的迷宫寻路系统
01-25
这是一个迷宫寻路小项目。 压缩包里有已经封装好的exe文件maze.exe，双击即可运行。 源代码也在压缩包中，直接用python运行maze.py即可（python版本3.6，要装pygame） 推荐一篇介绍A 算法的博文，解释的非常好：http://blog.csdn.net/hitwhylz/article/details/23089415 求好评！！！
python实现Dijkstra静态寻路算法
09-19
主要介绍了python实现Dijkstra静态寻路算法常用于路由算法或者作为其他图算法的一个子模块，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
迷宫问题的A*算法(python实现)
07-05
附件中A_star.py为算法实现，有两个txt文件作为测试样例，mediumMaze是一个封闭的迷宫，openmaze是一个开放的迷宫
基于图搜索的规划算法之A*家族（四）：Lifelong Planning A*算法
昔风不起，唯有努力生存！
08-20 969
Lifelong Planning A* 算法能够应对环境的变化，并基于历史探索信息，得到应对新环境的新知识，避免计算资源不必要的浪费。此外，本文基于定理一与定理二以及原文伪代码中的BUG提出新的伪代码，基于新伪代码的实现使算法变得更加智能，对于那些不会影响最短路径的状态变化，算法选择Lazy的方式，不进入搜索主循环去浪费计算资源。环境不会在我执行任务的途中变化，环境的改变是上一个任务执行完成后到新任务开始执行前的间隙，就像政府会把修路的情况提前一天告知大家，避免延误大家的出行。............
Python制作AI贪吃蛇，很多很多细节、思路都写下来了！
Python宋宋的专栏
08-03 2315
蛇每走一步，就更新snake距离food的board距离，涉及 board_rest (更新每个非snake元素距离food的距离)和 board_refresh （本文这里采用BFS算法）），寻找到best_move，然后让蛇移动即可。熟悉Curses中相关指令后基本就没什么了， 保证按的下一个键不导致蛇死亡，保证蛇吃食物后食物不在蛇身上，保证蛇碰到自己和边框就死亡,如果按其他键，会导致头被插入2次，从而让蛇死亡。（通过以上方法，就可以制造一个基本AI贪吃蛇了，当然，还有很多细节方面东西需要考虑）...
踢馆朋友圈迷宫挑战——自动寻路（Python实现）
m0_59236127的博客
02-07 2369
背景 我打开手机，发现有人在QQ空间里叫嚣。 看他得意的样子，显然是在家里呆久了，已经忘了天有多高。 预处理 设计一个迷宫自动寻路算法并不难，但是对于当下这个任务而言，第一个棘手的地方在于，如何把这个迷宫变成计算机认识的样子，也就是迷宫图片的矩阵化。 图片的大小是397×390。先把四周的白边裁掉，再把这幅图中的每一个像素二值化，再根据颜色赋值，黑色用0表示，白色用1表示，建立一个0/1矩阵。考虑到迷宫的边界都是封闭的，为了防止由于图片质量问题导致某些看上去是0的地方其实是1，在之后走迷宫的过程中造成一些
a*寻路算法python
10-19
以下是使用Python实现A*寻路算法的基本步骤： 1. 定义节点类，包括节点坐标、启发函数值、代价值等属性，并实现比较运算符以便排序。 2. 初始化起点节点和目标节点，并将起点节点加入到开放列表中。 3. 进入循环...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值