有关DFS的基础总结

最新推荐文章于 2022-06-24 16:28:57 发布
最新推荐文章于 2022-06-24 16:28:57 发布
阅读量429 收藏
点赞数
分类专栏： ACM_dfs 文章标签： dfs 递归算法 递归 搜索 编程

感觉是不错的文章 收藏一下

一、深度优先搜索

深度优先搜索算法(Depth First Search)，是图论中的经典算法。
深度优先搜索算法是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当结点所有子结点那一层都被搜索过，再回溯返回到当前结点的邻结点，继续搜索，直到遍历完整棵树。一般采用的是前序遍历，先根然后再左右结点的方式进行。
一些经典的问题，比如八皇后、马走日、迷宫等，都可以通过深度优先搜索算法来解决。
为了方便描述，下文用DFS来做为深度优先搜索算法的简称。

二、我对DFS的认识
对于DFS，我相信很多人第一次接触很难设计出相应的算法，即便是有不错的编程经验。我第一次几乎没办法设计出解决八皇后的算法，即便是想了很久。最后没办法只好参照别人写的递归式的DFS。之后，虽然对这个算法有一点了解，但由于了解不够深度，过了几天就记不得了，下次又完全不知道怎么入手。然后需要再到网上搜下代码，看一遍后大概才双知道。而且发现每次写代码的时候心里总觉得不踏实，一开始总有错误的地方，并且每次写的代码都有些不同。总之，写过很多次后，依然是停留到了解的阶段，没办法进一步提升，特别是非递归式的DFS一直都停留到靠脑力记忆而不是理解的阶段。

今天周末有点时间，觉得有必要解决这些问题，试着花时间去归纳总结DFS的本质，看能否做到一劳永逸。
我设定的目标是：
1、不仅停留到理解阶段，而是要知道这个算法每一步的实现
2、捉住其中的本质，给出这个算法的设计框架。
3、在1与2的基础中，可以熟练写出递归与非递归两种实现方式 。

经过一个下午的研究，我发现任何DFS只需要通过下面几步就可以实现，无论是递归还是非递归方式。我给这几步分别做了一个命名，分别是find、forward、done、back。
如下：
1、find(right):在树的当前层，横向遍历，尝试找到ok的节点。（这一步通常被叫做剪枝，只留下ok的。）
2、forward(down):若在当前层找到ok的结点，并且当前层不是最后一层:把ok的节点放到当前层；进入下一层第一个结点。跳到find
3、done(right):若在当前层找到ok的结点，并且当前层是最后一层：打印出结果；进入当前层的下一个结点。跳到find
4、back(up):在当前层没有找到ok的节点：返回上一层当前结点的下一个兄弟节点。跳到find

其实最重要的是find。然后后面的forward、done、back只是用来控制搜索走向。这四步可以进一步总结成两步。
为了了解算法，我想最好的切入方式是从一些实例开始。下面分别从八皇后以及马走日等问题做为切入点来分析DFS

三、用DFS解八皇后

1、问题描述
八皇后问题是一个以国际象棋为背景的问题：如何能够在8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？
也就是说，使得棋盘中每个横向、纵向、左上至右下斜向、右上至左下斜向均只有一枚皇后。
八皇后有92组解，下面给出其中一种解的图例：

Image

2、 问题分析

规则是每一个皇后与前面的所有皇后不能在同一行、同一列、同一对角线。我们可以从第0行，第0列开始摆放，然后按照深度优先的原则，按照规则往更下面的行摆放皇后，直到摆放完8行。因为解不只一个，当某一行（包括最后一行跟最后一行之前的所有行）的所有列都被尝试过，再回溯返回到上一行，继续深度优先，直到遍历完整个棋盘的所有情况。得出所有的解。
八皇后问题可以看成是在深度为8的8叉树中，找出所有的解。

3、代码实现

递归算法：

 
 
  1. #include <stdio.h>
  2. #include <math.h>
  3.  
  4. /*八皇后问题是在8*8的棋盘上放置8枚皇后，使得棋盘中每个横向、纵向、左上至右下斜向、右上至左下斜向均只有一枚皇后。
  5. 求解出所有摆法,一共有92种摆法*/
  6.  
  7. const int N = 8; //棋盘行数
  8. int a[N] = {0}; //表示棋盘，若a[2]=2,则表示在第3行第2列放一个皇后，因为同一行不能放两个皇后，所以只需要1维数组就可以表示一个棋盘。
  9.  
  10. int solution = 0;//解的个数
  11.  
  12. //row行，col列, 是否可以摆皇后
  13. bool IsOK(int row, int col)
  14. {
  15.     for (int i = 0; i < row; i++)
  16.     {
  17.         if (a[i] == col || (abs(a[i] - col) == row - i))
  18.         {
  19.             return false;
  20.         }
  21.     }
  22.     return true;
  23. }
  24.  
  25. void Display()
  26. {
  27.     printf("第%d种解：\n",++solution);
  28.     for (int i = 0; i < N; i++)
  29.     {
  30.         for (int j = 0; j < N; j++)
  31.         {
  32.             if (a[i] == j)
  33.             {
  34.                 printf("%d", i);
  35.             }
  36.             else
  37.             {
  38.                 printf("#");
  39.             }
  40.         }
  41.         printf("\n");
  42.     }
  43.  
  44.     printf("-----------------\n");
  45. }
  46.  
  47. void DSF(int row)
  48. {
  49.     for (int col = 0; col < N; col++)
  50.     {
  51.         //find
  52.         if (IsOK(row, col))
  53.         {
  54.             a[row] = col;
  55.             //forward
  56.             if (row != N -1)
  57.             {
  58.                 DSF(row + 1);
  59.             }
  60.             else
  61.             {
  62.                 //done
  63.                 Display();
  64.             }
  65.             
  66.         }
  67.     }
  68.     //back
  69. }
  70.  
  71. int main()
  72. {
  73.     DSF(0);
  74.     return 0;
  75. }

非递归算法：

 
 
  1. #include <stdio.h>
  2. #include <math.h>
  3. #include <stack>
  4. using namespace std;
  5. /*八皇后问题是在8*8的棋盘上放置8枚皇后，使得棋盘中每个横向、纵向、左上至右下斜向、右上至左下斜向均只有一枚皇后*/
  6.  
  7. const int N = 8; //棋盘行数
  8. int a[N] = {0}; //表示棋盘，若a[2]=2,则表示在第3行第2列放一个皇后，因为同一行不能放两个皇后，所以只需要1维数组就可以表示一个棋盘。
  9.  
  10. int solution = 0;//解的个数
  11.  
  12. struct Node
  13. {
  14.     int row;
  15.     int col;
  16. };
  17.  
  18. //row行，col列, 是否可以摆皇后
  19. bool IsOK(Node node)
  20. {
  21.     for (int i = 0; i < node.row; i++)
  22.     {
  23.         if (a[i] == node.col || (abs(a[i] - node.col) == node.row - i))
  24.         {
  25.             return false;
  26.         }
  27.     }
  28.     return true;
  29. }
  30.  
  31. //打印出所有解
  32. void Print()
  33. {
  34.     printf("第%d种解：\n", ++solution);
  35.     for (int i = 0; i < N; i++)
  36.     {
  37.         for (int j = 0; j < N; j++)
  38.         {
  39.             if (a[i] == j)
  40.             {
  41.                 printf("%d", i);
  42.             }
  43.             else
  44.             {
  45.                 printf("#");
  46.             }
  47.         }
  48.         printf("\n");
  49.     }
  50.  
  51.     printf("-----------------\n");
  52. }
  53.  
  54. void DSF()
  55. {
  56.     Node node;
  57.     stack stack;
  59.     node.row = 0;
  60.     node.col = 0;
  61.     stack.push(node);
  62.     while(stack.size() >= 1)
  63.     {
  64.         //--find
  65.         node = stack.top();
  66.         while (node.col < N && !IsOK(node))
  67.         {
  68.             node.col++;
  69.         }
  71.         if (node.col < N)
  72.         {
  73.             //--forward
  74.             if (node.row < N-1)
  75.             {
  76.                 //把ok的节点放到当前层
  77.                 a[node.row] = node.col;
  78.                 stack.pop();
  79.                 stack.push(node);
  80.                 
  81.                 //进入下一层的第一个节点
  82.                 node.row++;
  83.                 node.col = 0;
  84.                 stack.push(node);
  85.             }
  86.             else
  87.             {
  88.                 //--done
  89.                 a[node.row] = node.col;
  90.                 Print();
  91.                 
  92.                 //进入当前层的下一个结点
  93.                 //node = stack.top();
  94.                 node.col++;
  95.                 stack.pop();
  96.                 stack.push(node);
  97.             }
  98.         }
  99.         else
  100.         {
  101.             //--back
  102.             stack.pop();
  103.             
  104.             if (stack.size() == 0)
  105.             {
  106.                 return;
  107.             }
  108.             node = stack.top();
  109.             node.col++;
  110.             stack.pop();
  111.             stack.push(node);
  113.         }
  115.     }
  117. }
  119. int main()
  120. {
  121.     DSF();
  122.     return 0;
  123. }

三、马走日

1、问题描述
在n*n的棋盘中，马只能走"日"字。马从位置(0,0)出发，把棋盘的每一格都走一次且只走一次。找出所有路径。 5*5的棋盘上，有304种解。
下面是其中一种路径的图例：

Image

2、问题分析
搜索过程是从(0,0)出发，按照深度优先的原则，从8个方向中尝试一个可以走的点，直到尝试过所有的方向，走完棋盘上的所有点，得出所有的解。
马走日问题可以看成是在层数为n*n的8叉树中，找出所有的解。

3、代码实现
同样的，也可以把上面的算法框架，套用于马走日的身上。
递归算法：

 
 
  1. #include <stdio.h>
  2.  
  3. /*马走日*/
  4.  
  5. const int N = 5; //棋盘行数跟列数
  6. int matrix[N][N] = {0}; //表示棋盘
  7. int solution = 0;//解的个数
  8. int count = 0; //第几步
  9. int move[8][2]={{-1,-2},{-2,-1}, {-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2}};//八个方向
  10.  
  11. //在棋盘范围内，而且可放棋
  12. bool IsOK(int x, int y)
  13. {
  14.     if(( x <= N-1 ) && (x >=0 )
  15.         && (y <= N-1 ) && (y >=0 )
  16.         && (matrix[x ][y ]==0 ))
  17.     {
  18.         return true;
  19.     }
  20.     else
  21.     {
  22.         return false;
  23.     }
  24. }
  25.  
  26.  
  27. //打印出所有解
  28. void Display()
  29. {
  30.     printf("第%d种解：\n",++solution);
  31.     for (int i = 0; i < N; i++)
  32.     {
  33.         for (int j = 0; j < N; j++)
  34.         {
  35.             
  36.             printf("%3d",matrix[i][j]);
  37.         }
  38.         printf("\n");
  39.     }
  40.     
  41.     printf("-----------------\n");
  42. }
  43. void DFS(int x, int y)
  44. {
  45.     int nextX, nextY;
  46.  
  47.  
  48.     for (int i = 0; i < 8; i++)
  49.     {
  50.         nextX = x + move[i][0];
  51.         nextY = y + move[i][1];
  52.         //--find
  53.         if (IsOK(nextX, nextY))
  54.         {
  55.             
  56.             if (count != N*N -1 )
  57.             {
  58.                 //--forward
  59.                 count++;
  60.                 matrix[nextX][nextY] = count;
  61.                 
  62.                 DFS(nextX, nextY);
  63.                 matrix[nextX][nextY] = 0;
  64.                 count--;
  65.             }
  66.             else 
  67.             {
  68.                 //--done
  69.                 Display();
  70.             }
  71.         }
  72.     }
  73.     //--back
  74. }
  75.  
  76. int main()
  77. {
  78.     matrix[0][0] = 1;
  79.     count = 1;
  80.     DFS(0, 0);
  81.     return 0;
  82. }

非递归算法：

 
 
  1. #include <stdio.h>
  2. #include <stack>
  3. using namespace std;
  4.  
  5. /*马走日*/
  6.  
  7. const int N = 5; //棋盘行数跟列数
  8. int matrix[N][N] = {0}; //表示棋盘
  9. int solution = 0;//解的个数
  10. int count = 0; //第几步
  11. int move[8][2]={{-1,-2},{-2,-1}, {-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2}};//八个方向
  12.  
  13. //注意find这一步当前层的的结点，结点的坐标不是x与y，而通过Node中的x与y与direction三者计算后得到当前层的结点
  14. struct Node
  15. {
  16.     int x;
  17.     int y;
  18.     int direction;
  19. };
  20.  
  21. //在棋盘范围内，而且可放棋
  22. bool IsOk(Node node)
  23. {
  24.     int x, y;
  25.     x = node.x + move[node.direction][0];
  26.     y = node.y + move[node.direction][1];
  27.     if(( x <= N-1 ) && (x >=0 )
  28.         && (y <= N-1 ) && (y >=0 )
  29.         && (matrix[x][y]==0 ))
  30.     {
  31.         return true;
  32.     }
  33.     else
  34.     {
  35.         return false;
  36.     }
  37. }
  38.  
  39. //打印
  40. void Print()
  41. {
  42.     printf("第%d种解：\n",++solution);
  43.     for (int i = 0; i < N; i++)
  44.     {
  45.         for (int j = 0; j < N; j++)
  46.         {
  47.             
  48.             printf("%3d",matrix[i][j]);
  49.         }
  50.         printf("\n");
  51.     }
  52.     
  53.     printf("-----------------\n");
  54. }
  55.  
  56.  
  57. void DFS()
  58. {
  59.     Node node;
  60.     stack stack;
  61.     int x, y;
  62.     count = 1;
  63.     node.x = 0;
  64.     node.y = 0;
  65.     node.direction = 0;
  66.     matrix[0][0] = count++;
  67.     stack.push(node);
  69.     node.direction = 0;
  70.     stack.push(node);
  71.     
  72.     while(stack.size() >= 2)
  73.     {
  74.         //--find
  75.         node = stack.top();
  76.         while (node.direction < 8 && !IsOk(node))
  77.         {
  78.             node.direction++;
  79.         }
  80.         if (node.direction < 8)
  81.         {
  82.             //--forward
  83.             if (count < N * N)
  84.             {
  85.                 //把ok的节点放到当前层
  86.                 stack.pop();
  87.                 stack.push(node);
  89.                 x = node.x + move[node.direction][0];
  90.                 y = node.y + move[node.direction][1];
  91.                 matrix[x][y] = count++;
  92.                 
  93.                 //进入下一层的第一个节点
  94.                 node.x = x;
  95.                 node.y = y;
  96.                 node.direction = 0;
  97.                 stack.push(node);
  98.             }
  99.             else
  100.             {
  101.                 //--done
  102.                 //打印出结果;
  103.                 x = node.x + move[node.direction][0];
  104.                 y = node.y + move[node.direction][1];
  105.                 matrix[x][y] = count++;
  106.                 Print();
  107.                 //注意先清除当前结点的数据
  108.                 matrix[x][y] = 0;
  109.                 count--;
  110.                 //进入当前层的下一个结点;
  111.                 node.direction++;
  112.                 stack.pop();
  113.                 stack.push(node);
  114.             }
  115.         }
  116.         else
  117.         {
  119.             //----back
  120.             //返回上一层当前结点的下一个节点
  121.             stack.pop();
  122.             if (stack.size() == 1)
  123.             {
  124.                 return;
  125.             }
  126.             node = stack.top();
  127.             //注意先清除当前结点的数据
  128.             x = node.x + move[node.direction][0];
  129.             y = node.y + move[node.direction][1];
  130.             matrix[x][y] = 0;
  131.             count--;
  133.             node.direction++;
  134.             stack.pop();
  135.             stack.push(node);
  136.             
  137.         }
  138.     }
  139. }
  142. int main()
  143. {
  144.     DFS();
  145.     return 0;
  146. }

四、DFS有更多的变种，但都可以通过上面所说的四个步骤云解决。未完，待续。。。。

五、代码：
https://github.com/helloitworks/algorithm/tree/master/dfs

（转载本站文章请注明出处 www.helloitworks.com ，请勿用于任何商业用途）

znlznl_
关注
专栏目录
Python 算法基础篇：深度优先搜索（ DFS ）和广度优先搜索（ BFS ）
小蓝枣的博客
07-19 8279
深度优先搜索（ DFS ）和广度优先搜索（ BFS ）是两种常用的图遍历算法，用于在图中搜索目标节点或遍历图的所有节点。本篇博客将介绍 DFS 和 BFS 算法的基本概念，并通过实例代码演示它们的应用。
深度优先算法DFS入门 (超级简单的例题入门)
刷刷刷，刷Leetcode
10-02 1215
参考文章： 1、Leetcode Subset I & II 作者：算法鱼 （里面是java版本的代码） 一、什么是 DFS？ 图的深度优先搜索（Depth First Search），和树的先序遍历比较类似。 具体做法是：假设初始状态是图中所有顶点均未被访问，则从某个顶点V出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和V有路径相通的顶点都被...
深度优先搜索算法的通用解法
小小石头的那些事儿
09-07 902
一、深度优先搜索深度优先搜索算法(Depth First Search)，是图论中的经典算法。 深度优先搜索算法是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当结点所有子结点那一层都被搜索过，再回溯返回到当前结点的邻结点，继续搜索，直到遍历完整棵树。一般采用的是前序遍历，先根然后再左右结点的方式进行。 一些经典的问题，比如八皇后、马走日、迷宫等，都可以通过深度优先搜索算法来解决。 为了方
【算法入门】深度优先搜索(DFS)
热门推荐
raphealguo
05-12 8万+
深度优先搜索(DFS) 【算法入门】 郭志伟@SYSU：raphealguo(at)qq.com 2012/05/12 1.前言 深度优先搜索（缩写DFS）有点类似广度优先搜索，也是对一个连通图进行遍历的算法。它的思想是从一个顶点V0开始，沿着一条路一直走到底，如果发现不能到达目标解，那就返回到上一个节点，然后从另一条路开始走到底，这种尽量往深处走的概念即是深度优先的概念。 你可以跳过
深度优先算法回溯实例
qq_42535651的博客
06-04 458
将1-9九个数字不重复填入口口口口x口=口口口口中使等式成立，写出所有的情况 #include <stdio.h> int num[10]={0}; //记录每个位置上的数字 int status[10]={0}; //记录1-9的状态，用过记为1 void dfs(int dep) { if(dep == 10) //当到第9步的时候检测值是否满足，判断...
深度优先算法
小猪快跑
01-15 2091
深度优先搜索算法（Depth-First-Search）是搜索算法的一种。是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所有边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。属于盲目搜索。 深度优先搜索是图论中的经典
Dijkstra+DFS模板总结
Bing's Blog
03-02 1310
关于Dijstra的初级运用是，在第一标尺的基础上有下面三个角度： 边权：c[maxn] = {maxn}, cost[manx][maxn] = {inf}; 点权：w[maxn] = {0}, weight[maxn] = {0}; 最短路径条数：num[maxn] = {0}; a1003.cpp 用到了其中的两个，作为模板来刻意练习，练习如何将问题结构化，模板化。再额外补充边权的代码，不是这
DFS BFS算法总结
uestchuan的博客
06-24 223
leetcode
DFS BFS 图.zip_DFS BFS_bfs_bfs dfs_dfs_dfs bfs输出图
09-20
总结来说，DFS和BFS是图论中至关重要的搜索策略，它们各有优势，适用于不同的问题场景。通过理解这两种算法的工作原理和实现方式，我们可以有效地解决与图相关的复杂问题。结合这些文件，读者可以深入学习图的遍历...
算法基础系列第三章——一文详解DFS(全排列演示带入)
weixin_52621323的博客
12-01 2530
对全排列问题的详解，以及对深度优先遍历的生动模拟
深度优先搜索算法
04-09
深度优先C代码
深度优先搜索算法—DFS
04-23
该代码是DFS算法的实现，讲解部分可以查看我的博客
深度优先搜索算法（DFS）
weixin_41636030的博客
10-24 1832
BFS java：用hashmap/hashset来去重 python:dict/set来去重 分治法 divide & conquer 将大规模问题拆分为若干个小规模同类型问题去处理 再把子问题分为更小的问题，直到最后子问题可以简单求解 最后将子问题的解合并就是原问题的解 通常用递归方法来解决 搜索 宽度优先搜索 深度优先搜索(DFS) = 回溯 遍历法：可用递归或迭代（非递归） 分治法：可用递归或迭代（非递归） 注：递归和非递归是算法的一种实现方式而不是算法 递归三要素： 1.
深度优先搜索基本模型和例题详细分析
qq_63137068的博客
04-10 527
hello,小伙伴们,大家好，今天和大家介绍的是基础的深度优先搜索 先从一个例子入手：对三张牌的排序：一共有多少种排法 我们假设有三个盒子手上呢有三张牌，每个盒子仅能放一张牌，（我们设立一个放的规定：每到盒子前先放1，再放2，最后放3）我们先走到一号盒子前，将牌1放进去，就这样下去到三号盒子，我们手中此时 ...
DFS基础(1)
yr的专栏
02-28 258
Oil Deposits 题目大意 深度优先搜索的经典题，也是最基础的一道题。油田问题，八个方向深度搜索，计算油田区域数量？ 解题思路 遍历矩阵每个点，对其进行DFS并标记节点。记录DFS次数。 More info: 杭电1241 #include #include #include using namespace std; #define M 1
图论基础与应用总结
"amber的图论总结pdf版涵盖了图论的基本概念、术语、表示方法、遍历、拓扑排序、路径与回路、以及网络优化等核心内容，适合学习图论和组合优化的读者参考。" 图论是计算机科学、数学和网络分析中的重要分支，主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值