DFS和BFS学习笔记

DFS

dfs指的是深度优先搜索，即从起始点开始，沿着某一条路径一直向前搜索，没有后继节点时，回溯到最近的拥有分支的节点,然后向另一条路径搜索，一旦遇到死胡同,就进行回溯，直到到达终点或者搜索完所有路径。
dfs在搜索时会遍历每一条路径，所以通常用来计算从起点到终点的路径数量，即在搜索过程中，一旦到达终点就把路径计数加一

BFS

bfs指的是广度优先搜索，即从起始点出发，从临近点开始一环一环向外搜索。可以想象为把一个图结构按照与起始点距离从中心向外围摆放，然后从内向外一圈一圈的搜索，直到找到终点
bfs是按照从近到远搜索的，所以如果找到终点，则一定为从起点到终点的最短路径，注意，只适用于无权图,可以在迷宫问题中使用

---

下面是简单图解

对这样的图，设1为起点，8为终点

dfs会按照：

• 1–>2–>5–>7–>8 回溯到1
• 1–>3–>5–>7–>8 回溯到3
• 3–>6–>7–>8 回溯到6
• 6–>8 回溯到1
• 1–>4–>6–>7–>8 回溯到6
• 6–>8
  所以一共有6条路径

bfs则是：

• 访问1，将1的邻点2，3，4加入待访问列表
• 取出并访问2，将2的邻点5加入待访问列表
• 取出并访问3，将3的邻点5，6加入待访问列表（注意5已经加入了待访问列表，你可以在加入时对重复加入进行处理，也可以在访问时对重复访问进行处理，效果一样）
• 重复操作，直到到达终点

注意到：

• dfs回溯时是后到达的点要先被回溯的，所以可以用栈来维护回溯的顺序
• bfs是先添加的点先访问，所以可以用队列来维护访问的顺序

此外，可以维护一个pre数组，用于记录某点的前驱，从而可以得到完整的路径

---

下面是一个简单的代码示例，用于求解迷宫问题

#为了避免边界判定，我在左侧添加了一列
maze = [
    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
    [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
    [1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1],
    [1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1],
    [1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
    [1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1],
    [1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1],
    [1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1],
    [1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1],
    [1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1],
    [1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1],
    [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
    [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1],
    [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
]



def BFS(maze):
    ans = []
    rows = len(maze)
    cols = len(maze[0])
    start = (13, 1)
    end = (1, 15)
    visited = [[False for _ in range(cols)] for _ in range(rows)]
    prev = [[None for _ in range(cols)] for _ in range(rows)]
    queue = [start]
    dx = [-1, 0, 1, 0]
    dy = [0, -1, 0, 1]
    while queue:
        point = queue.pop(0)
        if visited[point[0]][point[1]]:
            continue
        else:
            visited[point[0]][point[1]] = True
            if maze[point[0]][point[1]]:
                continue
            if point == end:
                t = point
                while True:
                    ans.insert(0, f'({t[0]},{t[1]})')
                    if t == start:
                        break
                    t = prev[t[0]][t[1]]
                break
            for i in range(4):
                x = point[0] + dx[i]
                y = point[1] + dy[i]
                if visited[x][y]:
                    continue
                queue.append((x, y))
                prev[x][y] = point

    print('->'.join(ans))

BFS(maze)
def DFS(maze):
    ans = []
    start = (13, 1)
    end = (1, 15)
    rows = len(maze)
    cols = len(maze[0])
    directions = [ (-1, 0),(0, -1), (1, 0), (0, 1)]
    prev = [[None for _ in range(cols)] for _ in range(rows)]
    stack = [start]
    visited = set()

    while stack:
        node = stack.pop()
        x, y = node
        if node == end:
            t = node
            while True:
                ans.insert(0, f'({t[0]},{t[1]})')
                if t == start:
                    break
                t = prev[t[0]][t[1]]
            break
        visited.add(node)
        for dx, dy in directions:
            nx = x + dx
            ny = y + dy
            if rows > nx >= 0 == maze[nx][ny] and 0 <= ny < cols:
                if (nx, ny) not in visited:
                    stack.append((nx, ny))
                    prev[nx][ny] = node
    print('->'.join(ans))


DFS(maze)

可以看到运行结果如下：

(13,1)->(13,2)->(13,3)->(13,4)->(13,5)->(13,6)->(13,7)->(13,8)->(12,8)->(11,8)->(11,9)->(11,10)->(11,11)->(11,12)->(10,12)->(9,12)->(8,12)->(7,12)->(6,12)->(5,12)->(5,11)->(5,10)->(4,10)->(3,10)->(2,10)->(1,10)->(1,11)->(1,12)->(1,13)->(1,14)->(1,15)
(13,1)->(13,2)->(13,3)->(13,4)->(13,5)->(13,6)->(13,7)->(13,8)->(12,8)->(11,8)->(11,9)->(11,10)->(11,11)->(11,12)->(10,12)->(9,12)->(8,12)->(7,12)->(7,11)->(7,10)->(7,9)->(7,8)->(7,7)->(7,6)->(7,5)->(7,4)->(6,4)->(5,4)->(5,5)->(5,6)->(4,6)->(3,6)->(2,6)->(1,6)->(1,7)->(1,8)->(1,9)->(1,10)->(1,11)->(1,12)->(1,13)->(1,14)->(1,15)

虽然都找到了正确的路径，但是具体的路线却不同，在解决迷宫问题时，我们往往是要找到最短路径，所以我们应该优先使用BFS算法

---

2023.3.18