A*算法解决迷宫寻路问题

A*算法解决迷宫寻路问题

问题描述

下图是一个迷宫，试为机器人找一条从Start到End的最短路径设计一搜索算法

设计思路

a)状态空间的表示
首先将迷宫图转换为列表形式呈现，每个格子用
（横坐标，纵坐标，上通路状态，下通路状态，左通路状态，右通路状态）来表示，通路状态用1或0表示，可通过为1，不可通过为0。比如起点（1，1），假定不能从起点出去，所以（1,1）可以走下或走右，所以第一格的状态表示为（1,1,0,1,0,1）。
整张迷宫图的状态表示为：

同时每一步操作都记录在列表中，比如向下移动一格后，列表元素变为[(1,2,1,1,0,1),(1,1,0,1,0,0)]。

b)操作集
该问题通过“上，下，左，右”四个方向进行下一节点的生成和移动，同时通过四个方向的通路状态来判断下一方向节点是否可通过，以此来限制节点的生成。

c)算法使用策略
使用A*算法，估价函数使用h(n) = A * B（A为横坐标，B为纵坐标），用h(n)递减重排open表，同时对生成节点进行是否重复判断。 为清楚起见，每一格子均以其右下角坐标（x，y）为标志。如start格用（1，1），end格用（7，6）标志。

完整代码

def GJ(this):#估价函数计算 h(n) = A*B
    return this[0] * this[1]

def Judge(this,p):
    this_copy = this[:]
    this_copy.insert(0,p)
    for i in open:
        for x in i:
            if p == x:
                return
    for i in closed:
        for x in i:
            if p == x:
                return
    open.append(this_copy)
    return

def found(k,array):
    for i in array:
        if i[0:2]== k:
            return i

if  __name__ == '__main__':

    M = [(1,1,0,1,0,0),(2,1,0,0,1,1),(3,1,0,0,1,0),(4,1,0,1,0,1),(5,1,0,0,1,0),(6,1,0,1,0,1,),(7,1,0,0,1,0),
         (1,2,1,1,0,1),(2,2,0,1,1,1),(3,2,0,0,1,1),(4,2,1,1,1,0),(5,2,0,0,0,1),(6,2,1,1,1,1),(7,2,0,1,1,0),
         (1,3,1,1,0,0),(2,3,1,1,0,1),(3,3,0,1,1,0),(4,3,1,0,0,1),(5,3,0,0,1,0),(6,3,1,1,0,0),(7,3,1,0,0,0),
         (1,4,1,0,0,0),(2,4,1,1,0,0),(3,4,1,0,0,1),(4,4,0,0,1,1),(5,4,0,1,1,0),(6,4,1,1,0,1),(7,4,0,1,1,0),
         (1,5,0,1,0,1),(2,5,1,1,1,0),(3,5,0,1,0,0),(4,5,0,1,0,1),(5,5,1,0,1,0),(6,5,1,1,0,0),(7,5,1,1,0,0),
         (1,6,1,0,0,1),(2,6,0,0,1,1),(3,6,1,0,1,0),(4,6,1,0,0,1),(5,6,0,0,1,1),(6,6,1,0,1,0),(7,6,1,1,0,0)]

    start = M[0]
    end = M[-1]
    open = []  #创建open表
    closed = [] #创建closed表
    open.append([start])
    while(1):
        if len(open) == 0:
            print("未搜索到解！")
            break
        else:
            this = open.pop(0)
            closed.append(this)
            if this[0] == end:
                print("路线寻找成功！")
                print('迷宫寻找出口路线：')
                for i in this[::-1]:
                    print('-->',i[0:2])
                exit()

        #扩展节点
           #向上寻找
            if this[0][2] == 1:
                change1 = this[0][0]
                change2 = this[0][1]-1
                k = (change1,change2)
                p = found(k,M)
                Judge(this,p)
            # 向下寻找
            if this[0][3] == 1:
                change1 = this[0][0]
                change2 = this[0][1] + 1
                k = (change1,change2)
                p = found(k,M)
                Judge(this,p)
            # 向左寻找
            if this[0][4] == 1:
                change1 = this[0][0] - 1
                change2 = this[0][1]
                k = (change1,change2)
                p = found(k,M)
                Judge(this,p)
            # 向右寻找
            if this[0][5] == 1:
                change1 = this[0][0] + 1
                change2 = this[0][1]
                k = (change1,change2)
                p = found(k,M)
                Judge(this,p)

            #计算估计函数h(n) = A*B 重排open表
            for x in range(0,len(open)-1):
                m = x
                for y in range(x+1,len(open)):
                    if  GJ(open[x][0]) <  GJ(open[y][0]):
                        m = y
                if m != x:
                    open[x],open[m] = open[m],open[x]

运行结果