深度优先搜索算法的通用解法
一、深度优先搜索
深度优先搜索算法(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组解,下面给出其中一种解的图例:
2、 问题分析
规则是每一个皇后与前面的所有皇后不能在同一行、同一列、同一对角线。我们可以从第0行,第0列开始摆放,然后按照深度优先的原则,按照规则往更下面的行摆放皇后,直到摆放完8行。因为解不只一个,当某一行(包括最后一行跟最后一行之前的所有行)的所有列都被尝试过,再回溯返回到上一行,继续深度优先,直到遍历完整个棋盘的所有情况。得出所有的解。 八皇后问题可以看成是在深度为8的8叉树中,找出所有的解。
3、代码实现
递归算法:
#include <stdio.h> #include <math.h> /*八皇后问题是在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 <stdio.h>
#include <math.h>
#include <stack>
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、问题描述
在n*n的棋盘中,马只能走"日"字。马从位置(0,0)出发,把棋盘的每一格都走一次且只走一次。找出所有路径。 5*5的棋盘上,有304种解。
下面是其中一种路径的图例:
2、问题分析
搜索过程是从(0,0)出发,按照深度优先的原则,从8个方向中尝试一个可以走的点,直到尝试过所有的方向,走完棋盘上的所有点,得出所有的解。
马走日问题可以看成是在层数为n*n的8叉树中,找出所有的解。
3、代码实现
同样的,也可以把上面的算法框架,套用于马走日的身上。
递归算法:
#include <stdio.h> /*马走日*/ 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 <stdio.h>
#include <stack>
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有更多的变种,但都可以通过上面所说的四个步骤云解决。未完,待续。。。。