【BFS】广度优先搜索&【DFS】深度优先搜索

深度优先搜索：

这种算法就是建立在递归之上的，大体思路就是：找到最深处（冲啊！！！），返回，找第二种，再返回……直到找完，解决得了很多迷宫问题（你最好不要用此算法尝试数据大得恶心的最优解题，不然超时超得你透心凉心飞扬）

广度优先搜索：

顾名思义，从一个点找到他所有可以到的点，入队，即“一层一层”地找下一位置，将head移至下一个（弹出），再找head能去的所有点，入队，步数++……直到无处可找，当然，和深搜一样，要标记找过的点，且要判断此点是否出界或遇到墙，最后的节点的步数即是最短的路径了（对比深搜，优势就在很快（特别是最优解）），如果要输出路径的话，加一个father，最后递归输出就行了~

当然，我用的结构体模拟队列，直接用队列也是可以的，自己百度~

栗子：

The First：

1388:Lake Counting

总时间限制: 

1000ms 

内存限制: 

65536kB

描述

Due to recent rains, water has pooled in various places in Farmer John's field, which is represented by a rectangle of N x M (1 <= N <= 100; 1 <= M <= 100) squares. Each square contains either water ('W') or dry land ('.'). Farmer John would like to figure out how many ponds have formed in his field. A pond is a connected set of squares with water in them, where a square is considered adjacent to all eight of its neighbors.

Given a diagram of Farmer John's field, determine how many ponds he has.

输入

* Line 1: Two space-separated integers: N and M

* Lines 2..N+1: M characters per line representing one row of Farmer John's field. Each character is either 'W' or '.'. The characters do not have spaces between them.

输出

* Line 1: The number of ponds in Farmer John's field.

样例输入

10 12
W........WW.
.WWW.....WWW
....WW...WW.
.........WW.
.........W..
..W......W..
.W.W.....WW.
W.W.W.....W.
.W.W......W.
..W.......W.

样例输出

3

提示

OUTPUT DETAILS:

There are three ponds: one in the upper left, one in the lower left,and one along the right side.

来源

USACO 2004 November

#------------------------------------------------------------------------------#

题目大意：找有多少个水塘（"W"代表有水，"."代表干旱），共8个方向（哪八个不解释……）都算作一个水塘。

思路：

1.深搜：查每个点，只要是“W”，就开始dfs，把所有和它相连的“W”变为“.”，sum++，最后输出sum。

2.广搜：同样查每个点，是要是“W”，就开始bfs，将每个和它有相连的入队，找下一个，每找一个便将它变为“.”，sum++，最后输出sum。

代码（DFS）：

#include<cstdio>
char s[102][102];
int n,m;
int f[8][2]={{1,0},{-1,0},{0,1},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1}};//八个方向
int sum;
void w(int x,int y)//深搜
{
	if(x<0||y<0||x==n||y==m||s[x][y]=='.')//边界条件
		return;
	s[x][y]='.';//标记
	for(int i=0;i<8;i++)
		w(x+f[i][0],y+f[i][1]);//查找下一个
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++)
		scanf("%s",s[i]);//读入
	for(int i=0;i<n;i++)//这里要看你是从哪里开始的
		for(int j=0;j<m;j++)//注意这里一定要从0开始，从一开始也行，参看BFS
			if(s[i][j]=='W')//找到“W”
			{
				w(i,j);//其实它的作用是将“W”所在的池塘全部变为干旱地
				sum++;//池塘数++
			}
	printf("%d",sum);//输出
	return 0;
}

DFS是很久以前写的，以下的BFS是现在写的：

#include<cstdio>
#include<cstring>
struct queue
{
	int x,y;//结构体模拟队列，存坐标
}q[10005];
int n,m,head=1,tail=1,sum;//定义头和尾，头事实上指的是尾的父亲，而尾指的是当前位置
int f[8][2]={{0,1},{0,-1},{1,0},{-1,0},{1,1},{-1,-1},{1,-1},{-1,1}};
char map[105][105];
void bfs(int x,int y)
{
	q[tail].x=x; q[tail].y=y; tail++; map[x][y]='.';//初始化，将第一个坐标入队
	while(head<tail)//头大于尾时说明队列为空
	{
		for(int i=0;i<8;i++)
		{
			int _x,_y;
			_x=q[head].x+f[i][0];
			_y=q[head].y+f[i][1];//新坐标
			if(_x>n||_x<1||_y>m||_y<1)//边界
				continue;
			if(map[_x][_y]=='W')
			{
				map[_x][_y]='.';//标记
				q[tail].x=_x;
				q[tail].y=_y;//入队
				tail++;//尾移向下一个
			}
		}
		head++;//注意头一定要++，因为这里和头有关系的已经枚举完了，该枚举下一个了
	}
	sum++;//统计chitangshu
	memset(q,0,sizeof(q));//清零（应该可以不用）
	tail=1; head=1;
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
		scanf("%s",map[i]+1);//读入，“+1”指往后一位存
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++)//所以这里可以从1开始
			if(map[i][j]=='W')
				bfs(i,j);
	printf("%d",sum);//输出
}

#------------------------------------------------------------------------------#

The Second：

7084:迷宫问题

总时间限制: 

1000ms 

内存限制: 

65536kB

描述

定义一个二维数组： 

int maze[5][5] = {

0, 1, 0, 0, 0,

0, 1, 0, 1, 0,

0, 0, 0, 0, 0,

0, 1, 1, 1, 0,

0, 0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

输入

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

输出

左上角到右下角的最短路径，格式如样例所示。

样例输入

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

样例输出

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

#------------------------------------------------------------------------------#
这个数据小，用深搜应该也可以，不过用广搜练练手。

具体步骤跟前一题相同，主要是输出路径：

每次入队时将它的father设为head，输出时从末尾的father递归到最前面开始输出，注意，最后要单独处理末尾，因为是从末尾的爸爸开始查的。

代码：

#include<cstdio>
struct queue
{
	int x,y,f;
}q[100];//结构体模拟队列
int map[7][7],f[4][2]={{0,1},{0,-1,},{-1,0},{1,0}};//只有4个方向
int tail=1,head=1;//头和尾，用处同上
void bfs()
{
	q[tail].x=1; q[tail].y=1; tail++;//初始化，尾指向下一个
	while(head<tail)//队列不为空
	{
		for(int i=0;i<4;i++)
		{
			int _x,_y;
			_x=q[head].x+f[i][0];
			_y=q[head].y+f[i][1];//将要到达的位置
			if(_x<1||_x>5||_y<1||_y>5)//边界
				continue;
			if(map[_x][_y]==0)//不为墙
			{
				map[_x][_y]=1;
				q[tail].x=_x;
				q[tail].y=_y;//入队
				q[tail].f=head;//注意记录父亲
				tail++;
			}
		}
		head++;//头一定要指向下一个
	}
}
void print(int x)
{
	if(x!=1) print(q[x].f);//找到入口
	printf("(%d, %d)\n",q[x].x-1,q[x].y-1);//一层一层返回，递归输出
}
int main()
{
	for(int i=1;i<=5;i++)
		for(int j=1;j<=5;j++)
			scanf("%d",&map[i][j]);//输入
	bfs();
	print(q[tail-1].f);
	printf("(4, 4)\n");//别忘了加上终点
}

                                                                                             By WZY