DFS(深度优先搜索)的总结（含有例题）

DFS的思想以及模板

思想

深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次.
在搜索的过程中，朝着一个方向进行搜索，也是就是我们说的不撞南墙不回头。不达到限制条件的边界，本次搜索是不会停止的。到达本次搜索的边界后，再折返进行下一次搜索。

模版

DFS大多有固定几个组成的部分：
1.cheak部分，判断搜索是否到达了边界（通过判断下一个要搜索的的点是否合法）

2.vis或者room数组（名字不重要！）标记已经走过的节点，同时在某些需要回溯的情况下也可以标记回溯的节点。

3.方向数组，有的时候并不是单纯的上下左右移动的方向数组，可能是帮助一个状态向另一个状态转移的数组或者式子，请务必看清到底是几个方向，有的是4个有的是8个。

4.DFS函数，包含了以上几个部分，与其说是一个函数不如说是包含了上面几种操作的一段代码，最后通过递归来达到深搜的目的。

DFS模版

#include<bits/stdc++.h>
using namespace std;
const int maxn=100;
bool room[maxn][maxn]; //标记数组
int map[maxn][maxn]; // 坐标范围
int dir[4][2]={0,1,0,-1,1,0,-1,0}; // 四个方向
 
bool cheak(int x,int y) // 判断是否合法，满足条件
{
	if(!room[x][y] && ...) // 满足条件
		return 1;
	else // 不符合条件
		return 0;
}
 
void dfs(int x,int y)
{
	room[x][y]=1; // 标记该节点,已经被访问过
	if(map[x][y]==G) // 出现目标态G
		{
		...... // 作对应的处理
		return;
		}
	for(int i=0;i<4;i++)
	{
		if(cheak(x+dir[i][0],y+dir[i][1])) // 通过方向数组进行下一个节点的搜索
			dfs(x+dir[i][0],y+dir[i][1]);
	}
	return; // 没有进一步的节点了
}
int main()
{
......
return 0;
}

例题1

（1） 先来一道没有花里胡哨的模版题（转自https://blog.csdn.net/weixin_30670965/article/details/95571677）
来自hdu1283

题目：毕业后，Vegetable在一家建筑公司找到了工作。他所在的城市将要进行整修，要求把所有空地修成公园。
市区是一个N*M的矩形，Vegetable拿到了该市的地图，现在判断共要修几处公园？
注意：在一片空地上，它上下左右的位置是空地，则视为统一片空地。
输入
共有T组测试数据，每组测试数据包含一组N和M(0<n,m<=100)，分别表示市区的长和宽。
接下来N行每行有M个数（1代表楼房，0代表空地）。
输出
输出要修建的公园个数。

分析：没啥好说的，就是按照上面的步骤一步一步的走，不过要注意的是由于我懒，题解是复制粘贴的，方向数组被他省略了（他也懒）。

#include<bits/stdc++.h>
using namespace std;
const int maxn=110 ;
int a[maxn][maxn];
int n,m;
int ans;
void dfs(int sx,int sy)
{
    
    if(sx<0||sx>=n||sy<0||sy>=m)//超出边界则返回 
        return ;    
    if(a[sx][sy]==1)//当前位置被遍历过或者遇到了楼房则返回 
        return;    
    a[sx][sy]=1;//当前位置标记为已遍历 
    
    dfs(sx+1,sy);
    dfs(sx-1,sy);
    dfs(sx,sy+1);
    dfs(sx,sy-1);
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        
        cin>>n>>m;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                cin>>a[i][j];
            }
        }
        ans=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(a[i][j]==0)
                {
                    ans++;
                    dfs(i,j);
                }
            }
        }
        cout<<ans<<endl;
    }
    
    return 0;    
} 

———————————————————————————————————————

例题2

在普通的DFS板子题目之外，还存在将问题抽象化的DFS，即不能看做图的DFS。方向数组也并非再是直观的向某些位置移动，而是真正的向其他状态变化。

题目：猪猪Hanke特别喜欢吃烤鸡（本是同畜牲，相煎何太急！）Hanke吃鸡很特别，为什么特别呢？因为他有10种配料（芥末、孜然等），每种配料可以放1—3克，任意烤鸡的美味程度为所有配料质量之和

现在，Hanke想要知道，如果给你一个美味程度，请输出这10种配料的所有搭配方案

输入格式
一行,n<=5000

输出格式
第一行，方案总数

第二行至结束，10个数，表示每种配料所放的质量

按字典序排列。

如果没有符合要求的方法，就只要在第一行输出一个“0”

输入样例：

11

输出样例：

10
1 1 1 1 1 1 1 1 1 2 
1 1 1 1 1 1 1 1 2 1 
1 1 1 1 1 1 1 2 1 1 
1 1 1 1 1 1 2 1 1 1 
1 1 1 1 1 2 1 1 1 1 
1 1 1 1 2 1 1 1 1 1 
1 1 1 2 1 1 1 1 1 1 
1 1 2 1 1 1 1 1 1 1 
1 2 1 1 1 1 1 1 1 1 
2 1 1 1 1 1 1 1 1 1

分析：方向的转移是对不同调料的选择,每种调料有3种不同的状态。边界条件是调料种数之和到达10，调料质量到达输入值则将暂时储存情况的temp数组移到待会输出的数组里。

答案：

#include<iostream>
using namespace std;
int n, cnt, a[10000][10], temp[10];
void dfs(int step, int sum) {     //step为第几种调料，sum目前的调料质量之和
	int i;
	if (step == 10) {    //当10种调料都分析完了
		if (sum == n) {      //如果质量之和等于输入值
			for (i = 0; i < 10; i++)
				a[cnt][i] = temp[i];       //把temp数组的元素都转移到二维数组a里面
			cnt++;           //cnt为满足的情况数
		}
		return;
	}
	for (i = 1; i < 4; i++) {        //每种调料的质量有三种情况，分别为1，2，3，都要尝试
		temp[step] = i;           //第step种调料的质量为i
		dfs(step + 1, sum + i);         //递归，对下一种调料做同样的分析
	}
}
 
 
int main() {
	int i, j;
	cin >> n;
	dfs(0, 0);
	if (!cnt)      
		cout << "0";
	else {                  
		cout << cnt << endl;          
		for (i = 0; i < cnt; i++) {             
			for (j = 0; j < 10; j++) 
				cout << a[i][j] << " ";
			cout << endl;               
		}
	}
	return 0;
}