【BFS】学习

相关知识

BFS先找到的一定最短,但如果是加权的路就会出现问题,就应采用Dijkstra最短路径算法解决加权路径的最短路。

BFS可以解决:

1.从A点出发是否存在到达B的路径(DFS也可以做到

2.从A出发到达B的最短路径(如果数据小,20(数组行列数)以内,DFS也行

DFS、BFS的区别

(1条消息) 什么时候用DFS,什么时候用BFS?_dfs规模为多少时适合_yishuige的博客-CSDN博客

序号

BFS

DFS

1

BFS代表宽度优先搜索

DFS代表深度优先搜索

2

BFS(宽度优先搜索)使用队列数据结构来查找最短路径

DFS(深度优先搜索)使用栈数据结构

3

BFS更适合搜索更接近给定源的顶点

如果有远离源的解决方案,则DFS更适合

4

BFS首先考虑所有邻居,因此不适合用于游戏或拼图中的决策树。

DFS更适用于游戏或拼图问题。我们做出决定,然后探索有关该决定的所有路径。如果这一决定带来获胜局面,我们将停止。

5

当使用邻接表时,BFS的时间复杂度为O(V+E);当使用邻接矩阵时,BFS的时间复杂度为O(V^2),其中V表示顶点,E表示边。

当使用邻接表时,DFS的时间复杂度也是O(V+E),当使用邻接矩阵时,DFS的时间复杂度也是O(V^2),其中V表示顶点,E表示边。

实现方法

基本思想

解决问题

N规模

DFS

栈/递归

回溯法,一次访问一条路,更接近人的思维方式,

所有解问题,或连通性问题

不能太大,<=200

BFS

队列

分治限界法,一次访问多条路,每一层需要存储大量信息

最优解问题,如最短路径

可以比较大,因为可以用队列解决,<=1000

简单迷宫问题

走迷宫

题面可以看这个:(1条消息) acwing——844. 走迷宫_suxiaorui的博客-CSDN博客

#include
#include
#include 
#include 
using namespace std;
#define x first
#define y second
const int N=110;

typedef pair PII;//存坐标 
int n,m;
int g[N][N];//存地图 
int dist[N][N];//存每个点到起点的距离
queue q;

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
 
int bfs(int x1,int y1)
{
    memset(dist,-1,sizeof dist);//初始化数组dist全为-1 
    q.push({x1,y1}); //第一个点入队 
    dist[x1][y1]=0;//第一个进来的点是起点 
    while(!q.empty())
    {
        auto t=q.front();//取出队头 
        q.pop();
        
        for(int i=0;i<4;i++)//遍历四个方向 
        {
            int a=t.x+dx[i];
            int b=t.y+dy[i];
            if(a<1||a>n||b<1||b>n) continue;
            if(g[a][b]!=0) continue;
            if(dist[a][b]>0) continue;//判断是否访问过 
            
            q.push({a,b});//压入满足条件的点 
            dist[a][b]=dist[t.x][t.y]+1;
            if(a==n&&b==m) return dist[n][m];//到达了终点,直接返回距离 
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i>g[i][j];
        }
    }
    int res=bfs(1,1); 
    cout<

这里发现头文件cstring和string竟然是不一样的,memset要用ctring。

理一理思路:

先把起点放队列里,

只要队列里有数就弹出头结点,然后遍历头结点的四个方向,如果有点满足题目条件,就压入队列中;同时更新满足条件的点的dist,当点到达终点时直接退出循环,并返回dist。

离开中山路

P1746 离开中山路 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include
using namespace std;
const int N=1e3+10;
#define x first
#define y second
typedef pair PII;
int n;
int x,y,x2,y2;
char g[N][N];//输入没有空格所以用char类型 
int dist[N][N];//存距离 
queue q;
int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
int bfs(int x,int y)//从第x个位 
{
    memset(dist,-1,sizeof dist); 
    q.push({x,y});
    dist[x][y]=0;//起点赋值为0
    while(!q.empty())//遍历四个方向 
    {
        auto t=q.front();
        q.pop();
         
        for(int i=0;i<4;i++)
        {
            int a=t.x+dx[i];
            int b=t.y+dy[i];
            if(a<1||b<1||a>n||b>n) continue;//越界
            if(g[a][b]!='0') continue;//此路不通
            if(dist[a][b]>=0) continue;//已经走过了
            
            q.push({a,b});//符合条件就压入队列 
            dist[a][b]=dist[t.x][t.y]+1;
            
            if(dist[x2][y2]>0)    return dist[x2][y2];
        }
    } 
    return -1;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%s",g[i]+1);//注意,天坑
        //我们存的地图是要从(1,1)开始的,
        //这里i从1开始可以确保行从1开始 
        //需要列从1开始,就需要g[i]+1 
    }
    scanf("%d%d%d%d",&x,&y,&x2,&y2);
    
    int res=bfs(x,y);
    cout<
这题写的真有点受不了,一开始定义的变量是x1,y1,x2,y2,在dev上能正常运行,但洛谷和acwing就是编译错误。

呵呵,最后google才知道y1是一个关键字,有点无语就是说。

记住以后定义变量不要叫y1就好

C++中的那些报错之“[Error] ‘int y1‘ redeclared as diffrent kind of symbol”_XIOAGANG666的博客-CSDN博客

【BFS】学习_第1张图片

马的遍历

P1443 马的遍历 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

这题就是一个bfs,不多说

#include
using namespace std;
const int N=1e3+10;
#define x first
#define y second
typedef pair PII;
int n,m,x,y;
queue q;
int dist[N][N];
int dx[]={-2,-1,1,2,2,1,-1,-2};
int dy[]={1,2,2,1,-1,-2,-2,-1};

void bfs(int x,int y)
{
    memset(dist,-1,sizeof dist);
    q.push({x,y});
    dist[x][y]=0;
    while(!q.empty())
    {
        auto t=q.front();
        q.pop();
        for(int i=0;i<8;i++)
        {
            int a=t.x+dx[i];
            int b=t.y+dy[i];
            if(a<1||b<1||a>n||b>m) continue;
            if(dist[a][b]>=0) continue;
            q.push({a,b});
            dist[a][b]=dist[t.x][t.y]+1;
        }    
    }
     
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&x,&y);
    bfs(x,y);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            printf("%d    ",dist[i][j]);
        }
        cout<

数组模拟队列

stl中都提供了queue,为什么还要手写数组来模拟队列呢?

答案很简单,在算法竞赛中,这样会比较快

用hh和tt双指针指向头结点和尾节点 队列特性 头删尾插

hh一般初始化为0,tt可以为-1或0,转化也比较简单,不多说了。

#include
using namespace std;
const int N=1e3+10;
#define x first
#define y second
typedef pair PII;
int n,m,x,y;
//queue q;
PII q[N*N];//PII类型的数组模拟队列 
int dist[N][N];
int dx[]={-2,-1,1,2,2,1,-1,-2};
int dy[]={1,2,2,1,-1,-2,-2,-1};

void bfs(int x,int y)
{
    memset(dist,-1,sizeof dist);
     
    q[0]={x,y};
    dist[x][y]=0;
    
    int hh=0,tt=0;//分别指向头结点和尾节点 
    while(hh<=tt) 
    {
        auto t=q[hh];
        hh++;//出队 
        for(int i=0;i<8;i++)
        {
            int a=t.x+dx[i];
            int b=t.y+dy[i];
            
            if(a<1||b<1||a>n||b>m) continue;
            if(dist[a][b]>=0) continue;
            
            q[++tt]={a,b};//尾插 
            dist[a][b]=dist[t.x][t.y]+1;
        }    
    }
     
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&x,&y);
    bfs(x,y);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            printf("%-5d",dist[i][j]);
        }
        cout<

好奇怪的游戏

P1747 好奇怪的游戏 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

主要思路是从(1,1)开始走,直接输出马起点的dist就行了

这题如果边界是00,就只有80分,改成11,才能AC

#include 
using namespace std;
#define x first
#define y second
const int N=30;
typedef pair PII;
int  p1,p2,p3,p4;
PII q[N*N];
int dist[N][N]; 
int hh=0,tt=-1;
int dx[]={-2,-2,-1,1,2,2,2,2,1,-1,-2,-2};
int dy[]={1,2,2,2,2,1,-1,-2,-2,-2,-2,-1};
void bfs()
{//头删尾插 
    memset(dist,-1,sizeof dist);
    
    q[++tt]={1,1};//从11开始
    dist[1][1]=0;
    while(hh<=tt)
    {
        auto t=q[hh++];
        for(int i=0;i<12;i++)
        {
            int a=t.x+dx[i];
            int b=t.y+dy[i];
            if(dist[a][b]>=0) continue;//走过就不再走了 
            if(a<1||b<1||a>20||b>20) continue; 
            dist[a][b]=dist[t.x][t.y]+1;
            q[++tt]={a,b}; 
        }
    }
    return;
}
int main() 
{
    cin>>p1>>p2>>p3>>p4;
    bfs();
    cout<

Bronze Lilypad Pond B

P2385 [USACO07FEB]Bronze Lilypad Pond B - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

#include 
using namespace std;
#define x first
#define y second
const int N=40;
typedef pair PII;
PII start,end1;
PII q[N*N];
int hh=0,tt=-1;
int m,n,m1,m2;//M,N的矩阵,移动格数
int g[N][N];//存图 
int dist[N][N];

void bfs()
{//头删尾插 
    memset(dist,-1,sizeof dist);
    int dx[]={m2,m1,m1,-m2,-m2,-m1,-m1,-m2};
    int    dy[]={m1,m2,-m2,m1,-m1,-m2,m2,m1};
    q[++tt]=start;
    dist[start.x][start.y]=0;
    while(hh<=tt)
    {
        auto t=q[hh++];
        for(int i=0;i<8;i++)
        {
            int a=t.x+dx[i];
            int b=t.y+dy[i];
            
            if(a<1||b<1||a>m||b>n) continue;//越界结束
            if(dist[a][b]>=0) continue;//走过就结束
            if(g[a][b]==0||g[a][b]==2) continue;//只有0和2不能走
            
            q[++tt]={a,b};
            dist[a][b]=dist[t.x][t.y]+1;
            if(end1.x==a&&end1.y==b) return; 
        }    
    }
    return;
}
int main() 
{
    scanf("%d%d%d%d",&m,&n,&m1,&m2);
    
    
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=n;j++)
        {
            scanf("%d",&g[i][j]);
            if(g[i][j]==3) start={i,j};
            if(g[i][j]==4) end1={i,j};
        }
    }
    bfs();
    cout<

有三个点一直WA真绷不住了

【BFS】学习_第2张图片

后续,我看了一中午给人心态看崩了,给大佬一眼看出来方向向量写错了,蒟蒻就是蒟蒻

【BFS】学习_第3张图片

AC代码

#include 
using namespace std;
#define x first
#define y second
const int N=40;
typedef pair PII;
PII start,end1;
PII q[N*N];
int hh=0,tt=-1;
int m,n,m1,m2;//M,N的矩阵,移动格数
int g[N][N];//存图 
int dist[N][N];

void bfs()
{//头删尾插 
    memset(dist,-1,sizeof dist);
    int dx[]={m2,m1,m1,-m2,-m2,-m1,-m1,m2};
    int    dy[]={m1,m2,-m2,m1,-m1,-m2,m2,-m1};
    q[++tt]=start;
    dist[start.x][start.y]=0;
    while(hh<=tt)
    {
        auto t=q[hh++];
        for(int i=0;i<8;i++)
        {
            int a=t.x+dx[i];
            int b=t.y+dy[i];
            
            if(a<1||b<1||a>m||b>n) continue;//越界结束
            if(dist[a][b]>=0) continue;//走过就结束
            if(g[a][b]==0||g[a][b]==2) continue;//只有0和2不能走
            
            q[++tt]={a,b};
            dist[a][b]=dist[t.x][t.y]+1;
            if(end1.x==a&&end1.y==b) return; 
        }    
    }
    return;
}
int main() 
{
    scanf("%d%d%d%d",&m,&n,&m1,&m2);
    
    
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=n;j++)
        {
            scanf("%d",&g[i][j]);
            if(g[i][j]==3) start={i,j};
            if(g[i][j]==4) end1={i,j};
        }
    }
    bfs();
    cout<

多源BFS

血色先锋队

P1332 血色先锋队 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

【BFS】学习_第4张图片
#include
using namespace std;
const int N=510;
#define x first
#define y second
typedef pair PII;
PII q[N*N];//数组模拟队列 
int n,m,a,b;//n行m列 ,a个感染源,b个领主 
int dist[N][N];
int hh=0;
int tt=-1;
int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
//先对每个感染源进行入队,然后bfs,然后直接输出领主位置的dist
 
void bfs()
{//已经入队完毕了,直接弹出头结点 
    while(hh<=tt)//尾插头删 
    {
        auto t=q[hh++];//弹出头结点 
        for(int i=0;i<4;i++)
        {
            int a=t.x+dx[i];
            int b=t.y+dy[i];
            if(a<1||b<1||a>n||b>n) continue;//越界就结束 
            if(dist[a][b]>=0) continue;
            
            q[++tt]={a,b};//插入新节点
            dist[a][b]=dist[t.x][t.y]+1; 
        }        
    }  
}
int main()//尾插头删
{
    memset(dist,-1,sizeof dist);
    scanf("%d%d%d%d",&n,&m,&a,&b);
    while(a--)
    {//输入感染源位置 
        int c,d;
        scanf("%d%d",&c,&d);
        q[++tt]={c,d};//先入队 
        dist[c][d]=0; 
    }
    bfs();
    
    while(b--)
    {
        int c,d;
        scanf("%d%d",&c,&d);//输入领主位置,直接输出其dist 
        printf("%d\n",dist[c][d]);
    } 
    return 0;
}

矩阵距离

173. 矩阵距离 - AcWing题库

本篛狗不会,直接copy

思路

这道题就是求每一个点距离1的最短曼哈顿距离。

如果我们分别对每一个点求答案的话,肯定会超时,于是我们反向思考,直接从所有的1向整张图搜索。同时更新一下答案。

#include 
#include 
#define x first
#define y second
using namespace std;
typedef pair  PII;
const int N = 1010;
const int dx[] = {0,0,1,-1},dy[] = {1,-1,0,0};
int n,m;
bool g[N][N];
int dist[N][N];
void bfs () {
    queue  q;
    for (int i = 1;i <= n;i++) {
        for (int j = 1;j <= m;j++) {
            if (g[i][j]) q.push ({i,j});
        }
    }
    while (q.size ()) {
        PII t = q.front ();
        q.pop ();
        for (int i = 0;i < 4;i++) {
            int a = t.x + dx[i],b = t.y + dy[i];
            if (a < 1 || a > n || b < 1 || b > m || g[a][b] || dist[a][b]) continue;
            dist[a][b] = dist[t.x][t.y] + 1;
            q.push ({a,b});
        }
    }
}
int main () {
    cin >> n >> m;
    for (int i = 1;i <= n;i++) {
        for (int j = 1;j <= m;j++) {
            char ch;
            cin >> ch;
            g[i][j] = ch - '0';
        }
    }
    bfs ();
    for (int i = 1;i <= n;i++) {
        for (int j = 1;j <= m;j++) cout << dist[i][j] << ' ';
        cout << endl;
    }
    return 0;
}

染色问题

填涂颜色【最大联通子集

P1162 填涂颜色 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

【BFS】学习_第5张图片

乍看可能有点迷糊,但是仔细观察可以发现这题就是把0元素的联通集替换成2;

//这题的思路是把所有能走的0都走一遍且不走1
//那么剩下的没走的且不为1的地方就是需要涂色的点

//同时,会有特殊情况,如果我们从(1,1)开始走
//如果(1,1)正好就是1,那么我们就没法走了
//因此我们从(0,0)开始走,可以保证有一个闭合的0圈
#include 
using namespace std;
#define x first
#define y second
const int N=40;
typedef pair PII;
int n; 
int g[N][N];//存地图 
bool st[N][N];//只需要知道有没有走过就行 
PII q[N*N];
int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
int hh=0;
int tt=-1;
//这题的思路是把所有0都走一遍且不走1
//那么剩下的没走的地方不是1就是需要涂色的点

//同时,会有特殊情况,如果我们从(1,1)开始走
//如果(1,1)正好就是1了,那么我们就没法走了
//因此我们从(0,0)开始走,可以保证有一个闭合的0圈
void bfs(int x,int y)
{//队列尾插头删 
    q[++tt]={x,y};//插入 
    st[x][y]=true; 
    while(hh<=tt)
    {
        auto t=q[hh++];
        for(int i=0;i<4;i++)
        {
            int a=dx[i]+t.x;
            int b=dy[i]+t.y;
            if(a<0||b<0||a>n+1||b>n+1) continue;
            if(st[a][b]) continue;//已经走过了就不走了
            if(g[a][b]!=0) continue;//只走0
            
            q[++tt]={a,b};
            st[a][b]=true;//把所有能走的全都标记 
        }        
    }
    return;//走完了就return 
}
int main() 
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            scanf("%d",&g[i][j]);
        }
    }
    bfs(0,0);
    //涂色
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(!st[i][j]&&g[i][j]!=1) g[i][j]=2;
            //没被访问过同时值不为1就涂色 
        }
    }     
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            printf("%d ",g[i][j]);
        }
        cout<

有外界干扰的迷宫问题【待补充

Meteor Shower S 有外界干扰的迷宫问题

P2895 [USACO08FEB]Meteor Shower S - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

### 关于memset和0x3f
int a[100];
##### memset(a,0x3f,sizeof(a) );
0x3f=0011 1111=63
C++中**int**型变量所占的位数为**4个字节**,即32位
0x3f显然不是int型变量中单个字节的最大值,应该是0x7f=0111 1111 B
**那为什么要赋值0x3f ??**
int

##### 1.作为无穷大使用
因为4个字节均为0x3f时,0x3f3f3f3f的十进制是1061109567,也就是10^ 9级别的(和0x7fffffff一个数量级),而一般场合下的数据都是小于10^9的,所以它可以作为无穷大使用而不致出现数据大于无穷大的情形

##### 2.可以保证无穷大加无穷大仍然不会超限。
另一方面,由于一般的数据都不会大于10^9,所以当我们把无穷大加上一个数据时,它并不会溢出(这就满足了**“无穷大加一个有穷的数依然是无穷大”**),事实上0x3f3f3f3f+0x3f3f3f3f=2122219134,这非常大但却没有超过32-bit int_MAX的表示范围,所以0x3f3f3f3f**还满足了我们“无穷大加无穷大还是无穷大”的需求**。

首先要知道memset函数是**以字节为单位**进行赋值的;
**void *memset(void *s, int ch, size_t n);**
函数解释:将s中前n个字节 (typedef unsigned int size_t )用 ch 替换并返回 s 。
其实这里面的ch就是ascii为ch的字符;
将s所指向的某一块内存中的前n个 字节的内容全部设置为ch指定的ASCII值
#include
using namespace std;
#define xx first
#define yy second
const int N=310;
typedef pair PII;
int m;

int dist[N][N];//记录人走到某个位置的时间
int fire[N][N];//记录流星到达某个位置的时间
PII q[N*N]; 

int dx[]={-1,0,1,0};
int dy[]={0,1,0,-1};
//先输入流星位置,然后入队每个位置,bfs 
//同时用fire保存其落地时间
//bfs搜索人走路的情况,同时用dist记录 
// 如果在某个位置dist==fire就会被砸死,不走
 

int bfs()//模拟人走路的情况 
{
    q[0]={0,0};
    dist[0][0]=0;
    int hh=0,tt=0;
    while(hh<=tt)
    {
        auto t=q[hh++];
        for(int i=0;i<4;i++)
        {
            int a=t.xx+dx[i];
            int b=t.yy+dy[i];
            if(a<0||b<0) continue;
            if(dist[a][b]) continue;
            if(dist[t.xx][t.yy]+1>=fire[a][b]) continue;//会被砸死
             
            dist[a][b]=dist[t.xx][t.yy]+1;
            q[++tt]={a,b};
            if(fire[a][b]>1e9) return dist[a][b];
            //如果有点重复砸,取时间最早的那个 
        }     
    }    
    return -1;
}
int main()
{//尾插头删 
    cin>>m;
    memset(fire,0x3f,sizeof fire);
    while(m--)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        fire[x][y]=min(z,fire[x][y]);
        //直接拓展落点的四个方向
        for(int i=0;i<4;i++)
        {
            int a=x+dx[i];
            int b=y+dy[i];
            if(a<0||b<0||a>301||b>301) continue;
            fire[a][b]=min(fire[a][b],z); 
        }
    } 
    int res=bfs();
    printf("%d",res);
    
    return 0;
}

好难,看看别人写的。

你可能感兴趣的:(算法,宽度优先,学习,算法)