python栈迷宫路径搜索_深度优先搜索(DFS)

python链栈算法,DFS深度优先搜索

python栈迷宫路径搜索_深度优先搜索(DFS)_第1张图片

算法通过尝试四个方向(上、下、左、右)来探索迷宫。它使用一个栈来记录当前路径。如果到达终点,它会打印路径并返回True。如果找不到路径,它会打印"走不通!"并返回False。

# 1. 当前所在节点四个方向分别为 x+1,y; x-1,y; x,y+1; x,y-1
# 2. 当前节点,也就是栈里的最后一个节点 stack[-1]
# 3. 当走到终点时,就可以输出栈了
# 4. 没走到终点并且下一节点能走时,把该下一节点加入栈并标记为2,表示走过了
# 5. 没走到终点,并且四个节点都不能走时,把该下一节点做个标记,并删除原来的节点(回退)
# 6. 如果一条路都不能走时,就说明没有路可以走了
maze = [ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],        #1就是墙,0就是路
         [1, 0, 0, 1, 0, 0, 0, 1, 0, 1],        #原点在左上角
         [1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
         [1, 0, 0, 0, 0, 1, 1, 0, 0, 1],
         [1, 0, 1, 1, 1, 0, 0, 0, 0, 1],
         [1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
         [1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
         [1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
         [1, 1, 0, 0, 0, 0, 0, 0, 0, 1],
         [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
# 1. 当前所在节点四个方向分别为 x+1,y; x-1,y; x,y+1; x,y-1
# 2. 当前节点,也就是栈里的最后一个节点 stack[-1]
# 3. 当走到终点时,就可以输出栈了
# 4. 没走到终点并且下一节点能走时,把该下一节点加入栈并标记为2,表示走过了
# 5. 没走到终点,并且四个节点都不能走时,把该下一节点做个标记,并删除原来的节点(回退)
# 6. 如果一条路都不能走时,就说明没有路可以走了

def maze_path(x1, y1, x2, y2):  # 起点终点
    dirs = [
        lambda x, y: (x + 1, y),  #lambda函数对x或y进行加减
        lambda x, y: (x, y + 1),  #g=lambda x:x+1 print(g(1))  #结果为2(匿名函数lambbda用法举例)
        lambda x, y: (x - 1, y),  #如何让二维矩阵产生直角坐标系的效果?-----maze[3][2])前y后x
        lambda x, y: (x, y - 1)
    ]  # 四个方向
    stack = [(x1, y1)]  #
    while len(stack) > 0:
        curNode = stack[-1]     #往前走的那个头的坐标
        if curNode[0] == x1 and curNode[1] == x2:
            # 判断走到终点了
            for p in stack:
                print(p)  # 打印路线
            return True #如果不在这里整一个返回值的话,最下面的“走不通”
        # 尝试四个方向 上:x-1,y 下:x+1,y 左:x,y-1 右: x,y+1
        for dir in dirs:  #for 循环让上下左右每一条路都尝试一下
            nextNode = dir(curNode[0], curNode[1]) #更新前进的头的位置
            if maze[nextNode[0]][nextNode[1]] == 0: #nextNode[0]是curNode[0],curNode[0]是当前结点的x1,curNode[1]是当前结点的y1
                stack.append(nextNode)#只有是0,1才会更新栈顶
                maze[nextNode[0]][nextNode[1]] = 2 #没走到终点并且下一节点能走时,把该下一节点加入栈并标记为2,表示走过了
                break #跳出for循环
        else:   # 如果当前的路线走到死胡同时,把当前节点标记成2,并且出栈
            maze[nextNode[0]][nextNode[1]] = 2 #将零变成二
            stack.pop()
    else:
        print('走不通!')
        return False


maze_path(1, 4, 8, 7)

深度优先搜索(Depth-First Search,DFS)是一种用于遍历或搜索树或图的算法。它从起始节点开始,沿着一条路径尽可能深入地探索,直到无法继续前进,然后回溯到上一个节点,继续探索其他路径,直到遍历完所有节点。

DFS的基本思想是使用栈来保存待探索的节点。算法的步骤如下:

  1. 将起始节点放入栈中。
  2. 从栈中弹出一个节点作为当前节点。
  3. 检查当前节点是否为目标节点。如果是,则算法结束。
  4. 如果当前节点不是目标节点,则将当前节点标记为已访问,并将其未访问的邻居节点(如果有)放入栈中。
  5. 重复步骤2-4,直到栈为空或找到目标节点。

DFS的特点是深度优先,即尽可能深入地搜索。它不保证找到最短路径,但可以找到一条路径。在搜索问题中,DFS常用于解决迷宫问题、图的连通性问题、拓扑排序等。

然而,DFS也具有一些缺点。由于其深度优先的特性,它可能陷入无限循环,特别是在存在环的图中。此外,DFS不一定能找到最优解,因为它只关注一条路径,而不是搜索所有可能的路径。

为了应对DFS的缺点,可以使用一些技巧,如设置最大搜索深度、使用剪枝策略、记录已访问节点等。

你可能感兴趣的:(python数据结构,深度优先,算法,python,数据结构,学习方法,链表)