DFS 的本质就是递归，不同的是在递归的过程中加点料，由于递归的特殊操作模式，人脑很难模拟整个过程，而从我们熟知的排列数字和八皇后可以看出，基本套路是先枚举本层的所有可能，再进行递归，也就是枚举所有本层兄弟的可能，再向下走，而下一层也是这样的过程。关于是否回溯，其实只要是递归就要回溯，所以必定有返回值，有的人认为恢复现场就是回溯，其实是不正确的。关于是否需要恢复现场，如果后面操作涉及到前面的内容，则需要恢复现场，但是如果是树的重心这道题，则不需要，根本原因在于变量的作用范围，用变量记录了子树中节点的个数，每个节点遍历过程也不需要重复，所以不需要恢复现场。递归的逻辑自洽，是能够在某个节点结束递归（一般是在最后一层或者叶子结点），而且不管哪一层的操作过程都是相同的，就可以使用递归，这样理解树的重心会更加容易些。

二、搜索与暴力法

1、概念

搜索：“暴力法” 算法思想的具体实现。

搜索：“通用” 的方法。一个问题，如果比较难，那么先尝试一下搜索，或许能启发出更好的算法。

技巧：竞赛时遇到不会的难题，用搜索提交一下，说不定部分判题数据很弱，得分了!

【暴力法】

暴力法 (Brute force，又译为蛮力法)。

把所有可能性都列举出来，一一验证。简单直接！

利用计算机强大的计算能力和存储能力。

蛮力法也是一种重要的算法设计技术：

（1）理论上，蛮力法可以解决可计算领域的各种问题。

（2）蛮力法经常用来解决一些较小规模的问题。

（3）对于一些重要的问题蛮力法可以产生一些合理的算法，具备一些实用价值，而且不受问题规模的限制。

（4）蛮力法可以作为某类问题时间性能的底限，来衡量同样问题的更高效算法。

【蛮力的基本方法】⭐⭐⭐

蛮力的基本方法——扫描

关键——依次处理所有元素

基本的扫描技术——遍历

（1）集合的遍历

（2）线性表的遍历

（3）树的遍历

（4）图的遍历

2、搜索的基本思路

【BFS】

Breadth-First Search，宽度优先搜索，或称为广度优先搜索

【DFS】

Depth-First Search，深度优先搜索

3、BFS：一群老鼠走迷宫

老鼠无限多；
在每个路口，都派出部分老鼠探索所有没走过的路；
走某条路的老鼠，如果碰壁无法前行，就停下；
如果到达的路口已经有别的老鼠探索过了，也停下；
所有的道路都会走到，而且不会重复。

全面扩散、逐层递进

4、DFS：一只老鼠走迷宫

只有一只老鼠；
在每个路口，都选择先走右边（当然，选择先走左边也可以)，能走多远就走多远；
碰壁无法再继续往前走，回退一步，这一次走左边，然后继续往下走；
能走遍所有的路，而且不会重复 (回退不算重复)。

一路到底、逐层回退

三、DFS

1、DFS访问示例

设先访问左节点，后访问右节点

模拟老鼠走迷宫

访问顺序：{E B A D C G F I H}。

2、DFS的常见操作

DFS的代码比BFS更简短。

DFS的主要操作：

        时间戳

                DFS序

                树深度

                子树节点数

                中序输出

                先序输出

                后序输出

3、DFS基础：递归和记忆化搜索

形式上，递归函数是 “自己调用自己”，是一个不断 “重复” 的过程。
递归的思想，是把大问题逐步缩小，直到变成最小的同类问题的过程，而最后的小问题的解是已知的，一般是给定的初始条件。
到达最小问题后，再“回溯”，把小问题的解逐个带回给更大的问题，最终最大问题也得到了解决。
递归有两个过程：递归前进、递归返回（回溯）。
在递归的过程中，由于大问题和小问题的解决方法完全一样，那么大问题的代码和小问题的代码可以写成一样。
一个递归函数，直接调用自己，实现了程序的复用。

例如：斐波那契数列

递推式：f(n)=f(n-1)+f(n-2)

打印第20个数：


fib=[0]*25
fib[1]=1
fib[2]=1
for i in range(3,21):
    fib[i]=fib[i-1]+fib[i-2]
print(fib[20])
'运行

改用递归实现：


def fib(n):
    global cnt
    cnt+=1
    if n==1 or n==2:
        return 1
    return fib(n-1)+fib(n-2)    #递归调用自己2次，复杂度O(2^n)
 
cnt=0
print(fib(20))
print(cnt)          #递归了cnt=13529次
'运行

递推和递归两种代码，结果一样，计算量差别巨大：

递推代码：一个 for 循环，计算 20 次。

递归代码：计算第 20 个斐波那契数，共计算 cnt=13529 次。

为什么斐波那契的递归代码如此低效？

【原因】

代码低效的原因：return fib(n-1)+fib(n-2)

递归调用了自己 2 次，倍增计算 fib(n) 时，共执行了 O(2^n) 次递归

不过，很多递归函数只调用自己一次，不会额外增加计算量。

【改进：记忆化】

递归的过程中做了重复工作，例如 fib(3) 计算了 2 次，其实只算 1 次就够了。

为避免递归时重复计算，可以在子问题得到解决时，就保存结果，再次需要这个结果时，直接返回保存的结果就行了，不继续递归下去。这种存储已经解决的子问题结果的技术称为 “记忆化（Memoization）”。

记忆化是递归的常用优化技术。动态规划也常常用递归写代码，记忆化也是动态规划的关键技术。


import sys
sys.setrecursionlimit(30000)    #设置递归深度
def fib(n):
    global cnt
    cnt+=1
    if n==1 or n==2:
        data[n]=1
        return data[n]
    if data[n]!=0:
        return data[n]
    data[n]=fib(n-1)+fib(n-2)
    return data[n]
data=[0]*3005
cnt=0
print(fib(300))
print(cnt)
'运行

递归的关键问题：递归深度不能太大。

Python 默认递归深度 1000，如果递归深度太大，提示 "maximum recursion depth exceeded in comparison"。

用 sys.setrecursionlimit() 设置递归深度。

常常有深度大于 1000 的递归题目

4、DFS的代码框架（大量编码后回头体会）

DFS的框架，请在大量编码的基础上，再回头体会这个框架的作用。

5、DFS：保护现场、恢复现场

在 DFS 框架中，最让初学者费解的是第 10 行和第 12 行。

第 10 行的 used[i]=1，称为“保存现场”，或“占有现场”。

第 12 行的 used[i]=0，称为“恢复现场”，或“释放现场”。

6、DFS：搜索和输出所有路径

【题目描述】给出一张图，输出从起点到终点的所有路径。

【输入描述】第一行是整数 n, m，分别是行数和列数。后面 n 行，每行 m 个符号。'@' 是起点， '*' 是终点，'·' 能走，'#' 是墙壁不能走。在每一步，都按左-上-右-下的顺序搜索。在样例中，左上角坐标 (0,0)，起点坐标(1,1)，终点坐标 (0,2)。1<n,m <7。

【输出描述】输出所有的路径。坐标 (i, j) 用 ij 表示，例如坐标 (0,2) 表示为 02。从左到右是 i，从上到下是 j。

【输入样例】

5 3

.#.

#@.

*..

...

#.#

【输出样例】

from 11 to 02

1:11->21->22->12->02

2:11->21->22->12->13->03->02

3:11->21->22->23->13->03->02

4:11->21->22->23->13->12->02

5:11->12->02

6:11->12->22->23->13->03->02

7:11->12->13->03->02

（1）模拟路径过程

【第一条路经】

从起点 (1，1) 出发，查询它的 “左-上-右-下”哪个方向能走，发现 “左上” 不能走，可以走 “右”。
第一步走到右边的 (2，1)。然后从 (2，1) 继续走，它可以向上走到 (2，0)，但是后面就走不通了，退回来改走下面的 (2，2)。
逐步深入走到终点，最后得到一条从起点 (1，1) 到终点 (0，2) 的路径 ''11->21->22->12->02" 。
在这次DFS深入过程中，这条路径上曾经路过的点被 “保存现场”，不允许再次经过。
到达终点后，从终点退回，回溯寻找下一个路径。退回后 “恢复现场”。

【第二条路经】

搜到一条路径后，从终点 (0, 2) 退回到 (1, 2) ，继续走到 (1, 3)、(0, 3)、(0, 2)。

【第三条路经】

从终点 (0，2) 一路退回到 (2，2) 后，才找到新路径。
在退回的过程中，原来被 “保存现场的” (0, 3)、(1, 3)、(0, 2)，重新被 “恢复现场”，允许被经过。
例如 (1, 3)，在第二条路径中曾用过，这次再搜新路径时，在第三条路径中重新经过了它。
如果不 “恢复现场”，这个点就不能在新路径中重新用了。

【第四条路径】

（2）DFS搜索所有路径

“保存现场” 的作用，是禁止重复使用。当搜索一条从起点到终点的路径时，这条路径上经过的点，不能重复经过，否则就兜圈子了，所以路径上的点需要“保存现场”，禁止再经过它。没有经过的点，或者碰壁后退回的点，都不能“保存现场”，这些点可能后面会进入这条路径。
“恢复现场” 的作用。当重新搜新的路径时，方法是从终点（或碰壁的点）沿着旧路径逐步退回，每退回一个点，就对这个点“恢复现场”，允许新路径重新经过这个点。例如上图的点 (1，3)。

路径有很多条，需要记录每条路径然后打印，这个代码使用了 “输出最短路径的简单方法”：每到一个点，就在这个点上记录从起点到这个点的路径。
P[][] 记录路径，p[i][j] 用字符串记录了从起点到点 (i，j) 的完整路径。
第 13 行把新的点 (nx, ny) 加入到这个路径。这种“简单方法”浪费空间，适用于小图。


def dfs(x,y):
    global num
    for i in range(0,4):
        dir=[(-1,0),(0,-1),(1,0),(0,1)]     #左、上、右、下
        nx,ny=x+dir[i][0],y+dir[i][1]       #新坐标
        if nx<0 or nx>=hx or ny<0 or ny>=wy:    #不在地图范围内
            continue
        if mp[nx][ny]=='*':
            num+=1
            print("%d:%s->%d%d"%(num,p[x][y],nx,ny))    #打印路径
            continue            #不退出，继续找下一个路径
        if mp[nx][ny]=='.':
            mp[nx][ny]='#'      #保存现场。这个点在这次更深的dfs中不能再用
            p[nx][ny]=p[x][y]+'->'+str(nx)+str(ny)  #记录路径
            dfs(nx,ny)
            mp[nx][ny]='.'      #恢复现场，回溯之后，这个点可以再次使用
num=0
wy,hx=map(int,input().split())      #wy行，hx列。用num统计路径数量
a=['']*10
for i in range(wy):
    a[i]=list(input())      #读迷宫
mp=[['']*(10) for i in range(10)]       #二维矩阵mp[][]表示迷宫
for x in range(hx):
    for y in range(wy):
        mp[x][y]=a[y][x]
        if mp[x][y]=='@':   #起点
            sx=x
            sy=y
        if mp[x][y]=='*':   #终点
            tx=x
            ty=y
print("from %d%d to %d%d"%(sx,sy,tx,ty))
p=[['']*10 for i in range(10)]      #记录从起点到点path[i][j]的路径
p[sx][sy]=str(sx)+str(sy)
dfs(sx,sy)                          #搜索并输出所有的路径

（3）路径问题：BFS 和 DFS

搜所有的路径，应该用DFS；如果只搜最短路径，应该用BFS。

在一张图上，从起点到终点的所有路径数量是一个天文数字，读者可以用上面的代码试试一个 8×8 的图，看看路径总数是多少。但是搜最短的路径就比较简单，并不需要把所有路径搜出来之后再比较得到最短路，用BFS可以极快地搜到最短路。DFS适合用来处理暴力搜所有情况的题目

以上，DFS初入门

祝好

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】