搜索——最短路模型&&多源BFS&&最小步数模型（BFS）

已于 2024-05-22 10:11:36 修改
阅读量80 收藏
点赞数
分类专栏： 搜索 文章标签： 算法 bfs
于 2023-08-28 16:34:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/victor_hq/article/details/132526422
版权

最短路模型&&多源BFS&&最小步数模型

最短路模型

迷宫问题

原题地址

这里是引用

#include<iostream>
#include<algorithm>
#include<string>
#include<string.h>
#include<vector>
#include<queue>
#include<set>
#include<map>
#define int long long
#define fi first
#define se second
#define inf 0x3f3f3f3f
using namespace std;
typedef pair<int,int> pii;
const int N= 1010;
int g[N][N];
int n;
bool st[N][N];
pii pr[N][N];
int dx[]={-1,0,1,0},dy[]={0,1,0,-1};

void bfs(int x,int y){
    queue<pii> q;
    q.push({x,y});
    st[x][y]=true;
    while(q.size()){
        auto t=q.front();
        q.pop();
        for(int i=0;i<4;i++){
            int tx=t.fi+dx[i],ty=t.se+dy[i];
            if(tx<0||tx>=n||ty<0||ty>=n) continue;
            if(g[tx][ty]==1) continue;
            if(st[tx][ty]) continue;
            // if(tx==0&&ty==0){
            //     pr[tx][ty]=t;
            //     break;
            // }这个会过不去，break只是跳出循环，而不是直接退出
            q.push({tx,ty});
            st[tx][ty]=true;
            pr[tx][ty]=t;
        }
    }
}


signed main(){
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    cin>>n;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            cin>>g[i][j];
    bfs(n-1,n-1);
    pii end={0,0};//end(0,0)
    while(!(end.fi==n-1&&end.se==n-1)){
        cout<<end.fi<<" "<<end.se<<endl;
        // end.fi=pr[end.fi][end.se].fi;
        // end.se=pr[end.fi][end.se].se;
        end=pr[end.fi][end.se];//上面代码会tle
    }
    cout<<n-1<<" "<<n-1;
    return 0;
}

debug

1.TLE部分——赋值end.fi的同时把end改变了
2.if 语句会卡，过不去。bfs本质是第一次找到的最小路径（距离），如果用break只是跳出for循环，如果后面还有更长路径能到达终点，那么最短路径就会被更新为后面的那条长些的路径。所以第一次找到后就应该跳出while循环，直接退出函数，用return即可。

总结

  1. PII pair的用法
  2. 求路径的技巧。起点开始，后一个点通过当前 pr数组 信息来获得，最后到达终点停止（看成一个个点移动）

武士风度的牛

原题地址

这里是引用

#include<iostream>
#include<algorithm>
#include<string>
#include<string.h>
#include<vector>
#include<map>
#include<set>
#include<queue>
#define int long long
#define inf 0x3f3f3f3f
#define fi first
#define se second
using namespace std;
typedef pair<int,int> pii;
const int N=200;

char g[N][N];
int dist[N][N];
int n,m;
bool st[N][N];
pii q[N*N];
int dx[8]={-2,-2,-1,1,2,2,1,-1},dy[8]={-1,1,2,2,1,-1,-2,-2};

int bfs(int x,int y){
    
    memset(dist,-1,sizeof dist);
    // queue<pii> q;
    // q.push({x,y});
    int hh=0,tt=0;
    q[0]={x,y};
    dist[x][y]=0;
    st[x][y]=true;
    while(hh<=tt){
        auto t=q[hh++];
        for(int i=0;i<8;i++){
            int fx=t.fi+dx[i],fy=t.se+dy[i];
            if(fx<0||fx>=n||fy<0||fy>=m) continue;
            if(g[fx][fy]=='*') continue;
            if(dist[fx][fy]!=-1) continue;
            if(st[fx][fy]) continue;
            if (g[fx][fy] == 'H') return dist[t.fi][t.se] + 1;//不return会被覆盖
            st[fx][fy]=true;
            q[++tt]={fx,fy};
            dist[fx][fy]=dist[t.fi][t.se]+1;
        }
    }
}

signed main(){
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    cin>>m>>n;
    
    int sx,sy,tx,ty;
    // for (int i = 0; i < n; i ++ ) cin >> g[i];
    
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++)
        {
            cin>>g[i][j];
            if(g[i][j]=='K'){
                sx=i,sy=j;
            }
            if(g[i][j]=='H')
                tx=i,ty=j;
        }
    } 
    cout<<bfs(sx,sy);
    // cout<<dist[tx][ty];答案错误会被覆盖，是先直接return的，还没有更新dist，所以还是-1
    // for(int i=0;i<n;i++){
    //     for(int j=0;j<m;j++)
    //         cout<<dist[i][j]<<" ";
    //     cout<<endl;
    // }
    return 0;
}

debug

  1. 没有return，让while循环一直执行到最后，最后的距离不是最短的，会被覆盖掉。
  2. 返回dist[tx][ty]没有注意细节，因为是先return在更新的，所以终点的dist没有被更新，所以如果输出dist终点的话，会是-1；
  3. 如果不return，会发生Segmentation Fault 错误，内存超了
  4. 用st和dist都可以做判断标记
  5. tx,ty读入的时候逗号写成分号，导致ty不是正确坐标。最后debug半天必须用函数里面的回来，麻了，下次注意，要么就老实写大括号包起来。

总结

  1. bfs是求最短的性质，所以第一个碰到的点肯定是最短了，就直接return就行，切记不要用break，不然可以只是退出for循环。
  2. 用dist当标记数组
  3. 马走法的方法。dx[8]={-2，-2，-1，1，2，2，1，-1}，dy[8]={-1，1，2，2，1，-1，-2，-2}

抓住那头牛

原题链接

这里是引用

#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<set>
#include<map>
#define int long long
#define fi first
#define se second
#define inf 0x3f3f3f3f3f
using namespace std;
typedef pair<int, int>pii;

const int N = 1e5+10;
int n,k;
int dist[N];

int bfs(int x){
    if(x==k) return 0;
    memset(dist,-1,sizeof dist);
    queue<int> q;
    q.push(x);
    dist[x]=0;
    while(q.size()){
        auto t=q.front();
        q.pop();
        if(t==k) return dist[t];
        if(dist[t+1]==-1&&t+1<=N){
            q.push(t+1);
            dist[t+1]=dist[t]+1;
        }
        if(dist[t-1]==-1&&t-1>=0){
            q.push(t-1);
            dist[t-1]=dist[t]+1;
        }
        if(t*2<=N&&dist[2*t]==-1){
            q.push(2*t);
            dist[t*2]=dist[t]+1;
        }
    }
}

signed main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin>>n>>k;
    cout<<bfs(n);
    return 0;
}

总结

这题写得很顺利，对于搜索，关键在于找到搜索的方向，考虑怎么去扩展节点。

模型归纳

  1. bfs有最短的性质，一般第一次搜索到的点就是就有最短的性质，（弹出的队头也是）。如果是双向队列的话，就用第一次弹出的队头，因为第一次放进去的队尾不一定是最短的。
  2. 注意细节，理解标记的作用，体会每次dist是怎么更新的。

多源BFS

矩阵距离

原题链接

这里是引用

#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<set>
#include<map>
#define int long long
#define fi first
#define se second
#define inf 0x3f3f3f3f3f
using namespace std;
typedef pair<int, int>pii;

const int N = 1100;
int n,m;
char g[N][N];
bool st[N][N];
int dist[N][N];
int dx[]={-1,0,1,0},dy[]={0,1,0,-1};
void bfs(){
    memset(dist ,-1,sizeof dist );
    queue<pii> q;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++){
            if(g[i][j]=='1'){
                q.push({i,j});
                dist[i][j]=0;
            }
        }
    
    while(q.size()){
        auto t=q.front();
        q.pop();
        for(int i=0;i<4;i++){
            int tx=t.fi+dx[i],ty=t.se+dy[i];
            if(tx<0||tx>=n||ty<0||ty>=m) continue;
            if(dist[tx][ty]!=-1) continue;
            q.push({tx,ty});
            dist[tx][ty]=dist[t.fi][t.se]+1;
        }
    }
    
}
signed main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin>>n>>m;
    for(int i=0;i<n;i++) cin>>g[i];
    
    bfs();
    
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++){
            cout<<dist[i][j]<<" ";
        }
        cout<<endl;
    }
    return 0;
}

总结

  1. 哈曼顿距离的定义了解一下
  2. 实际是多源点最短路问题，还是利用队列的两段性，将所有源点放进去搜索即可

最小步数模型

模板

原题链接

这里是引用

#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<vector>
#include<queue>
#include<set>
#include<map>
#define int long long
#define fi first
#define se second
#define inf 0x3f3f3f3f3f
using namespace std;
typedef pair<string,char>pii;

const int N = 1100;
string s,ed="12345678";
queue<string> q;
map<string,int> dist;
map<string,pii> pre;

string change(string t,int k){
    string p;
    if(k==0) p={t[7],t[6],t[5],t[4],t[3],t[2],t[1],t[0]};
    if(k==1) p={t[3],t[0],t[1],t[2],t[5],t[6],t[7],t[4]};
    if(k==2) p={t[0],t[6],t[1],t[3],t[4],t[2],t[5],t[7]};
    return p;
}

int bfs(string p){
    q.push(p);
    dist[p]=0;
    while(q.size()){
        auto t=q.front();
        q.pop();
        if(t==s) return dist[t];
        for(int i=0;i<3;i++){
            auto state=change(t,i);
            if(dist.count(state)) continue;
            q.push(state);
            dist[state]=dist[t]+1;
            pre[state]={t,'A'+i};
        }
    }
}

signed main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    for(int i=0;i<8;i++){
        int x;
        cin>>x;
        s+=(x+'0');
    }
    if(s==ed){
        cout<<0;
        return 0;
    }
    cout<<bfs(ed)<<endl;//不能bfs（s），因为题意是要从基本状态开始
    
    string t="",p=s;
    while(true){
        // cout<<p<<"   "<<pre[p].fi<<"  "<<pre[p].se<<endl;
        t+=pre[p].se;
        if(pre[p].fi==ed) break;
        p=pre[p].fi;
    }
    reverse(t.begin(),t.end());
    cout<<t;
    
    
    // string t="",p=ed;
    // while(true){
    //     // cout<<pre[p].fi<<"  "<<pre[p].se<<endl;
    //     t+=pre[p].se;
    //     if(pre[p].fi==s) break;
    //     p=pre[p].fi;
    // }
    // // cout<<t<<endl;
    
    return 0;
}

debug

题目没有看清楚，问的是从标准状态开始的字典序最小，所以要用ed开始搜索。最后注意反转输出就行。

总结

这题还是最短路性质，只不过每次扩展方向是改变的全局，然后就是注意输出路经的方法。

策z
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
BFS 找最短路.cpp
07-23
题解：Bfs找最短路径（正解，绝对正确）这是c++中一道题的题解
DFS&&BFS&&图.pptx
07-26
技术文档分享，免费获取请私信博主。
BFS——多源BFS、最小步数模型
qq_57150526的博客
12-19 360
多源BFS，即同时存在多个起点，然后要求计算出图中任意一个点距离所有起点的最短距离，即图中任意点到每个起点的距离的最小值。BFS最短路模型，所有状态一般都是基于一个点向周围的点扩散的状态。每次只需要保存每次扩散遍历的点的状态即可，整个图本身不变。最小步数模型，每一步都会改变图的状态，此时我们需要保存的是图的状态。只要每一步都是分量相同，则可考虑BFS。
【搜索】—— 多源BFS + 最小步数模型
forever_bryant的博客
07-25 159
【搜索】—— 多源BFS + 最小步数模型
BFS进阶技巧——多源BFS、最小步数模型、双端队列广搜、双向广搜
AKAPinkman的博客
01-31 1621
多源BFS 多源BFS时有从多个源点出发的bfs算法,只需要将多个源点都连一条边权为0的边到虚拟源点,那么问题就等价于从虚拟源点开始BFS。 一开始直接将所有源点加入BFS的队列即可. 矩阵距离 输入样例： 3 4 0001 0011 0110 输出样例： 3 2 1 0 2 1 0 0 1 0 0 1 思路 题意为搜索所有0点到一群1点的最短曼哈顿距离。 将所有为1的点直接加入bfs队列，向外搜索，由bfs性质到达的点一定离虚拟源点最短,而到虚拟源点的距离 == 到1点的距离,故最短。 代码 /*
BFS__FloodFill、最短路、多源BFS、最小步数、双端队列广搜
Zo_ee的博客
05-30 179
每个方块中墙的特征由数字 P 来描述，我们用1表示西墙，2表示北墙，4表示东墙，8表示南墙，P 为该方块包含墙的数字之和。The Knight 的位置用 K 来标记，障碍的位置用 * 来标记，草的位置用 H 来标记。接下来 m 行，每行包含 n 个整数，每个整数都表示平面图对应位置的方块的墙的特征。电子元件的主要部分是一个可旋转的、连接一条对角线上的两个接点的短电缆。对于每组测试数据，在单独的一行输出一个正整数，表示所需的最小旋转次数。其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走。
最短路的四种求法详解+模板
lxt_Lucia的博客
06-08 4352
欢迎访问https://blog.csdn.net/lxt_Lucia～～   宇宙第一小仙女\(^o^)/～～萌量爆表求带飞=≡Σ((( つ^o^)つ~dalao们点个关注呗～～     一.最短路之Floyd算法         Floyd算法虽然时间复杂度不是最短的，但是代码是最简单的最短的啦～   1.介绍 　　floyd算法只有五行代码，代码简单，三个for循环就可以解决...
笔记-----BFS宽度优先搜索
2302_79440616的博客
04-19 1155
对于BFS：宽搜第一次搜到就是最小值，并且基于迭代，不会爆栈。 Flood Fill 模型 如果直译的话就是：洪水覆盖，意思就是像是从一个点一圈圈的往外扩散，如果遇见能够连通的就扩散，如果遇见无法联通的就不去扩散，然后再去以扩散出去的点为起点再去扩散。 Flood Fill 可以实现在线性时间复杂度内找到某个点所在的连通块。 例题： 1.AcWing 1097. 池塘计数 农夫约翰有一片 N∗MN∗MN∗M 的矩形土地。 最近，由于降雨的原因，部分土地被水淹没了。 现在用一个字符矩阵来表示他的土地。 每
宽度优先搜索(BFS)进阶
m0_74176921的博客
12-03 142
从一个起始节点开始把附近与其连通的节点提取出或填充成不同颜色颜色，直到封闭区域内的所有节点都被处理过为止，是从一个区域中提取若干个连通的点与其他相邻区域区分开(或分别染成不同颜色)的经典算法。以下图为例，黄色部分将整个矩形分成了两个连通块，现在我们往第一个联通块里面注水，于是他就会向他的四周开始蔓延，知道整个块都被蔓延完毕。当我们左边这个连通块蔓延完毕之后，我们才会蔓延右边这个连通块。了解完毕这个之后我们来看一道例题加深理解。
BFS（）
m0_74015873的博客
07-22 89
可以用颜色的序列来表示一种魔板状态，规定从魔板的左上角开始，沿顺时针方向依次取出整数，构成一个颜色序列。对于上图的魔板状态，我们用序列 (1,2,3,4,5,6,7,8) 来表示，这是基本状态。你要编程计算用最少的基本操作完成基本状态到特殊状态的转换，输出基本操作序列。一个 N行 M 列的矩阵 BB，相邻两个整数之间用一个空格隔开。如果操作序列的长度大于0，则在第二行输出字典序最小的操作序列。输入仅一行，包括 8 个整数，用空格分开，表示目标状态。输出文件的第一行包括一个整数，表示最短操作序列的长度。
BFS扩展进阶
INGg__的博客
08-19 219
多源BFS 题意 给定一个A矩阵，问所有点到该矩阵的元素为1的点的最短距离是多少 题解 根据BFS的性质，我们知道原本的时候只是将一个起点放进了队列中去，那么现在我们有好多个起点，我们可以把所有的起点都先放进队列中去，然后以每个起点为“山峰”进行Flood-Fill覆盖，某一个点被由某一个起点首先遍历过来的距离就是最短距离了 Code // Problem: 矩阵距离 // Contest: AcWing // URL: https://www.acwing.com/problem/content/des
【团体程序设计天梯赛 往年关键真题 详细分析&完整AC代码】搞懂了赛场上拿下就稳
04-15
紧急救援最短路+路径打印 链表去重模拟链表 月饼贪心 这是二叉搜索树吗?数据结构 集合相似度STL 树的遍历数据结构 家庭房产并查集 最长对称子串字符串 抢红包排序 排座位dfs 玩转二叉树数据结构 关于堆的判断 红色...
数独DFS&BFS.cpp
08-13
在校初学者
【18】输出字符菱形
2301_78786609的博客
07-19 185
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
最新发布
m0_61862494的博客
07-19 102
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 162
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
树与二叉树
2201_76027754的博客
07-15 790
树和二叉树
DFS与BFS在图论中的应用：连通性与最小生成树
"学生课程学习工程图探讨了DFS(深度优先搜索)和BFS(广度优先搜索)在解决图论问题中的应用，包括连通性、拓扑排序和关键路径等概念。此外，还涉及了无向图的连通分量、最小生成树以及普里姆算法的介绍。" 在图论中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值