蒟蒻的ACM算法(二)-BFS

什么是BFS

  BFS:中文名为"广度优先搜索算法（宽度优先搜索算法）",其英文全称是 Breadth First Search
是利用队列数据结构(FIFO)来解决从初始状态到最终状态最少步骤问题.

BFS的核心:队列

  队列是什么??
  队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。
  如何写并不重要,这里主要讲怎么用

1. 头文件:

#include<queue>

2. 定义一个数据类型为x的队列q

queue<x >q;

3. 放入一个数据x

q.push(x);

4. 判断队列q是否为空

q.empty();  //队列是否为空,为空返回1
q.size() //队列里元素的个数

5. 取队首的元素赋给x,并删除队首元素

x=q.front(); //取出队首元素给x
q.pop();  //删除队首元素

核心写法

while(!q.empty()){
	q.front();q.pop();
	if[判断结束的条件是否达成]
		达成后进行的操作,break;
	if[如果没有结束,判断进行下一步的条件是否达成]
		达成则进行处理,q.push();
}

例题及解析

1.仙岛求药
描述
少年李逍遥的婶婶病了，王小虎介绍他去一趟仙灵岛，向仙女姐姐要仙丹救婶婶。叛逆但孝顺的李逍遥闯进了仙灵岛，克服了千险万难来到岛的中心，发现仙药摆在了迷阵的深处。迷阵由M×N个方格组成，有的方格内有可以瞬秒李逍遥的怪物，而有的方格内则是安全。现在李逍遥想尽快找到仙药，显然他应避开有怪物的方格，并经过最少的方格，而且那里会有神秘人物等待着他。现在要求你来帮助他实现这个目标。
下图 显示了一个迷阵的样例及李逍遥找到仙药的路线.

输入
  输入有多组测试数据. 每组测试数据以两个非零整数 M 和 N 开始，两者均不大于20。M 表示迷阵行数, N 表示迷阵列数。接下来有 M 行, 每行包含N个字符,不同字符分别代表不同含义:
1)‘@’：少年李逍遥所在的位置；
2)‘.’：可以安全通行的方格；
3)‘#’：有怪物的方格；
4)‘*’：仙药所在位置。

  当在一行中读入的是两个零时，表示输入结束。
输出
  对于每组测试数据，分别输出一行，该行包含李逍遥找到仙药需要穿过的最少的方格数目(计数包括初始位置的方块)。如果他不可能找到仙药, 则输出 -1。
样例输入
8 8
.@##…#
#…#.#
#.#.##…
…#.###.
#.#…#.
…###.#.
…#.…
.#…###
6 5
..#.
.#…
…##.
…
.#…
…@
9 6
.#…#.
.#.*.#
.####.
…#…
…#…
…#…
…#…
#.@.##
.#…#.
0 0
样例输出
10
8
-1
解析
由于BFS的性质,找到的点一定是最小步数.就是简单的BFS模板.注意多组输入就可以了.

#include <cmath>
#include <ctime>
#include <queue>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>//头文件准备
using namespace std;

char a[21][21];
int n, m, dx[4] = { 0,1,0,-1 }, dy[4] = { 1,0,-1,0 };
struct vec {
	int x, y, step;
}s,e,p;
int main() {
	while (cin >> n >> m&&n!=0&&m!=0) {
		memset(a, 0, sizeof(a));
		for(int i=0;i<n;i++)
			for (int j = 0; j < m; j++) {
				cin >> a[i][j];
				if (a[i][j] == '@')
					s.x = i, s.y = j, s.step = 0;
				else if (a[i][j] == '*')
					e.x = i, e.y = j, e.step = -1;
			}
		queue<vec >q;
		q.push(s);
		while (q.size() != 0) {
			p = q.front(), q.pop();
			if (p.x == e.x&&p.y == e.y) {
				e.step = p.step;
				break;
			}
			for (int i = 0; i < 4; i++) {
				vec r = p;
				r.x+= dx[i], r.y+= dy[i],r.step++;
				if (r.x >= 0 && r.x < n&&r.y >= 0 && r.y < m&&a[r.x][r.y] != '#') {
					q.push(r);
					a[r.x][r.y] = '#';
				}
			}
		}
		cout << e.step << endl;
	}
	return 0;
}

2. P1141 01迷宫
题目描述
  有一个仅由数字0与1组成的n×n格迷宫。若你位于一格0上，那么你可以移动到相邻4格中的某一格1上，同样若你位于一格1上，那么你可以移动到相邻4格中的某一格0上。
你的任务是：对于给定的迷宫，询问从某一格开始能移动到多少个格子（包含自身）。
输入输出格式
输入格式：
  第1行为两个正整数n,m。
  下面n行，每行n个字符，字符只可能是0或者1，字符之间没有空格。
接下来m行，每行22个用空格分隔的正整数i,j，对应了迷宫中第i行第j列的一个格子，询问从这一格开始能移动到多少格。
输出格式：
m行，对于每个询问输出相应答案。
输入输出样例
输入样例#1：
2 2
01
10
1 1
2 2
输出样例#1：
4
4
说明
所有格子互相可达。
对于20%的数据，n≤10；
对于40%的数据，n≤50；
对于50%的数据，m≤5；
对于60%的数据，n≤100,m≤100；
对于100%的数据，n≤1000,m≤100000。
解析
  就是向四个方向走,能每走一个格子,就个数加一.然后把每一块可以走的算作一大块,打上一个标记,每次查询到这一大块里的任意一个格子的时候,直接输出格子的标记代表的值就可以了.

#include<stdio.h>
#include<cstring>
#include<iostream>
#include<math.h>
#include<algorithm>
#include<stack>
#include<queue>
#include<stdlib.h>
using namespace std;

int t = 1,ans=0, n, dx[4] = { 0,1,0,-1 }, dy[4] = { 1,0,-1,0 };
char map[1001][1001];
int val[1001][1001],a[1000001];
struct vec {
	int x, y;
}p;

int main()
{
	int m;
	memset(map, 0, sizeof(map));
	cin >> n >> m;
	for (int i = 0; i < n; i++)
		cin >> map[i];
	queue<struct vec>q;
	for(int i=0;i<n;i++)
		for (int j = 0; j < n; j++)
			if (val[i][j] == 0) {
				p.x = i, p.y = j;
				q.push(p);
				ans++; 
				val[i][j] = t;
				while (q.size() != 0) {
					p = q.front(); q.pop();
					for (int k = 0; k < 4; k++){
						vec ip = p;
						ip.x = dx[k] + p.x, ip.y = p.y + dy[k];
						if (val[ip.x][ip.y] == 0 && ip.x >= 0 && ip.x < n&&ip.y < n&&ip.y >= 0 && (map[p.x][p.y] != map[ip.x][ip.y])) {
							val[ip.x][ip.y] = t;
							ans++;
							q.push(ip);
						}
					}
				}
				a[t] = ans;
				ans = 0;
				t++;
			}
	for (int i = 0; i < m; i++) {
		int x, y;
		scanf("%d %d",&x,&y);
		cout << a[val[x-1][y-1]] << endl;
	}
	return 0;
}