dfs深搜总结

关于DFS搜索

包括深度优先搜索和广度优先搜索，从起点开始，逐渐扩大寻找范围，知道找到需要得答案为止

为什么搜索和暴力枚举有关：因为枚举是将所有可能的情况都枚举一遍以获得最优解，但是枚举全部元素得效率太低，无法应付数据范围稍大的情况

严格来说，搜索算法也算是一种暴力枚举策略，但是其算法特性决定了效率比直接的枚举所有答案要高，因为搜索可以跳过一些无效状态，降低问题规模。在算法竞赛中，如果选手无法找到一种高效求解的方法（比如贪心、递推、动态规划、公式推导等），使用搜索也可以解决一些规模较小的情况；而有的任务就是必须使用搜索来完成

理解深搜的过程：

深搜的解题思路就好像走那个迷宫，一开始找到一个可以走的方向，不停的往这个方向走，路上看到了其它路口，记住，如果一个方向走不通，还可以回来走这个方向。当那个方向被围住或者走不通时，就往回走，直到碰到最近的之前遇到过的路口，然后一样的往这个方向走，重复上面的步骤。深搜具体实现时和它的区别就是当一个方向走到头时你不用往回走，因为你走过的地方都被标记过，不能走了，系统**(递归回溯)**会帮你自动跳回到你之前遇到过的最近的路口。

深搜本质思想：先随意选择某种情况执行，在过程中，一旦发现方案不可用，就马上退回一步重新选择另一种情况，如此重复进行，直到找到解

两种基本框架：

第一种：

int fx(int k){
	for(int i=1;i<=算符总数;i++){
		if(满足条件){ 
			保存结果;
			if(到目的地){
				输出解; 
			}
			else fx(k+1);
		}
		恢复:保存结果之前的状态; 
}

第二种：

int fx(int k){
	if(到目的地){
		输出解; 
	}
	else{
		for(int i=1;i<=算符总数;i++){	
			if(满足条件){ 
				保存结果;
				fx(k+1);
				恢复:保存结果之前的状态(回溯一步); 
			}
		}	
	}
}

经典迷宫问题

求最小路径

#include <iostream>
using namespace std;

int p,q,m,n;
int a[100][100];//用二维数组表示地图,1表示空地，2表示障碍物
int v[100][100];//1表示访问，0表示未访问
int minn=0x3fffffff;

void dfs(int x,int y,int step)//step步数
{
	if(x==p&&y==q){//终点坐标
		if(step<minn){//step最终步数
			minn=step;
		}
		return;//回溯,寻找是否还有最小的步数
	}
	//如果当前的点不是终点，则顺时针：右下左上，试探
	//右
	if(a[x][y+1]==1 && v[x][y+1]==0){//可以往右试探
		v[x][y+1]=1;//表示已访问,从这个点开始搜索
		dfs(x,y+1,step+1);//因为往右走了一步，步数+1,搜索完这个点后回溯
		v[x][y+1]=0;//回溯时，将其设置为未访问
	}
	//下
	if(a[x+1][y]==1 && v[x+1][y]==0){
		v[x+1][y]=1;
		dfs(x+1,y,step+1);
		v[x+1][y]=0;
	}
	//左
	if(a[x][y-1]==1 && v[x][y-1]==0){
		v[x][y-1]=1;
		dfs(x,y-1,step+1);
		v[x][y-1]=0;
	}
	//上
	if(a[x-1][y]==1 && v[x-1][y]==0){
		v[x-1][y]=1;
		dfs(x-1,y,step+1);
		v[x-1][y]=0;
	}
	return ;	
}
int main()
{
	int startx,starty;
	cin>>m>>n;
	for(int i=1;i<=m;i++){//初始化地图
		for(int j=1;j<=n;j++){
			cin>>a[i][j];
		}
	}
	cin>>startx>>starty>>p>>q;//起点和终点坐标
	v[startx][starty]=1;//从起点开始深搜，设置为已经访问
	dfs(startx,starty,0);//从起点开始深搜
	cout<<minn;
	return 0;
}
/*样例
5 4
1 1 2 1
1 1 1 1
1 1 2 1
1 2 1 1
1 1 1 2
1 1 4 3
*/

优化

#include <iostream>
using namespace std;
//找出最小步数
int p,q,m,n;
int a[100][100];//用二维数组表示地图,1表示空地，2表示障碍物
int v[100][100];//1表示访问，0表示未访问
int minn=0x3fffffff;
int dx[4]={0,1,0,-1};//方向数组
int dy[4]={1,0,-1,0};
void dfs(int x,int y,int step)//step步数
{
	if(x==p&&y==q){//终点坐标
		if(step<minn){//step最终步数
			minn=step;
		}
		return;//回溯,寻找是否还有最小的步数
	}
	//如果当前的点不是终点，则顺时针：右下左上，试探
	for(int k=0;k<4;k++){//试探四个方向，利用循环
		int tx,ty;//表示下一个方向
		tx=x+dx[k];
		ty=y+dy[k];//表示下一个试探的位置，从当前的x y进行相加
		if(a[tx][ty]==1 && v[tx][ty]==0){//这个位置是空地并且没有被访问
			v[tx][ty]=1;//符合if语句就设置成已经访问
			dfs(tx,ty,step+1);//从这个点开始深搜
			v[tx][ty]=0;//深搜结束，回溯时设置成未访问
		}
	}
	return ;	
}

int main()
{
	int startx,starty;
	cin>>m>>n;
	for(int i=1;i<=m;i++){//初始化地图
		for(int j=1;j<=n;j++){
			cin>>a[i][j];
		}
	}
	cin>>startx>>starty>>p>>q;//输入起点和终点坐标
    //先标记再深搜
	v[startx][starty]=1;//从起点开始深搜，设置为已经访问
	dfs(startx,starty,0);//从起点开始深搜
	cout<<minn;
	return 0;
}

迷宫

题目描述

给定一个 $N\times M$ 方格的迷宫，迷宫里有 $T$ 处障碍，障碍处不可通过。

在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。

给定起点坐标和终点坐标，每个方格最多经过一次，问有多少种从起点坐标到终点坐标的方案。

输入格式

第一行为三个正整数 $N,M,T$，分别表示迷宫的长宽和障碍总数。

第二行为四个正整数 $SX,SY,FX,FY$，$SX,SY$ 代表起点坐标，$FX,FY$ 代表终点坐标。

接下来 $T$ 行，每行两个正整数，表示障碍点的坐标。

输出格式

输出从起点坐标到终点坐标的方案总数。

样例 #1

样例输入 #1

2 2 1
1 1 2 2
1 2

样例输出 #1

1

提示

对于 $100\%$ 的数据，$1\le N,M\le 5$，$1\le T\le 10$，$1\le SX,FX\le n$，$1\le SY,FY\le m$。

#include <iostream>
using namespace std;

int n,m,t;
int sx,sy,fx,fy,px,py;//起点坐标和终点 障碍点坐标
int ans=0;//方案数
int a[6][6];//地图,1表示障碍，0表示空地
int v[6][6];//标记，1表示走过，0表示未走过
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};
void dfs(int x,int y)//坐标
{
	if(x==fx&&y==fy){
		ans++;
		return;//回溯，继续找
	}
	else{//顺时针：右下左上，深搜
		for(int k=0;k<4;k++){
			int tx,ty;
			tx=x+dx[k];
			ty=y+dy[k];
			if(tx>=1&&tx<=n &&ty>=1&&ty<=m && a[tx][ty]==0&&v[tx][ty]==0)//未越界 空地 未访问过
			{
				v[tx][ty]=1;
			    dfs(tx,ty);
			    v[tx][ty]=0;//回溯
			}
		}
	}
	return ;
}
int main()
{
	cin>>n>>m>>t;
	cin>>sx>>sy>>fx>>fy;
	for(int i=0;i<t;i++){
		cin>>px>>py;
		a[px][py]=1;//障碍点
	}
    v[sx][sy]=1;//从起点开始，标记起点
	dfs(sx,sy);
    /*原本是：但是只有70分
    dfs(sx,sy);
    v[sx][sy]=1;
    */
	//应先标记，再深搜，顺序不能乱
	cout<<ans;
	return 0;
}