BFS(思路加简单例题)
上次讲的DFS是一直往前走,直到无路可走的时候就返回,而BFS不一样。
BFS是广度优先搜索,顾名思义就是横着来搜索,也就是按层次来搜索,一层层来搜索。
广度优先搜索是一种分层的查找过程,每向前走一步可能访问一批顶点,不像深度优先搜索(DFS)那样有回退的情况,因此它不是一个递归的算法,为了实现逐层的访问,算法必须借助一个辅助队列并且以非递归的形式来实现。
BFS搜索的步骤
1、首先创建一个mp[ ]数组用来判断该位置是否被访问;
2、再创建一个队列p用来储存下一步要访问的点。
3、让起点start入队,并使该点的mp赋值为1;
4、while(!q.empty()){…}执行搜索操作,
a、取出队头元素后使队头元素出队,判断该元素是否为目标到达点;
b、如果是目标点,就返回结果(一般是最短时间、最短路径);
c、如果不是目标点,就继续访问与其相邻的位置点,将可走的相邻的位置点入队,并更新mp[ ]数组直到找到目标;
模板
struct Node
{
int x,y;
int step;
};//结构体
queue<int>p;//队列p
int mp[10005][10005];
int dx[]={1,0,0,-1};//方向数组
int dy[]={0,1,-1,0};
// 计算从起点 start 到终点 ed 的最近距离
int BFS(Node start, Node target) {
p.push(start); //将起点加入队列
mp[stat.x][start.y]=1;
while (!p.empty()) {
Node temp=p.front()//取出队头元素
p.pop()//将队头元素出队
/* 将当前队列中的所有节点向四周扩散 */
for (int i = 0; i < 4; i++) {
int xx=temp.x+dx[i];
int yy=temp.y+dy[i];
/* 划重点:这里判断是否到达终点 */
if (xx==target.x&&yy==target.y)
return temp.step+1;
if(mp[xx][yy]||越界)
continue;
p.push({xx,yy,temp.step+1});//将xx,yy,temp.step+1,当成结构体压入队列
mp[xx][yy]=1;//标记走过
}
}
}
一,走迷宫的最短路径
链接:https://ac.nowcoder.com/acm/problem/15136
来源:牛客网
题目描述
这是一个关于二维迷宫的题目。我们要从迷宫的起点 ‘S’ 走到终点 ‘E’,每一步我们只能选择上下左右四个方向中的一个前进一格。 ‘W’ 代表墙壁,是不能进入的位置,除了墙壁以外的地方都可以走。迷宫内的 ‘D’ 代表一道上锁的门,只有在持有钥匙的时候才能进入。而 ‘K’ 则代表了钥匙,只要进入这一格,就会自动地拿到钥匙。最后 ‘.’ 则是代表空无一物的地方,欢迎自在的游荡。
本题的迷宫中,起点、终点、门跟钥匙这四个特殊物件,每一个恰好会出现一次。而且,此迷宫的四周 (最上面的一行、最下面的一行、最左边的一列以及最右边的一列) 都会是墙壁。
请问,从起点到终点,最少要走几步呢?
输入描述:
输入的第一行有两个正整数H, W,分别代表迷宫的长跟宽。
接下来的H行代表迷宫,每行有一个长度恰为W的字串,此字串只包含`'S'`, `'E'`, `'W'`, `'D '`, `'K'`, `'.'`这几种字元。
输出描述:
请在一行中输出一个整数代表答案,如果无法从起点走到终点,请输出-1。
示例1
输入
4 12
WWWWWWWWWWWW
WE.W.S..W.KW
W..D..W....W
WWWWWWWWWWWW
输出
20
示例2
输入
6 6
WWWWWW
WEWS.W
W.WK.W
W.WD.W
W.W..W
WWWWWW
输出
-1
备注:
4 ≤ H, W≤ 500
'S', 'E', 'K', 'D'各出现恰好一次
迷宫的四周(最上面的一行、最下面的一行、最左边的一列以及最右边的一列) 都会是 'W'
思路
从起点到终点一共存在两种可行性
1)起点直接到达终点, 起点 -> 终点。
2)通过 起点S -> 钥匙 -> 门-> 终点E。
最终到达终点的可行方案
1)如果 不能直接从 起点S -> 终点E ,需要考虑 获取钥匙开门的途径,如果仍然不能到达终点,则输出 -1,否则输出到达终点的最小步数。
2)如果 起点S -> 终点E 可行 ,那么 获取钥匙开门到达终点必定可行 ,此时只需比较二者步数,获得最小步数即可。
#include<bits/stdc++.h>
using namespace std;
int mp[505][505];//用来标记该点是否被走过
char migon[505][505];//输入
int dx[] = {1,-1,0,0};
int dy[] = {0,0,1,-1};
int H,W;
struct car
{
int x;//行
int y;//列
int step=0;//从起点到(x,y)得最小步数;
}st,ed,key,door;//定义起点,终点,钥匙,门,四个结构体;
int bfs(car beg,car end)
{
queue<car>p;//创建一个队列储存(bfs一般都得创一个队列)
p.push(beg);
mp[beg.x][beg.y]=1;//将走过的做标记
while(!p.empty())
{
car temp,t;
temp=p.front();//获取当前格子
p.pop();//将该格子去掉
if(temp.x==end.x && temp.y==end.y)
return temp.step;//如果到达终点将步数返回
for(int i=0;i<4;i++)//遍历四个方向
{
int xx=temp.x+dx[i];
int yy=temp.y+dy[i];
t=temp;
if(xx<0||yy<0||xx>=H||yy>=W)//越界
continue;
if(mp[xx][yy]||migon[xx][yy]=='W'||migon[xx][yy]=='D')//走过的地方跳过,W是墙跳过,门跳过(后面拿到钥匙将D改成了.);
continue;
t.x=xx;
t.y=yy;
t.step++;
p.push(t);
mp[xx][yy]=1;
}
}
return -1;
}
int main()
{
cin>>H>>W;
for(int i=0;i<H;i++)
{
for(int j=0;j<W;j++)
{
cin>>migon[i][j];
if(migon[i][j]=='S')//记录下起点,终点,钥匙,门的位置
st.x=i,st.y=j;
else if(migon[i][j]=='E')
ed.x=i,ed.y=j;
else if(migon[i][j]=='K')
key.x=i,key.y=j;
else if(migon[i][j]=='D')
door.x=i,door.y=j;
}
}
memset(mp,0,sizeof(mp));
int ans1=bfs(st,ed);//直接从起点到终点,不开门
memset(mp,0,sizeof(mp));
int ans2=bfs(st,key);//从起点去拿钥匙
memset(mp,0,sizeof(mp));
migon[door.x][door.y]='.';//拿到钥匙将门变成点
int ans3=bfs(key,door);//拿了钥匙去开门
memset(mp,0,sizeof(mp));
int ans4=bfs(door,ed);//开完门去终点
if(ans1==-1)//不拿钥匙走不通的情况
{
if(ans2==-1||ans3==-1||ans4==-1)
cout<<-1<<endl;
else
cout<<ans2+ans3+ans4<<endl;
}
else
cout<<min(ans1,ans2+ans3+ans4);//输出小的
return 0;
}
二、【CCF-CSP】最优配餐
问题描述
栋栋最近开了一家餐饮连锁店,提供外卖服务。随着连锁店越来越多,怎么合理的给客户送餐成为了一个急需解决的问题。
栋栋的连锁店所在的区域可以看成是一个n×n的方格图(如下图所示),方格的格点上的位置上可能包含栋栋的分店(绿色标注)或者客户(蓝色标注),有一些格点是不能经过的(红色标注)。
方格图中的线表示可以行走的道路,相邻两个格点的距离为1。栋栋要送餐必须走可以行走的道路,而且不能经过红色标注的点。
送餐的主要成本体现在路上所花的时间,每一份餐每走一个单位的距离需要花费1块钱。每个客户的需求都可以由栋栋的任意分店配送,每个分店没有配送总量的限制。
现在你得到了栋栋的客户的需求,请问在最优的送餐方式下,送这些餐需要花费多大的成本。
输入格式
输入的第一行包含四个整数n, m, k, d,分别表示方格图的大小、栋栋的分店数量、客户的数量,以及不能经过的点的数量。
接下来m行,每行两个整数xi, yi,表示栋栋的一个分店在方格图中的横坐标和纵坐标。
接下来k行,每行三个整数xi, yi, ci,分别表示每个客户在方格图中的横坐标、纵坐标和订餐的量。(注意,可能有多个客户在方格图中的同一个位置)
接下来d行,每行两个整数,分别表示每个不能经过的点的横坐标和纵坐标。
输出格式
输出一个整数,表示最优送餐方式下所需要花费的成本。
样例输入
10 2 3 3
1 1
8 8
1 5 1
2 3 3
6 7 2
1 2
2 2
6 8
样例输出
29
评测用例规模与约定
前30%的评测用例满足:1<=n <=20。
前60%的评测用例满足:1<=n<=100。
所有评测用例都满足:1<=n<=1000,1<=m, k, d<=n^2。可能有多个客户在同一个格点上。每个客户的订餐量不超过1000,每个客户所需要的餐都能被送到。
#include<bits/stdc++.h>
using namespace std;
int n,m,k,d;
int mp[1005][1005];
int w[1005][1005];
int dx[]={1,0,-1,0};
int dy[]={0,1,0,-1};
struct car
{
int x,y;
int step;
};
queue<car>p;
int bfs()
{
long long sum=0,cnt=0;//sum是记录总花费,cnt是记录已经送了几家客户
while(!p.empty()) {
car temp=p.front();
p.pop();
for(int i=0; i<4; i++) {
int xx=temp.x+dx[i];
int yy=temp.y+dy[i];
int st=temp.step+1;
if(!mp[xx][yy]&&xx>0&&xx<=n&&yy>0&&yy<=n) {
mp[xx][yy]=1;
if(w[xx][yy]!=0) {//走到客户时
sum+=st*w[xx][yy];
if(++cnt==k) return sum;//全部客户送完
}
p.push({xx,yy,st});
}
}
}
}
int main()
{
int x,y,c;
cin>>n>>m>>k>>d;
for(int i=1;i<=m;i++)
{
cin>>x>>y;
mp[x][y]=1;
p.push({x,y,0});//将每个店当起点压入队列
}
for(int i=1;i<=k;i++)
{
cin>>x>>y>>c;
w[x][y]=c;//将客户的位置和订餐量记录下来
}
for(int i=1;i<=d;i++)
{
cin>>x>>y;
mp[x][y]=1;//将不能走的地方标记为走过
}
cout<<bfs()<<endl;
return 0;
}
三、马的遍历
https://www.luogu.com.cn/problem/P1443
来源: 洛谷
题目描述
有一个n × \times ×m的棋盘(1<n,m<=400),在某个点上有一个马,要求你计算出马到达棋盘上任意一个点最少要走几步
输入格式
一行四个数据,棋盘的大小和马的坐标
输出格式
一个n × \times ×m的矩阵,代表马到达某个点最少要走几步(左对齐,宽5格,不能到达则输出-1)
输入
3 3 1 1
输出
0 3 2
3 -1 1
2 1 4
#include<bits/stdc++.h>
using namespace std;
int n,m,x,y;
int dx[]={1,2,2,-1,-2,-2,1,-1};
int dy[]={2,1,-1,2,1,-1,-2,-2};
int mp[1005][1005];
int a[1005][1005];//用来记录起点到每一个点的步数
struct car
{
int x,y;
};
queue<car>p;
void bfs(car st)
{
a[st.x][st.y]=0;
car temp;
p.push(st);
mp[st.x][st.y]=1;
while(!p.empty())
{
temp=p.front();
p.pop();
for(int i=0;i<8;i++)//遍历8个方向
{
int xx=temp.x+dx[i];
int yy=temp.y+dy[i];
if (xx<1||yy<1||xx>n||yy>m||mp[xx][yy])
continue;
mp[xx][yy]=1;
p.push({xx,yy});
a[xx][yy]=a[temp.x][temp.y]+1;
}
}
}
int main()
{
cin>>n>>m>>x>>y;
memset(a,-1,sizeof(a));
bfs({x,y});
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
printf("%-5d",a[i][j]);
}
cout<<endl;
}
return 0;
}