深搜DFS和广搜BFS

深搜和广搜--原理彼此的优缺点

一般来说，广搜常用于找单一的最短路线，或者是规模小的路径搜索，它的特点是"搜到就是最优解"， 而深搜用于找多个解或者是"步数已知（好比3步就必需达到前提）"的标题，它的空间效率高，然则找到的不必定是最优解，必需记实并完成全数搜索，故一般情况下，深搜需要很是高效的剪枝（优化）.

像搜索最短路径这些的很显著是用广搜，因为广搜的特征就是一层一层往下搜的，保证当前搜到的都是最优解，当然，最短路径只是一方面的操作，像什么起码状态转换也是可以操作的。
深搜就是优先搜索一棵子树，然后是另一棵，它和广搜对比，有着内存需要相对较少的所长，八皇后标题就是典范楷模的操作，这类标题很显著是不能用广搜往解决的。或者像图论里面的找圈的算法，数的前序中序后序遍历等，都是深搜

深搜和广搜的分歧之处是在于搜索次序的分歧。

深搜的实现近似于栈，每次选择栈顶元素往扩年夜，

广搜则是操作了队列，先被扩年夜的的节点优先拿往扩年夜。

搜索树的形态：深搜层数良多，广搜则是很宽。

深搜合适找出所有方案，广搜则用来找出最佳方案

深搜和广搜的分歧：

深搜并不能保证第一次碰着方针点就是最短路径，是以要搜索所有可能的路径，是以要回溯，标识表记标帜做了之后还要打消失踪，是以统一个点可能被访谒良多良多次。而广搜因为它的由近及远的结点扩年夜次序，结点老是以最短路径被访谒。一个结点假如第二次被访谒，第二次的路径确定不会比第一次的短，是以就没有需要再从这个结点向周围扩年夜――第一次访谒这个结点的时辰已经扩年夜过了，第二次再扩年夜只会获得更差的解。是以做过的标识表记标帜不必往失踪。是以统一个点至多只可能被访谒一次。每访谒一个结点，与它相连的边就被搜检一次。是以最坏情况下，所有边都被搜检一次，是以时刻复杂度为O（E）。

BFS与DFS的讨论：BFS：这是一种基于队列这种数据结构的搜索方式，它的特点是由每一个状态可以扩展出许多状态，然后再以此扩展，直到找到目标状态或者队列中头尾指针相遇，即队列中所有状态都已处理完毕。
DFS：基于递归的搜索方式，它的特点是由一个状态拓展一个状态，然后不停拓展，直到找到目标或者无法继续拓展结束一个状态的递归。
         
优缺点：BFS:对于解决最短或最少问题特别有效，而且寻找深度小，但缺点是内存耗费量大（需要开大量的数组单元用来存储状态）。
        DFS：对于解决遍历和求所有问题有效，对于问题搜索深度小的时候处理速度迅速，然而在深度很大的情况下效率不高
 
总结：不管是BFS还是DFS，它们虽然好用，但由于时间和空间的局限性，以至于它们只能解决数据量小的问题。

最近刚刚接触搜索，听学长说搜索可以解决好多问题，就试着开始学了，话不多说，我们来看一道简单的搜索题，对于搜索的初学者有很大的帮助。

例题链接：        百练-3752 走迷宫

3752:走迷宫

• 查看
• 提交
• 统计
• 提示
• 提问

总时间限制: 

1000ms 

内存限制: 

65536kB

描述

一个迷宫由R行C列格子组成，有的格子里有障碍物，不能走；有的格子是空地，可以走。
给定一个迷宫，求从左上角走到右下角最少需要走多少步(数据保证一定能走到)。只能在水平方向或垂直方向走，不能斜着走。

输入

第一行是两个整数，Ｒ和Ｃ，代表迷宫的长和宽。（ 1<= R，C <= 40)
接下来是Ｒ行，每行Ｃ个字符，代表整个迷宫。
空地格子用'.'表示，有障碍物的格子用'#'表示。
迷宫左上角和右下角都是'.'。

输出

输出从左上角走到右下角至少要经过多少步（即至少要经过多少个空地格子）。计算步数要包括起点和终点。

样例输入

5 5
..###
#....
#.#.#
#.#.#
#.#..

样例输出

9

我们来看一下两种方法代码的实现：

一，DFS

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
char maps[40][40];//用于储存迷宫中的字符 
int dp[40][40];//用于标记是否被访问
int dir[2][4]={{1,0,0,-1},{0,1,-1,0}};//用于表示上下左右四个方向
int R,S;
int ans=1<<30;//1左移30位 
void DFS(int x,int y,int step)
{
	if(x>=R||y>=S||x<0||y<0)
	return ;           //x和y不能数组越界 
	if(x==R-1&&y==S-1)   //直到访问到右下端结束找到最少步数 
	{
	    if(step<ans)
		ans=step;
		return ;	
	} 
	if(maps[x][y]=='#')
	return ; 
	for(int i=0;i<4;i++)
	{
		if(x+dir[0][i]>=R||y+dir[1][i]>=S||x+dir[0][i]<0||y+dir[1][i]<0)
		continue;
		if(maps[x+dir[0][i]][y+dir[1][i]]=='.'&&!dp[x+dir[0][i]][y+dir[1][i]])
		{
			dp[x+dir[0][i]][y+dir[1][i]]=1;
			DFS(x+dir[0][i],y+dir[1][i],step+1);//等同于递归 
			dp[x+dir[0][i]][y+dir[1][i]]=0;
		} 
	}
} 
int main()
{
	char c;
	while(cin>>R>>S)
	{
		for(int i=0;i<R;i++)
		{
			for(int j=0;j<S;j++)
			{
				cin>>c;
				maps[i][j]=c;
				dp[i][j]=0;//初始化为0表示都未被访问 
			}
		}
		DFS(0,0,1);
		cout<<ans<<endl; 
	} 
	return 0;
}
二，BFS

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
char maps[40][40];//用于储存迷宫中的字符
int dp[40][40];//用于标记是否被访问
int dir[2][4]={{1,0,0,-1},{0,1,-1,0}};//用于表示上下左右四个方向
int R,S;
int ans=1<<30;
struct node
{
    int x;
	int y;
	int step;
	node(int xx,int yy,int tt):x(xx),y(yy),step(tt){}	
};
int BFS()
{
    queue<node> que;
	que.push(node(0,0,1));
	while(!que.empty())
	{
		node temp=que.front();
		que.pop();
		for(int i=0;i<4;i++)
		{
			int tx=temp.x+dir[0][i];
			int ty=temp.y+dir[1][i];
			int tt=temp.step;
			if(dp[tx][ty])
			continue;
			if(tx<0||tx>=R||ty<0||ty>=S)
			continue;
			if(maps[tx][ty]=='#')
			continue;
			if(tx==R-1&&ty==S-1)
			{
				return tt+1;
			}
			dp[tx][ty]=1;
			que.push(node(tx,ty,tt+1));
		}
	}	
} 
int main()
{
	while(cin>>R>>S)
	{
		for(int i=0;i<R;i++)
		{
			for(int j=0;j<S;j++)
			{
				cin>>maps[i][j];
				dp[i][j]=0;
			}
		}
		int ans=BFS();
		cout<<ans<<endl; 
	}
return 0;	
}