DFS----深度优先搜索与记忆化数组例题分析

DFS与BFS的简单理解

DFS

DFS(即深度优先搜索)是一种利用递归和循环结构将所有可能的路径和方法都搜索一遍的方式，其本质上与暴力解法类似，不过是利用了递归结构省去了大量代码。
主要思想是运用了回溯，保存这次的位置并深入搜索，都搜索完便回溯回来，搜下一个位置，直到把所有最深位置都搜一遍（找到目的解返回或者全部遍历完返回一个事先定好的值）。要注意的一点是，搜索的时候有记录走过的位置，标记完后可能要改回来。

例题1：滑雪问题

Michael喜欢滑雪这并不奇怪， 因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道在一个区域中最长底滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。

下面是一个例子：

 1 2 3 4 5 
16 17 18 19 6 
15 24 25 20 7 
14 23 22 21 8 
13 12 11 10 9 

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-…-3-2-1更长。事实上，这是最长的一条。 Input 输入的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。 Output 输出最长区域的长度。

Sample Input 5 5 
1 2 3 4 5 
16 17 18 19 6 
15 24 25 20 7 
14 23 22 21 8 
13 12 11 10 9 
Sample Output 25

题解：

首先由于路径的可能性实在太多，使用暴力for循环无法写出，于是我们可以考虑dfs解决。

即我们可以构造一个dfs函数，然后将输入的每一个数都输入到dfs函数中求其路径的可能性，最后求最大值即可。

dfs函数怎么构成呢？
我们通常使用递归实现。
我们可以只传入目标值的两个下标，然后对其进行四个方向的搜索。如果满足其中一个方向没有越界且符合题意时，我们就按照此种可能性继续搜索下去，即秉着“深度优先搜索”的思想，将这一条路走到不能走为止。因此这里使用递归进行搞定。

若此方向不满足搜索下去的条件那么我们就换个方向看一看，如果四个方向都不可以，那么我们认为这一个点不符合题意，因此不对其进行任何操作，直接查看下一个点即可。
需要注意的是每个点自己就算一个点了，因此长度至少为1。并且多次递归我们要的只是次数最大的那一个。
还需要注意的是由于a数组一直在多个函数都用到了，所以不妨直接定义全局化。
另外另外这题为了节省时间而使用了一个非常重要的东西——————记忆化数组！！！
因为在进行dfs时由于我们秉承着“深度优先”的思想，因此必定会有重复搜索的现象。所以我们不妨定义一个hash数组当做我们的记忆化数组，保存我们每次搜索后得到的结果，这样的话可以大大的省去了我们的时间。
如:我们在遍历24时，查找到了其一个方向17，而17这个在我们前面的搜索中其实已经搜索过了，所以我们不用搜索了，直接使用前面搜索的结果即可。
所以这里也同时蕴含动态规划和回溯的思想。

代码：

#include<bits/stdc++.h>
using namespace std;

int a[101][101];
int hash[101][101];//记忆化数组
int m,n;
int dir[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};//定义方向数组以免需要过多的if来模拟四种方向 

bool inspect(int x0,int y0)//判断是否可行
{
	if(x0<0||x0>=m||y0<0||y0>=n)
	{
		return 0;
	}
	return 1;
}

int dfs(int x,int y)
{
	if(hash[x][y])//一旦满足记忆化数组保存过的地方 
		return hash[x][y];//直接取它
	int res = 1;//保存每次的长度，最少为1
	for(int k=0;k<4;k++)//遍历四种方向
	{
		int tx = x+dir[k][0];//这样通过一个步骤即可完成四个if的情况
		int ty = y+dir[k][1];
		if(inspect(tx,ty)&&a[tx][ty]<a[x][y])
		{
			res = max(res,dfs(tx,ty)+1);
		}
	}
	hash[x][y] = res;
	return res;
}

int main()
{
	cin>>m>>n;
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<n;j++)
		{
			cin>>a[i][j];
		}
	}
	
	int sum = 1;//次数最少为1
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<n;j++)
		{
			sum = max(sum,dfs(i,j));
		}
	}
	
	cout<<sum<<endl;
	return 0; 
} 

例题2：八皇后问题

八皇后问题是一个以国际象棋为背景的问题：如何能够在 8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？为了达到此目的，任两个皇后都不能处于同一条横行、纵行或斜线上。八皇后问题可以推广为更一般的n皇后摆放问题：这时棋盘的大小变为n×n，而皇后个数也变成n。当且仅当 n = 1 或 n ≥ 4 时问题有解。
Input
无输入。
Output
按给定顺序和格式输出所有八皇后问题的解（见Sample Output）。
Sample Input

Sample Output

No. 1
1 0 0 0 0 0 0 0 
0 0 0 0 0 0 1 0 
0 0 0 0 1 0 0 0 
0 0 0 0 0 0 0 1 
0 1 0 0 0 0 0 0 
0 0 0 1 0 0 0 0 
0 0 0 0 0 1 0 0 
0 0 1 0 0 0 0 0 
No. 2
1 0 0 0 0 0 0 0 
0 0 0 0 0 0 1 0 
0 0 0 1 0 0 0 0 
0 0 0 0 0 1 0 0 
0 0 0 0 0 0 0 1 
0 1 0 0 0 0 0 0 
0 0 0 0 1 0 0 0 
0 0 1 0 0 0 0 0 
No. 3
1 0 0 0 0 0 0 0 
0 0 0 0 0 1 0 0 
0 0 0 0 0 0 0 1 
0 0 1 0 0 0 0 0 
0 0 0 0 0 0 1 0 
0 0 0 1 0 0 0 0 
0 1 0 0 0 0 0 0 
0 0 0 0 1 0 0 0 
No. 4
1 0 0 0 0 0 0 0 
0 0 0 0 1 0 0 0 
0 0 0 0 0 0 0 1 
0 0 0 0 0 1 0 0 
0 0 1 0 0 0 0 0 
0 0 0 0 0 0 1 0 
0 1 0 0 0 0 0 0 
0 0 0 1 0 0 0 0 
No. 5
0 0 0 0 0 1 0 0 
1 0 0 0 0 0 0 0 
0 0 0 0 1 0 0 0 
0 1 0 0 0 0 0 0 
0 0 0 0 0 0 0 1 
0 0 1 0 0 0 0 0 
0 0 0 0 0 0 1 0 
0 0 0 1 0 0 0 0 
No. 6
0 0 0 1 0 0 0 0 
1 0 0 0 0 0 0 0 
0 0 0 0 1 0 0 0 
0 0 0 0 0 0 0 1 
0 1 0 0 0 0 0 0 
0 0 0 0 0 0 1 0 
0 0 1 0 0 0 0 0 
0 0 0 0 0 1 0 0 
No. 7
0 0 0 0 1 0 0 0 
1 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 1 
0 0 0 1 0 0 0 0 
0 1 0 0 0 0 0 0 
0 0 0 0 0 0 1 0 
0 0 1 0 0 0 0 0 
0 0 0 0 0 1 0 0 
No. 8
0 0 1 0 0 0 0 0 
1 0 0 0 0 0 0 0 
0 0 0 0 0 0 1 0 
0 0 0 0 1 0 0 0 
0 0 0 0 0 0 0 1 
0 1 0 0 0 0 0 0 
0 0 0 1 0 0 0 0 
0 0 0 0 0 1 0 0 
No. 9
0 0 0 0 1 0 0 0 
1 0 0 0 0 0 0 0 
0 0 0 1 0 0 0 0 
0 0 0 0 0 1 0 0 
0 0 0 0 0 0 0 1 
0 1 0 0 0 0 0 0 
0 0 0 0 0 0 1 0 
0 0 1 0 0 0 0 0 
...以下省略

题解：

此题同样为许多种组合方式，过于繁杂，因此我们也可以使用dfs简化思考过程。
即将一个庞大的问题化为若干个小问题，接着对小问题进行求解即可。
我们可以将行列分离来看，同样创建dfs函数，将第一行先传入dfs中，然后给其找上一列，然后对其分析，看其是否能满足放置皇后的条件，若能则放上皇后，并秉承“深度优先”的思想，继续此深度的搜索，即给其行数加1代入dfs中直到这种方法搜索完毕，即此方法对八行都进行判断完全，因此我们可以打印出这种方法，接着对原数组进行“回溯”操作，再进行下一轮判断即可。
而回溯的关键即在于记忆化数组的构建。

需要注意的是对于繁杂的程序我们尽量将程序碎片化，即将程序分解为多个模块，这样有助于我们分析哪步操作该办哪步的事情。
如此代码中的reflect函数和check函数，其实也可以不单独定义，但那样会显得代码过于繁杂，可读性低，分解为小函数后更能增加可读性，只要注意函数名的选择即可。

代码：

#include<bits/stdc++.h>
using namespace std;

int hash[8][8] = {0};//既是棋盘同时也承担着“回溯”的操作，即也是记忆化数组
//先变成0表示棋盘初始化
int queen_col[8];//其表示第n行时皇后所在的列数
int sum = 1;//表示方法数量，用于打印

bool check(int row)//将行数传进来
{
	for(int i=0;i<row;i++)//i<row,所以其必定不会和我们要判断的皇后位置同行
	//这也是我们分解行列的原因，省去判断行的情况了
	{
		if(queen_col[row]==queen_col[i]||abs(queen_col[row]-queen_col[i])==row-i)
		//满足斜线的条件是列下标相减与行下标相减绝对值大小相同
		{
			return 0;	
		} 
	}//因为检查的是前面的那些行，该行不包括在内，所以只检查列就相当于检查了行与列 
	return 1;
}

void reflect()
{	
	for(int i=0;i<8;i++)
	{
		hash[i][queen_col[i]] = 1;//queen_col[i]就是我们经过判断的结果，其表示列，因此遍历行
	}
	cout<<"方法"<<sum++<<endl;
	
	for(int i=0;i<8;i++)
	{
		for(int j=0;j<8;j++)
		{
			cout<<hash[i][j]<<" ";	
		}	
		cout<<endl;
	}	
}

void dfs(int row)//其会遍历许多次，因为有许多不同的摆法，每种摆法都要遍历八行才可打印
{
	if(row==8)//表示一种方法遍历完毕
	{
		reflect();
	}
	for(int i=0;i<8;i++)
	{
		queen_col[row] = i;//将列代入
		if(check(row)!=0)
		{
			hash[row][i] = 1;//满足即放上，与后面打印中的赋值操作有关系的
			dfs(row+1);
			hash[row][i] = 0;//“回溯”操作
//因为在前面的dfs递归完成后即代表八行已经遍历过了，即一种方法已经确定了，因此我们可以“回溯”了
		}	
	}
}

int main()
{
	dfs(0);//将第一行代入
	return 0; 
}