深度优先搜索算法的通用解法

原文链接:http://helloitworks.com/678.html?utm_source=tuicool&utm_medium=referral
一、深度优先搜索
深度优先搜索算法(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的节点放到当前层；进入下一层第一个结点。跳到find3、done(right):若在当前层找到ok的结点，并且当前层是最后一层：打印出结果；进入当前层的下一个结点。跳到find4、back(up):在当前层没有找到ok的节点：返回上一层当前结点的下一个兄弟节点。跳到find
其实最重要的是find。然后后面的forward、done、back只是用来控制搜索走向。这四步可以进一步总结成两步。为了了解算法，我想最好的切入方式是从一些实例开始。下面分别从八皇后以及马走日等问题做为切入点来分析DFS
三、用DFS解八皇后
1、问题描述八皇后问题是一个以国际象棋为背景的问题：如何能够在8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？也就是说，使得棋盘中每个横向、纵向、左上至右下斜向、右上至左下斜向均只有一枚皇后。八皇后有92组解，下面给出其中一种解的图例：

Image

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

#include 
#include 
 
/*八皇后问题是在8*8的棋盘上放置8枚皇后，使得棋盘中每个横向、纵向、左上至右下斜向、右上至左下斜向均只有一枚皇后。
求解出所有摆法,一共有92种摆法*/
 
const int N = 8; //棋盘行数
int a[N] = {0}; //表示棋盘，若a[2]=2,则表示在第3行第2列放一个皇后，因为同一行不能放两个皇后，所以只需要1维数组就可以表示一个棋盘。
 
int solution = 0;//解的个数
 
//row行，col列, 是否可以摆皇后
bool IsOK(int row, int col)
{
 for (int i = 0; i < row; i++)
 {
 if (a[i] == col || (abs(a[i] - col) == row - i))
 {
 return false;
 }
 }
 return true;
}
 
void Display()
{
 printf("第%d种解：\n",++solution);
 for (int i = 0; i < N; i++)
 {
 for (int j = 0; j < N; j++)
 {
 if (a[i] == j)
 {
 printf("%d", i);
 }
 else
 {
 printf("#");
 }
 }
 printf("\n");
 }
 
 printf("-----------------\n");
}
 
void DSF(int row)
{
 for (int col = 0; col < N; col++)
 {
 //find
 if (IsOK(row, col))
 {
 a[row] = col;
 //forward
 if (row != N -1)
 {
 DSF(row + 1);
 }
 else
 {
 //done
 Display();
 }
 
 }
 }
 //back
}
 
int main()
{
 DSF(0);
 return 0;
}

非递归算法：

#include 
#include 
#include 
using namespace std;
/*八皇后问题是在8*8的棋盘上放置8枚皇后，使得棋盘中每个横向、纵向、左上至右下斜向、右上至左下斜向均只有一枚皇后*/
 
const int N = 8; //棋盘行数
int a[N] = {0}; //表示棋盘，若a[2]=2,则表示在第3行第2列放一个皇后，因为同一行不能放两个皇后，所以只需要1维数组就可以表示一个棋盘。
 
int solution = 0;//解的个数
 
struct Node
{
 int row;
 int col;
};
 
//row行，col列, 是否可以摆皇后
bool IsOK(Node node)
{
 for (int i = 0; i < node.row; i++)
 {
 if (a[i] == node.col || (abs(a[i] - node.col) == node.row - i))
 {
 return false;
 }
 }
 return true;
}
 
//打印出所有解
void Print()
{
 printf("第%d种解：\n", ++solution);
 for (int i = 0; i < N; i++)
 {
 for (int j = 0; j < N; j++)
 {
 if (a[i] == j)
 {
 printf("%d", i);
 }
 else
 {
 printf("#");
 }
 }
 printf("\n");
 }
 
 printf("-----------------\n");
}
 
void DSF()
{
 Node node;
 stack stack;

 node.row = 0;

 node.col = 0;

 stack.push(node);

 while(stack.size() >= 1)

 {

 //--find

 node = stack.top();

 while (node.col < N && !IsOK(node))

 {

 node.col++;

 }

 if (node.col < N)

 {

 //--forward

 if (node.row < N-1)

 {

 //把ok的节点放到当前层

 a[node.row] = node.col;

 stack.pop();

 stack.push(node);

 

 //进入下一层的第一个节点

 node.row++;

 node.col = 0;

 stack.push(node);

 }

 else

 {

 //--done

 a[node.row] = node.col;

 Print();

 

 //进入当前层的下一个结点

 //node = stack.top();

 node.col++;

 stack.pop();

 stack.push(node);

 }

 }

 else

 {

 //--back

 stack.pop();

 

 if (stack.size() == 0)

 {

 return;

 }

 node = stack.top();

 node.col++;

 stack.pop();

 stack.push(node);

 }

 }

}

int main()

{

 DSF();

 return 0;

}

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

Image

2、问题分析搜索过程是从(0,0)出发，按照深度优先的原则，从8个方向中尝试一个可以走的点，直到尝试过所有的方向，走完棋盘上的所有点，得出所有的解。马走日问题可以看成是在层数为n*n的8叉树中，找出所有的解。
3、代码实现同样的，也可以把上面的算法框架，套用于马走日的身上。递归算法：

#include 
 
/*马走日*/
 
const int N = 5; //棋盘行数跟列数
int matrix[N][N] = {0}; //表示棋盘
int solution = 0;//解的个数
int count = 0; //第几步
int move[8][2]={{-1,-2},{-2,-1}, {-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2}};//八个方向
 
//在棋盘范围内，而且可放棋
bool IsOK(int x, int y)
{
 if(( x <= N-1 ) && (x >=0 )
 && (y <= N-1 ) && (y >=0 )
 && (matrix[x ][y ]==0 ))
 {
 return true;
 }
 else
 {
 return false;
 }
}
 
 
//打印出所有解
void Display()
{
 printf("第%d种解：\n",++solution);
 for (int i = 0; i < N; i++)
 {
 for (int j = 0; j < N; j++)
 {
 
 printf("%3d",matrix[i][j]);
 }
 printf("\n");
 }
 
 printf("-----------------\n");
}
void DFS(int x, int y)
{
 int nextX, nextY;
 
 
 for (int i = 0; i < 8; i++)
 {
 nextX = x + move[i][0];
 nextY = y + move[i][1];
 //--find
 if (IsOK(nextX, nextY))
 {
 
 if (count != N*N -1 )
 {
 //--forward
 count++;
 matrix[nextX][nextY] = count;
 
 DFS(nextX, nextY);
 matrix[nextX][nextY] = 0;
 count--;
 }
 else 
 {
 //--done
 Display();
 }
 }
 }
 //--back
}
 
int main()
{
 matrix[0][0] = 1;
 count = 1;
 DFS(0, 0);
 return 0;
}

非递归算法：
#include 
#include 
using namespace std;
 
/*马走日*/
 
const int N = 5; //棋盘行数跟列数
int matrix[N][N] = {0}; //表示棋盘
int solution = 0;//解的个数
int count = 0; //第几步
int move[8][2]={{-1,-2},{-2,-1}, {-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2}};//八个方向
 
//注意find这一步当前层的的结点，结点的坐标不是x与y，而通过Node中的x与y与direction三者计算后得到当前层的结点
struct Node
{
 int x;
 int y;
 int direction;
};
 
//在棋盘范围内，而且可放棋
bool IsOk(Node node)
{
 int x, y;
 x = node.x + move[node.direction][0];
 y = node.y + move[node.direction][1];
 if(( x <= N-1 ) && (x >=0 )
 && (y <= N-1 ) && (y >=0 )
 && (matrix[x][y]==0 ))
 {
 return true;
 }
 else
 {
 return false;
 }
}
 
//打印
void Print()
{
 printf("第%d种解：\n",++solution);
 for (int i = 0; i < N; i++)
 {
 for (int j = 0; j < N; j++)
 {
 
 printf("%3d",matrix[i][j]);
 }
 printf("\n");
 }
 
 printf("-----------------\n");
}
 
 
void DFS()
{
 Node node;
 stack stack;

 int x, y;

 count = 1;

 node.x = 0;

 node.y = 0;

 node.direction = 0;

 matrix[0][0] = count++;

 stack.push(node);

 node.direction = 0;

 stack.push(node);

 

 while(stack.size() >= 2)

 {

 //--find

 node = stack.top();

 while (node.direction < 8 && !IsOk(node))

 {

 node.direction++;

 }

 if (node.direction < 8)

 {

 //--forward

 if (count < N * N)

 {

 //把ok的节点放到当前层

 stack.pop();

 stack.push(node);

 x = node.x + move[node.direction][0];

 y = node.y + move[node.direction][1];

 matrix[x][y] = count++;

 

 //进入下一层的第一个节点

 node.x = x;

 node.y = y;

 node.direction = 0;

 stack.push(node);

 }

 else

 {

 //--done

 //打印出结果;

 x = node.x + move[node.direction][0];

 y = node.y + move[node.direction][1];

 matrix[x][y] = count++;

 Print();

 //注意先清除当前结点的数据

 matrix[x][y] = 0;

 count--;

 //进入当前层的下一个结点;

 node.direction++;

 stack.pop();

 stack.push(node);

 }

 }

 else

 {

 //----back

 //返回上一层当前结点的下一个节点

 stack.pop();

 if (stack.size() == 1)

 {

 return;

 }

 node = stack.top();

 //注意先清除当前结点的数据

 x = node.x + move[node.direction][0];

 y = node.y + move[node.direction][1];

 matrix[x][y] = 0;

 count--;

 node.direction++;

 stack.pop();

 stack.push(node);

 

 }

 }

}

int main()

{

 DFS();

 return 0;

}

四、DFS有更多的变种，但都可以通过上面所说的四个步骤云解决。未完，待续。。。。
五、代码：https://github.com/helloitworks/algorithm/tree/master/dfs