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