原文鏈接: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組解，下面給出其中一種解的圖例：
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、問題描述在nn的棋盤中，馬只能走"日"字。馬從位置(0,0)出發，把棋盤的每一格都走一次且只走一次。找出所有路徑。 55的棋盤上，有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有更多的變種，但都可以通過上面所說的四個步驟云解決。未完，待續。。。。
五、代碼：https://github.com/helloitworks/algorithm/tree/master/dfs
