算法：深度优先搜索之迷宫寻径

Posted 2021-04-11 我的时光穿梭机

深度优先搜索（depth-first search, DFS）：一种试图穷尽所有可能直到抵达问题边界条件，然后依次返回搜索结果的算法。本质是递归实现。

以下是在迷宫中走最短路径的算法实现。结果会返回所有可能路径以及一条最短路径。

# To define a stack.
class Stack():
    def __init__(self,stack):
        self.stack = stack
        self.head = 0
        self.tail = len(self.stack)
    def push(self,element):
        self.stack.append('')
        self.stack[self.tail] = element
        self.tail += 1
    def pop(self):
        self.tail -= 1
        pop_item = self.stack[self.tail]
        self.stack = self.stack[self.head:self.tail]
        return pop_item
    def peek(self):
        return self.stack[self.tail-1]
    def is_empty(self):
        return self.head >= self.tail
    def size(self):
        return len(self.stack[self.head:self.tail])
    def clear(self):
        self.stack.clear()
        self.head = self.tail
# To define a maze.
maze = [
'..#.',
'....',
'..#.',
'.#T.',
'...#',
]
# A depth first search function to probe the maze until a walkable path is found.
def walk(x,y):
    # plan: store the number of walkable paths.
    global plan
    # inc: store the increment (or direction) per step.
    inc = [(0,1),(1,0),(-1,0),(0,-1)]
    # flag: store the availability status ('0': available, has not been probed; '1': unavailable, has already been probed;) of current (x,y) or next (nx,ny) step.
    flag.setdefault((x,y),1)
    for i in range(4):
        # (nx,ny): coordinate of next step.
        nx = x+inc[i][0]
        ny = y+inc[i][1]
        flag.setdefault((nx,ny),0)
        # To identify the walkable status of next step. If the next step has been out of the maze borders or blocked by a barrier ('#') or probed (flag == 1), then it is skipped.
        if nx < 0 or nx > row-1 or ny <0 or ny > clmn-1 or maze[nx][ny] == '#' or flag[(nx,ny)] == 1:
            continue
        else:
            # If next step is our target, this round of probing shall be ended and recorded.
            if maze[nx][ny] == 'T':
                stc.push((nx,ny))
                path.setdefault(plan,stc.stack)
                stc.pop()
                plan += 1
                return
            # If next step is walkable, the probing shall be repeated by taking the next step as current step.
            # Before probing, the next step should be marked as 'walked' (flag == 1) and pushed into the stack. After probing, the next step should be marked as 'walkable' (flag == 0) and popped out of the stack. This is critical for proper running of the recursion.
            if maze[nx][ny] == '.':
                flag[(nx,ny)] = 1
                stc.push((nx,ny))
                walk(nx,ny)
                stc.pop()
                flag[(nx,ny)] = 0
    # return all the possible strategies to walk to the target.
    return path
if __name__=='__main__':
    # To define initial status of the maze and relevant variables.
    row = len(maze)
    clmn = len(maze[0])
    flag = {}
    path = {}
    stc = Stack([])
    stc.push((0,0))
    plan = 0
    paths = walk(0,0)
    # sort the paths according the steps needed, and output them.
    sorted_paths = sorted(paths.items(),key = lambda item:len(item[1]))
    for p in sorted_paths:
        print(p)
    optimal_path = sorted_paths[0][1]
    print('There are %s paths to the target. The shortest path include %s steps %s'%(len(paths),len(optimal_path)-1,optimal_path))