【python】【图解】BFS和DFS的区别（双向BFS）

LRY___

已于 2022-06-01 14:28:26 修改

阅读量633

点赞数

文章标签：深度优先 python 宽度优先

于 2022-05-12 18:10:32 首次发布

本文链接：https://blog.csdn.net/LRY___/article/details/124735534

版权

什么是BFS

BFS中文名称宽度优先搜索算法（又称广度优先搜索），是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。

什么是DFS

深度优先搜索是一种在开发爬虫早期使用较多的方法。它的目的是要达到被搜索结构的叶结点(即那些不包含任何超链的HTML文件) 。在一个HTML文件中，当一个超链被选择后，被链接的HTML文件将执行深度优先搜索，即在搜索其余的超链结果之前必须先完整地搜索单独的一条链。深度优先搜索沿着HTML文件上的超链走到不能再深入为止，然后返回到某一个HTML文件，再继续选择该HTML文件中的其他超链。当不再有其他超链可选择时，说明搜索已经结束。

BFS和DFS区别

宽度优先搜索算法，顾名思义，就是在搜索的时候优先横向（兄弟结点）搜索，而深度优先算法则是优先往下走（往叶子结点走），这样讲可能还是有点模糊，我们来看下面这张图就一目了然~
请添加图片描述
宽度优先算法：A→B\C\D→E\F\G→H
深度优先算法：A→B→E→C→F→H→G→D

运用

DFS：
经典的跳马问题

问题描述
　　一个8×8的棋盘上有一个马初始位置为(a,b)，他想跳到(c,d)，问是否可以？如果可以，最少要跳几步？
输入格式
　　一行四个数字a,b,c,d。
输出格式
　　如果跳不到，输出-1；否则输出最少跳到的步数。
样例输入
1 1 2 3
样例输出
1
数据规模和约定
　　0<a,b,c,d≤8且都是整数。

# 别人写的
a, b, c, d = map(int, input().split())
dir = [[1, 2], [1, -2], [2, 1], [-2, 1], [-2, -1], [2, -1], [-1, -2], [-1, 2]]  #各个方向的走位
visited = []

for i in range(9):  # 因为abcd不能为0，所以棋盘为0-8
    visited.append([0] * 9)

minnum = float('inf')  # 正无穷


def dfs(x, y, step):
    global visited, minnum  # 全局变量
    if step >= minnum: 
        return
    if x == c and y == d:
        minnum = step
        return
    for i in range(8):
        nx = x + dir[i][0]
        ny = y + dir[i][1]
        if nx > 0 and nx <= 8 and ny > 0 and ny <= 8: # 防止出界
            if visited[nx][ny] == 0:
                visited[nx][ny] = 1
                dfs(nx, ny, step + 1)
                visited[nx][ny] = 0

双向BFS（原视频）

双向BFS，就是从起点和终点同时进行搜索，这样就可以避免分支太多而造成时间与空间上的浪费，是一种优化算法。
如果从起点开始，使用单向算法，拿得到的解答树可能会非常的庞大，如同大海捞针！
如图：
在这里插入图片描述
如果采用单向算法，这无疑是巨大的工程！

而当采用双向算法之后，工程量会有明显的减少！这也是双向BFS的意义所在~

双向列队的计算怎么顺序安排呢？

哪边分支少就算哪边！
直到两边重合，那么这个步数相加，就是本题的答案了！

运用（原博文）

如下面第一个图的九宫格中，放着 1~8
的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。

我们把第一个图的局面记为：12345678. 把第二个图的局面记为：123.46758
显然是按从上到下，从左到右的顺序记录数字，空格记为句点。
本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。如果无论多少步都无法到达，则输出-1。

# 别人写的 我稍加注释，大家有哪里看不懂可以问我
# 采用双向BFS
# 注意：解这道题是看空白的移动！！不是数字移动
# 判断九宫格是否出界限
def check(x,y):
    return x<3 and x>=0 and y<3 and y>=0
# 将数组转换为字符串
def toString():
    global m
    l = ''
    for i in range(3):
        for j in range(3):
            l +=m[i][j]
    return l

# 将字符串转换为数组
def toMatrix(strn):
    global m
    # 定义二维数组
    m = [[None]*3 for i in range(3)]
    for i in range(len(strn)):
        m[i//3][i%3]=strn[i]

def doublebfs(first,last):
    global m
    dira = [[0,1],[0,-1],[1,0],[-1,0]] # 用来记录方向
    q1 = []
    # q1: ['1234567.8', '12345.786']
    q2 = []
    # q2: ['1234.6758', '123746.58', '.23146758']
    dis = {}  # 开始查找的点到当前点的一个距离
    # dis:{'12345678.': 1, '123.46758': 1, '1234.6758': 2, '123746.58': 2, '.23146758': 2, '1234567.8': 2, '12345.786': 2}
    vis = {}  # 访问标记 q1访问过的点标记为1 q2访问过的点标记为2
    # vis:{'12345678.': 1, '123.46758': 2, '1234.6758': 2, '123746.58': 2, '.23146758': 2, '1234567.8': 1, '12345.786': 1}
    # 数值初始化
    q1.append(first)
    dis[first]=1
    vis[first]=1
    q2.append(last)
    dis[last]=1
    vis[last]=2
    while len(q1)>0 and len(q2)>0: # 如果其中一个队列为空，还没有找到解，说明无解
        if len(q1)<len(q2):  # 根据队列的容量来判断从哪一端开始查找，谁少谁先出列
            str1 = q1.pop(0)
            flag =1
        else:
            str1 = q2.pop(0)
            flag=2
        toMatrix(str1) # 将字符串转换为数组

        # 找到.的位置
        for i in range(3):
            for j in range(3):
                if m[i][j]=='.':
                    x=i
                    y=j

        # 从四个方向开始探测
        for i in range(4):
            tx = x + dira[i][0]
            ty = y + dira[i][1]
            # 判断是否出界
            if check(tx,ty):
                # 没有出界就探测
                m[x][y],m[tx][ty] = m[tx][ty],m[x][y]
                # 将数组转换为字符串
                str2 = toString()
                if not str2 in dis.keys(): # 如果这个点还没有被访问过 就标记
                    dis[str2] = dis[str1]+1
                    vis[str2] = vis[str1] # q1=1 q2=2 这样写可以避免判断是从那一端开始查找str2
                    # 如果刚开始是从q1从pop出来就push到p1
                    if flag==1:
                        q1.append(str2)
                    elif flag==2:
                        q2.append(str2)
                else: # 如果已经访问过就判断标记是否重合
                    if vis[str1]+vis[str2]==3:
                        ans = dis[str1]+dis[str2]-1 # 因为刚开始dis=1
                        return ans
                # 回溯 重新探测
                m[x][y], m[tx][ty] = m[tx][ty], m[x][y]
        # print("dis:"+str(dis))
        # print("vis:"+str(vis))
        print("q1:"+str(q1))
        print("q2:"+str(q2))
    return -1 # 找不到
first = input().strip()
last = input().strip()
if last == first:
    print('0')
else:
    print(doublebfs(first,last))