深度优先搜索：
这种算法就是建立在递归之上的，大体思路就是：找到最深处（冲啊！！！），返回，找第二种，再返回……直到找完，解决得了很多迷宫问题（你最好不要用此算法尝试数据大得恶心的最优解题，不然超时超得你透心凉心飞扬）
广度优先搜索：
顾名思义，从一个点找到他所有可以到的点，入队，即“一层一层”地找下一位置，将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);//输出
}
#------------------------------------------------------------------------------#
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)
",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)
");//别忘了加上终点
}
By WZY