不到一百行python代码简单实现A星算法

为了更好地理解A星算法,自己手撸了一段91行的代码来实现A星算法
可能代码风格不是很好,因为这也就是一上午写出来的,只是简单实现了A星
过两天准备好好改动一下代码使其更易读,再好好备注一下。
#python3.7.3

import numpy as np
#设置地图和障碍,障碍物为1
tarmap=np.zeros((24,24))
tarmap.astype(np.int32)
tarmap[2][0:5]=1
tarmap[0:5,6]=1
tarmap[5,3:10]=1
tarmap[7,1:20]=1
def showMap(tarmap):#打印地图
    for i in tarmap:
        print(i)
showMap(tarmap)
class node:#每一个节点的初始化,有一个打印节点坐标和F值的方法
    def __init__(self,point,end,father=None):
        self.x=point[0]
        self.y=point[1]
        self.father=father
        if father==None:
            self.G=None
            self.H=None
            self.F=None
        else:
            self.G=(10 if abs(father.x-self.x)+abs(father.y-self.y)==1 else 14)
            self.H=abs(end[0]-self.x)*10+abs(end[1]-self.y)*10
            self.F=self.G+self.H
    def show(self):
        print([self.x,self.y],self.F)
openlist=[]
closelist=[]
start=[0,0]
end=[23,23]
def findMinF(openlist):#在openlist中找到最小F的节点
    minF=999999999
    minIndex=0
    for i,j in enumerate(openlist):
        if j.F==None:
            continue
        if j.F<minF:
            minF,minIndex=j.F,i
    return openlist[minIndex]
def nodeIn(point,openlist):#查看节点是否在openlist中
    for i in openlist:
        if point.x==i.x and point.y==i.y:
            return i
    return False
def listAppend(point,openlist,tarmap):#将当前节点的邻近节点更新并加入到openlist中
    points=[]
    temp=[-1,0,1]
    for i in temp:
        for j in temp:
            points.append([point.x+i,point.y+j])
    points.pop(4)
    for i in points:
        if 23>=i[0]>=0 and 23>=i[1]>=0:
            t=node(i,end,point)
            t1=nodeIn(t,openlist)
            t2=nodeIn(t,closelist)
            if tarmap[i[0],i[1]]==1 or t2 is not False:
                continue
            if t1 and t1.G>t.G:
                openlist.remove(t1)
                openlist.append(t)
            if t1 is False:
                openlist.append(t)
def getres(res,tarmap):#从终点找到来时的路径并将路径画到原来的地图上
    reslist=[]
    cur=res
    while [cur.x,cur.y]!=start:
        reslist.append([cur.x,cur.y])
        cur=cur.father
    reslist.append([cur.x,cur.y])
    for i in reslist:
        tarmap[i[0],i[1]]=2
    showMap(tarmap)
    return reslist
#实际操作
openlist.append(node(start,end))
while openlist!=[] or nodeIn(node(end,end),closelist) is False:
    temp=findMinF(openlist)
    openlist.remove(temp)
    closelist.append(temp)
    listAppend(temp,openlist,tarmap)
print('-----------------------------')
res=nodeIn(node(end,end),closelist)
reslist=getres(res,tarmap)
### 回答1: Python代码实现A寻路算法可以使用以下代码:def astar(start, goal): closedset = set() openset = set([start]) came_from = {} gscore = {start: 0} fscore = {start: heuristic_cost_estimate(start, goal)} while openset: current = min(openset, key=fscore.get) if current == goal: return reconstruct_path(came_from, current) openset.remove(current) closedset.add(current) for neighbor in get_neighbors(current): if neighbor in closedset: continue tentative_gscore = gscore[current] + dist_between(current, neighbor) if neighbor not in openset: openset.add(neighbor) elif tentative_gscore >= gscore[neighbor]: continue came_from[neighbor] = current gscore[neighbor] = tentative_gscore fscore[neighbor] = gscore[neighbor] + heuristic_cost_estimate(neighbor, goal) return False ### 回答2: A寻路算法是一种常用的路径规划算法,可以在给定的地图中找到最短路径。下面是用Python实现A寻路算法代码示例: ```python import heapq # 定义节点类 class Node: def __init__(self, row, col, g, h): self.row = row self.col = col self.g = g self.h = h def __lt__(self, other): return self.g + self.h < other.g + other.h # 计算启发式代价(h值) def heuristic(row, col, target_row, target_col): return abs(target_row - row) + abs(target_col - col) # A寻路算法 def astar_search(start, target, grid): directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] # 上下左右四个方向 rows, cols = len(grid), len(grid[0]) visited = set() # 已访问的节点集合 pq = [] # 优先队列,用来选择下一个节点 heapq.heappush(pq, start) while pq: curr_node = heapq.heappop(pq) row, col = curr_node.row, curr_node.col visited.add((row, col)) if row == target.row and col == target.col: return curr_node.g for d in directions: new_row, new_col = row + d[0], col + d[1] if 0 <= new_row < rows and 0 <= new_col < cols and grid[new_row][new_col] != 1: new_g = curr_node.g + 1 new_h = heuristic(new_row, new_col, target.row, target.col) new_node = Node(new_row, new_col, new_g, new_h) if (new_row, new_col) not in visited: heapq.heappush(pq, new_node) return -1 # 示例 grid = [[0, 0, 0], [1, 1, 0], [0, 0, 0]] start = Node(0, 0, 0, 0) target = Node(2, 2, 0, 0) result = astar_search(start, target, grid) print(result) ``` 以上代码实现了A寻路算法,并可用于寻找给定地图中起点到目标点的最短路径。其中,`grid`是二维列表表示地图,在地图中,0表示可通过的节点,1表示不可通过的节点。`start`表示起点,`target`表示目标点。通过调用`astar_search`函数,将起点、目标点和地图作为参数进传递,即可得到最短路径的长度。 ### 回答3: A寻路算法是一种常用于寻找最短路径的算法,广泛应用于游戏开发、路径规划等领域。下面是使用Python实现A寻路算法代码: ```python # 定义地图和起终点 map = [ [0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0] ] start = (1, 1) # 起点坐标 goal = (6, 5) # 终点坐标 # 定义辅助函数 def heuristic(pos1, pos2): # 估算两点之间的距离(启发函数) x1, y1 = pos1 x2, y2 = pos2 return abs(x1 - x2) + abs(y1 - y2) def get_neighbors(pos): # 获取当前位置的邻近位置 x, y = pos neighbors = [] for dx in [-1, 0, 1]: for dy in [-1, 0, 1]: if dx == dy == 0: # 排除当前位置 continue new_x, new_y = x + dx, y + dy if 0 <= new_x < len(map) and 0 <= new_y < len(map[0]) and map[new_x][new_y] == 0: neighbors.append((new_x, new_y)) return neighbors # 定义A算法函数 def astar_search(start, goal): # 初始化起点和终点 open_list = [start] # 待探索的节点 came_from = {} # 记录路径中每个节点的上一个节点 g_score = {start: 0} # 起点到每个节点的实际代价 f_score = {start: heuristic(start, goal)} # 起点到每个节点的估算代价(f_score = g_score + h_score) while open_list: current = min(open_list, key=lambda x: f_score[x]) # 获取f_score最小的节点 if current == goal: # 已到达终点 path = [] while current in came_from: path.append(current) current = came_from[current] path.append(start) path.reverse() return path open_list.remove(current) for neighbor in get_neighbors(current): g_temp = g_score[current] + 1 # 节点到邻近节点的代价为1 if neighbor not in g_score or g_temp < g_score[neighbor]: came_from[neighbor] = current g_score[neighbor] = g_temp f_score[neighbor] = g_temp + heuristic(neighbor, goal) if neighbor not in open_list: open_list.append(neighbor) return [] # 未找到路径 # 在地图上运A算法 path = astar_search(start, goal) print("路径: ", path) ``` 该代码首先定义了一个地图,使用0表示可走的区域,使用1表示障碍物。将起点和终点设定好后,通过`heuristic`函数计算两点间的估算距离。`get_neighbors`函数用于获取当前位置的邻近位置。 `astar_search`函数是实现A算法的核心部分。其中,`open_list`用于存放待探索的节点,`came_from`用于记录路径中每个节点的上一个节点,`g_score`用于记录起点到每个节点的实际代价,`f_score`用于记录起点到每个节点的估算代价。算法使用一个循环不断探索下一个最有可能的节点,直到找到终点或无法找到路径为止。 最后,在地图上运A算法,并输出结果路径。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值