寒假笔记·BFS

BFS

BFS主要适用于求最短路问题

例题：迷宫

原题地址
题目描述

你在一个 n 行 m 列的网格迷宫中，迷宫的每一格要么为空，要么有一个障碍。
你当前在第 r 行第 c 列(保证该格子为空)。每次移动你可以向上下左右任意一个方向移动一格，前提是不能走到障碍上，也不能超出迷宫的边界。
你向左移动的次数不能超过 x 次，向右不能超过 y 次。
问在这种情况下，对于每个格子，是否存在一种移动方案让你走到它。
输出有多少个格子存在移动方案让你走到它。

输入描述:

第一行两个正整数 n,m 。
第二行两个正整数 r,c ，保证 1≤r≤n ，1≤c≤m 。
第三行两个整数 x,y ，保证 0≤x,y≤10^9 。
接下来 n 行，每行一个长度为 m 的字符串，
第 i 行第 j 个字符表示迷宫第 i 行第 j 列的格子，
字符为. 表示格子为空，字符为* 表示格子上有一个障碍。
输出描述:

输出一个数，表示有多少个格子存在移动方案让你走到它。
示例1

输入
4 5
3 2
1 2
…
.*.
…
*…
输出
10
代码：

#include <iostream>
#include <queue>
using namespace std;
const int MAX = 1e3+10;
const int mv[4][2]={1,0,-1,0,0,1,0,-1};
struct hh{
	int x,y;
	int l,r;
};
bool vis[MAX][MAX];
char mp[MAX][MAX];
int n,m,r,c,x,y;
int sum;//用来计数
void bfs(){
	queue<hh> q;
	hh tmp;
	tmp.x=r;tmp.y=c;
	tmp.l=x;tmp.r=y;
	q.push(tmp);
	vis[r][c]=true;//标记过的，就不走了
	while(!q.empty()){
		hh tp=q.front();
		q.pop();
		sum++;//计数
		for (int i = 0; i < 4;i++){
			int xx=tp.x+mv[i][0];
			int yy=tp.y+mv[i][1];
			if(xx>=1&&xx<=n&&yy>=1&&yy<=m&&mp[xx][yy]=='.'&&!vis[xx][yy]){
				vis[xx][yy]=true;//别忘了标记~
				if(i==0||i==1){//上下
					tmp.x=xx;tmp.y=yy;
					tmp.l=tp.l;tmp.r=tp.r;
					q.push(tmp);
				}
				else if(i==2&&tp.r>=1){//往右
					tmp.x=xx;tmp.y=yy;
					tmp.l=tp.l;tmp.r=tp.r-1;
					q.push(tmp);
				}
				else if(i==3&&tp.l>=1){//往左
					tmp.x=xx;tmp.y=yy;
					tmp.l=tp.l-1;tmp.r=tp.r;
					q.push(tmp);
				}
			}
		}
	}
}
int main(){
	cin >> n >> m >> r >> c >> x >> y;
	for (int i = 1; i <= n;i++){
		for (int j = 1; j <= m;j++){
			cin >> mp[i][j];
		}
	}
	bfs();
	cout << sum << endl;
	return 0;
}

例题：P1135 奇怪的电梯

原题地址
题目描述

呵呵，有一天我做了一个梦，梦见了一种很奇怪的电梯。大楼的每一层楼都可以停电梯，而且第i层楼(1≤i≤N)上有一个数字K_i。电梯只有四个按钮：开，关，上，下。上下的层数等于当前楼层上的那个数字。当然，如果不能满足要求，相应的按钮就会失灵。例如：3, 3 ,1 ,2 ,5代表了K_i(K_1=3,K_2=3,…)从1楼开始。在1楼，按“上”可以到4楼，按“下”是不起作用的，因为没有-2楼。那么，从A楼到B楼至少要按几次按钮呢？

输入输出格式

输入格式：
共二行。

第一行为33个用空格隔开的正整数，表示N,A,B(1≤N≤200, 1≤A,B≤N)。

第二行为N个用空格隔开的非负整数，表示K_i.
输出格式：
一行，即最少按键次数,若无法到达，则输出-1。

输入输出样例

输入样例#1：
5 1 5
3 3 1 2 5
输出样例#1：
3
代码：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
int n,qq[220],vi[220],a,b,ww[2000020][2],ans,fl=0;
int dx[2]={-1,1};
void bfs()
{
    int i,head=0,tail=1,tx;
    ww[1][0]=0;
    ww[1][1]=a;
    vi[a]=1;
    while(head<=tail)
    {
        head++;
        for(i=0;i<=1;i++)
        {
            tx=ww[head][1]+dx[i]*qq[ww[head][1]];
            if(tx==b)
            {
                fl=1;
                ans=ww[head][0]+1;
                return;
            }
            else if(tx>=1&&tx<=n&&vi[tx]==0)
            {
                tail++;
                ww[tail][0]=ww[head][0]+1;
                ww[tail][1]=tx;
                vi[tx]=1;
            }
        }
    }
}
int main()
{    
    int i;
    scanf("%d%d%d",&n,&a,&b);
    for(i=1;i<=n;i++)
        scanf("%d",&qq[i]);
    memset(ww,0,sizeof(ww));
    memset(vi,0,sizeof(vi));
    if(a==b)
    {
        ans=0;
        fl=1;
    }
    else bfs();
    if(fl) printf("%d\n",ans);
    else printf("-1\n");
    return 0;
}

与递归结合的BFS

每一步广搜都可以看作在参考数组中的递归过程。

例题：P1256 显示图像

原题地址
题目描述

古老的显示屏是由N×M个像素（Pixel）点组成的。一个像素点的位置是根据所在行数和列数决定的。例如P(2,1)表示第2行第1列的像素点。那时候，屏幕只能显示黑与白两种颜色，人们用二进制0和1来表示。0表示黑色，1表示白色。当计算机发出一个指令：P(x,y)=1，则屏幕上的第x行第y列的阴极射线管就开始工作，使该像素点显示白色，若P(x,y)=0，则对应位置的阴极射线管不工作，像素点保持黑色。在某一单位时刻，计算机以N×M二维01矩阵的方式发出显示整个屏幕图像的命令。

例如，屏幕是由3×4的 对应屏幕显示应为：

像素点组成，在某单位时刻，

计算机发出如下命令：

0001 0011 0110

假设放大后，一个格子表示一个像素点

由于未知的原因，显示黑色的像素点总是受显示白色的像素点的影响——可能是阴极射线管工作的作用。并且，距离越近，影响越大。这里的距离定义如下：设有像素点P1(x1,y1)和像素点P2(x2,y2)，则它们之间的距离D(P1,P2)：D(P1,P2)=|x1-x2|+|y1-y2| 在某一时刻，计算机发出显示命令后，科学家们期望知道，每个像素点和其最近的显示白色的像素点之间的最短距离是多少——科学家们保证屏幕上至少有一个显示白色的像素点。

上面的例子中，像素P(1,1)与最近的白色像素点之间的距离为3，而像素P(3,2)本身显示白色，所以最短距离为0。

输入输出格式

输入格式：
第一行有两个数字，N和M (1<=N,M<=182)，表示屏幕的规格。

以下N行，每行M个数字，0或1。为计算机发出的显示命令。

输出格式：
输出文件有N行，每行M个数字，中间用1个空格分开。第i行第j列的数字表示距像素点P(i,j)最近的白色像素点的最短距离。

输入输出样例

输入样例#1：
3 4
0001
0011
0110
输出样例#1：
3 2 1 0
2 1 0 0
1 0 0 1
说明

对于30%的数据：N*M<=10000；

对于100%的数据：N*M<=182^2。
代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cmath>
using namespace std;
int ss[200][200],qq[200][200],pp[200][200];
int dx[4]={0,0,-1,1};
int dy[4]={-1,1,0,0};
int n,m,t=0;
char ch[200][200];
struct point
{
    int x,y;
}zz[40010];
void bfs(int a,int b)
{
    int i,tx,ty;
    for(i=0;i<4;i++)
    {
        tx=a+dx[i];
        ty=b+dy[i];
        if(pp[tx][ty]==0&&qq[tx][ty]==0)
        {
            ss[tx][ty]=ss[a][b]+1;//递归过程
            t++;
            zz[t].x=tx;
            zz[t].y=ty;
            pp[tx][ty]=1;//已访问
        }
    }
}
int main()
{
    int i,j;
    scanf("%d%d",&n,&m);
    getchar();
    memset(pp,0,sizeof(pp));
    for(i=0;i<200;i++)
        for(j=0;j<200;j++)
            qq[i][j]=2;
    for(i=1;i<=n;i++)
        scanf("%s",ch[i]+1);
    for(i=1;i<=n;i++)
        for(j=1;j<=m;j++)
            qq[i][j]=ch[i][j]-'0';
    for(i=1;i<=n;i++)
        for(j=1;j<=m;j++)
        {
            if(qq[i][j])
            {
                ss[i][j]=0;
                t++;
                zz[t].x=i;
                zz[t].y=j;
            }
        }
    for(i=1;i<=t;i++)
        bfs(zz[i].x,zz[i].y);
    for(i=1;i<=n;i++)
    {
        for(j=1;j<m;j++)
            printf("%d ",ss[i][j]);
        printf("%d\n",ss[i][m]);
    }
    return 0;
}