BFS算法

最新推荐文章于 2024-04-22 09:27:45 发布
最新推荐文章于 2024-04-22 09:27:45 发布
阅读量145 收藏
点赞数
分类专栏： ACM算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55000908/article/details/113488659
版权

简介

  广度优先搜索算法(BFS)，当碰到岔道口时，总是先依次访问从该岔道口能直接到达的所有结点，然后再按这些结点被访问的顺序去依次访问它们能直接到达的所有结点，直到所有结点都被访问为止，类似于树的层次遍历，需要用到队列数据结构。
  （1）先访问完当前顶点的所有邻接点。
  （2）先访问的顶点的邻接点先于后访问顶点的邻接点被访问。

搜索过程

BFS 搜索

程序模板

void BFS(int s)
{
    queue<int> q;
    q.push(s);
    vis[s]=1;
    while(!q.empty()){
    	int top=q.front();
        q.pop();
        访问top,if(满足某种条件) return;
        将top的下一层结点中未曾入队的结点全部入队，并设置为已入队;
    }
}

具体应用

  1. POJ 3278 – Catch That Cow

  给定两个整数n和k，通过 n+1或n-1 或n*2 这3种操作，使得n==k，输出最少的操作次数。

  利用动态规划(DP)解决问题。

  dp[x]表示从N出发到x所需要的最小时间。
  dp[x] = N - x，x <= N
  dp[x] = dp[x-1] + 1，x > N
  dp[x] = min(dp[x], dp[x/2] + 1, dp[x/2+1] + 3)，x > N（当x为偶数的时候）
  dp[x] = min(dp[x], dp[(x-1)/2] + 2, dp[(x+1)/2] + 2)，x>N（当x为奇数的时候）

#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
int N, K;
const int MAX = 100005;
int dp[MAX];
 
int main(){
   
    cin >> N >> K;
    for(int i = 0; i <= K; ++i){
        dp[i] = abs((int)(N - i));
    }
    for(int i = N+1; i <= K; ++i){
        if (i & 1) { // 奇数
            dp[i] = min(dp[i], dp[(i-1)/2] + 2);
            dp[i] = min(dp[i], dp[i-1] + 1);
            dp[i] = min(dp[i], dp[(i+1)/2] + 2);
        }else{
            dp[i] = min(dp[i], dp[i/2] + 1);
            dp[i] = min(dp[i], dp[i-1] + 1);
            dp[i] = min(dp[i], dp[i/2 + 1] + 3);
        }
    }
    cout << dp[K] << endl;
    
    return 0;
}

  利用广度优先搜索(BFS)，已经访问过的数值不再进行下一层的搜索。并进行剪枝，当前要检索的数值为n，其下一层的数值有三个取值n-1,n+1,2*n。设这个取值为temp。当temp<0 或者 temp>maxn 越界，则不管它；temp已经访问过，则不再进行处理。

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int maxn = 100003;

int change (int x, int ch){//0为x-1,1为x+1,2为2*x
    if(ch == 0) return x-1;
    else if(ch == 1) return x+1;
    else return 2*x;//(ch == 2)
}

struct node{
    int num, deep;
    node(int _num, int _deep) : num(_num), deep(_deep) {}
};

bool visit[maxn];

int main()
{
    int n, k;
    
    while(cin >> n >> k){
        memset(visit, false, sizeof(visit));
        
        queue<node> q;
        node u(n, 0);
        
        q.push(u);
        visit[n] = true;
        while (!q.empty()){
            u = q.front();
            q.pop();
            if (u.num == k){
                cout << u.deep << endl;
                break;
            }
            for (int i = 0; i < 3; ++i){
                int temp = change(u.num, i);
                if (temp >= 0 && temp <= maxn && !visit[temp]) {
                    node v(temp,u.deep+1);
                    q.push(v);
                    visit[temp] = true;
                }
            }
        }
    }
    return 0;
}

5 17
4
  1. POJ 2251 Dungeon Master

   一个立体空间， 输入三个数，L，R，C，代表有L个平面，R行，C列，.代表可以走，#代表不能走，S代表开始点，E代表结束点，问从S开始走，对每个位置，有六个走法，即空间的六个方向的走法（上下东南西北)，一分钟可以走一个点，问从S走到E点，最少可以经过多少分钟，若不能到达，则输出Trapped!

#include <iostream>
#include <queue>
using namespace std;
const int maxn = 35;
int L,R,C;
char mmap[maxn][maxn][maxn];
bool vis[maxn][maxn][maxn] = {0};
int dir[6][3] = {{-1,0,0},{1,0,0},{0,1,0},{0,-1,0},{0,0,1},{0,0,-1}};//x y z
struct point{
    int x, y, z;
    int step;
}st,ed;

void bfs(){//cnt统计步数
    memset(vis,0,sizeof(vis));
    queue<point>q;
    point pre,nxt;
    
    vis[st.z][st.x][st.y] = 1;
    st.step = 0;
    q.push(st);
    while(!q.empty()){
        pre = q.front();
        q.pop();
        if(pre.x==ed.x && pre.y==ed.y && pre.z==ed.z){
            cout << "Escaped in " << pre.step << " minute(s)." << endl;
            return;
        }
        for(int i=0; i<6; ++i){
            int nx = pre.x + dir[i][0];
            int ny = pre.y + dir[i][1];
            int nz = pre.z + dir[i][2];
            if(nx>=0 && nx<R && ny>=0 && ny<C && nz>=0 && nz<L && mmap[nz][nx][ny]!='#' && !vis[nz][nx][ny]){
                //也可以写成mmap[nz][nx][ny]=='.'||mmap[nz][nx][ny]=='E' 但不要只写 =='.'
                nxt.x = nx; nxt.y = ny; nxt.z = nz;
                nxt.step = pre.step+1;
                q.push(nxt);
                vis[nz][nx][ny] = 1;
            }
        }
    }
    cout << "Trapped!" << endl;
}

int main()
{
    while(scanf("%d%d%d", &L, &R, &C) && L && R && C){
        for(int i = 0; i < L; ++i){
            for(int j = 0; j < R; ++j){
                scanf("%s", mmap[i][j]);
                for(int k = 0; k < C; ++k){
                    if(mmap[i][j][k] == 'S'){
                        st.x = j; st.y = k; st.z = i;
                    }
                    else if(mmap[i][j][k] == 'E'){
                        ed.x = j; ed.y = k; ed.z = i;
                    }
                }
            }
            getchar();
            getchar();
        }
        bfs();
    }
}

3 4 5
S....
.###.
.##..
###.#

#####
#####
##.##
##...

#####
#####
#.###
####E

1 3 3
S##
#E#
###

0 0 0

Escaped in 11 minute(s).
Trapped!
  1. HDU1240 Asteroids!

  三维的空间里，给出起点和终点，“O”表示能走，“X”表示不能走，计算最少的步数。

#include <iostream>
#include <algorithm>
#include <queue>
#define N 106
#define INF 0x3f3f3f3f
using namespace std;

typedef long long LL;


const int dir[6][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}, {0, 0, -1}, {0, -1, 0}, {-1, 0, 0}};

struct node{
    int x, y, z, step;
}sa, en;

char g[N][N][N];
int vis[N][N][N], n;


int BFS ()
{
    queue <node> que;
    vis[sa.x][sa.y][sa.z] = 1;
    que.push (sa);
    while (!que.empty()){
        node top = que.front();
        que.pop();
        
        if (top.x==en.x && top.y==en.y && top.z==en.z) return top.step;
        for (int i=0; i<6; i++){
            node q = top;
            
            q.x += dir[i][0]; q.y += dir[i][1]; q.z += dir[i][2];
            if (q.x>=0 && q.x<n && q.y>=0 && q.y<n && q.z>0 && q.z<n && !vis[q.x][q.y][q.z] && g[q.x][q.y][q.z]!='X'){
                q.step++;//一层一层从(sa)往外
                vis[q.x][q.y][q.z] = 1;
                que.push (q);
            }
        }
    }
    return -1;
}


int main ()
{
    char str1[10], str2[10];//START,END
    
    while (scanf ("%s %d", str1, &n) != EOF){
        memset (g, 0, sizeof (g));
        
        for (int i = 0; i < n; ++i){
            for (int j = 0; j < n; ++j){
                getchar ();
                for (int k = 0; k < n; ++k)
                    scanf ("%c", &g[i][j][k]);
            }
        }
        scanf ("%d%d%d%d%d%d", &sa.z,&sa.y,&sa.x, &en.z,&en.y,&en.x);
        sa.step = en.step = 0;
        
        scanf ("%s", str2);
        
        int ans = BFS ();
        if (ans != -1) printf ("%d %d\n", n, ans);
        else puts ("NO ROUTE");
    }
    return 0;
}

START 1
O
0 0 0
0 0 0
END
START 3
XXX
XXX
XXX
OOO
OOO
OOO
XXX
XXX
XXX
0 0 1
2 2 1
END
START 5
OOOOO
OOOOO
OOOOO
OOOOO
OOOOO
OOOOO
OOOOO
OOOOO
OOOOO
OOOOO
XXXXX
XXXXX
XXXXX
XXXXX
XXXXX
OOOOO
OOOOO
OOOOO
OOOOO
OOOOO
OOOOO
OOOOO
OOOOO
OOOOO
OOOOO
0 0 0
4 4 4
END

1 0
3 4
NO ROUTE
孤舟独钓寒江雪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BFS算法介绍
Geecky的博客
07-08 1万+
定义： 广度优先算法（Breadth-First-Search），简称BFS，是一种图形搜索演算法。简单的说，BFS是从根节点开始，沿着树的宽度遍历树的节点，如果发现目标，则演算终止。 算法分析: BFS是一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。 时间复杂度：O(|V| +
Bfs算法
cailibuhong的博客
03-28 490
Bfs算法 https://www.2cto.com/kf/201605/509249.html
bfs 算法
qq_40859951的博客
11-10 291
算法思想：https://baike.baidu.com/item/%E5%B9%BF%E5%BA%A6%E4%BC%98%E5%85%88%E7%AE%97%E6%B3%95/5724468?fr=aladdin 例题： 题意：         你的任务是帮助Joe走出一个大火蔓延的迷宫。Joe每分钟可以走到上下左右4个方向的相邻格之一，而所有着火的格子都会往四周蔓延(即如果某个空格与着火...
算法——BFS算法
最新发布
qq_73201597的博客
04-22 686
BFS（广度优先搜索，Breadth-First Search）算法是一种用于图和树等数据结构中进行搜索的基本算法。它从指定的起始节点开始，逐层地向外扩展搜索，直到找到目标节点或遍历完整个图。BFS算法的基本思想是：先访问起始节点，然后依次访问起始节点的邻居节点，再依次访问邻居节点的邻居节点，以此类推，直到搜索到目标节点或者遍历完整个图。BFS算法使用队列来辅助实现节点的遍历顺序，保证每一层的节点按顺序访问。
BFS算法BFS算法BFS算法BFS算法
08-30
### BFS算法概述 BFS算法是一种用于图的查找算法，常用于解决两类问题： 1. **路径存在性问题**：判断从起点A到终点B之间是否存在一条路径； 2. **最短路径问题**：当图中的边没有权重（即所有边的长度相等），BFS...
BFS.zip_Bfs算法_图BFS算法
09-19
**BFS算法详解** 在计算机科学中，图遍历是一种重要的算法，用于探索图的所有节点。其中，广度优先搜索（Breadth-First Search，简称BFS）是一种按照节点的层次顺序遍历图的方法。BFS算法尤其适用于寻找最短路径、...
bfs.rar_Bfs算法_bfs
09-20
总的来说，BFS算法在解决八数码难题这样的问题时，能有效地找到解决方案或判断无解，而`bfs.cpp`的代码实现是理解这一过程的关键。通过学习和理解这段代码，我们可以更深入地掌握BFS的工作原理，并将其应用于其他...
BFS.rar_BFS JAVA_Bfs算法_bfs java_java b
09-24
**标题：“BFS.rar_BFS JAVA_Bfs算法_bfs java_java b”** **描述：“java 数据结构 实现图的广度优先算法”** 在计算机科学中，数据结构和算法是编程的基础，它们决定了程序的效率和性能。在这个压缩包中，重点是...
Python实现BFS算法
07-26
BFS算法的基本思想是通过队列来维护待探索的节点，并按照节点的层级顺序进行探索。 具体描述BFS算法的步骤如下： 将起始节点放入队列中。 从队列中取出一个节点，将其标记为已访问。 遍历该节点的所有相邻节点： ...
BFS算法入门--POJ3984
weixin_34162228的博客
06-22 104
迷宫问题–POJ3984 Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 22008 Accepted: 12848 Description 定义一个二维数组： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0...
BFS 算法
angle0018的博客
06-03 196
一：BFS概念 宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。 ...
BFS-广度优先搜索算法（图）
热门推荐
futurerock的专栏
05-07 7万+
广度优先搜索算法（Breadth-First-Search），又译作宽度优先搜索，或横向优先搜索，简称BFS，是一种图形搜索算法。简单的说，BFS是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。广度优先搜索的实现一般采用open-closed表。特性 空间复杂度因为所有节点都必须被储存，因此BFS的空间复杂度为 O(|V| + |E|)，其中 |V| 是
bfs算法
05-24
BFS（Breadth-First Search）算法是一种基于队列实现的图搜索算法。它从图的起始顶点开始遍历，先访问它的所有直接邻居，然后再访问它的邻居的邻居，依次类推直到遍历完整张图。BFS算法的时间复杂度为O(V+E)，其中V和E分别为图的顶点数和边数。 BFS算法的基本思想是从起始顶点开始，将其加入队列中，然后访问它的所有邻居节点，并将邻居节点加入队列中，标记已访问过的节点。然后从队列中取出一个节点，重复上述操作，直到队列为空。 以下是BFS算法的基本实现： ```python from collections import deque def bfs(start, graph): visited = set() # 记录已访问的节点 queue = deque([start]) # 创建一个队列，并将起始节点加入队列 while queue: # 当队列不为空时，执行以下操作 node = queue.popleft() # 取出队列的第一个节点 if node not in visited: # 如果该节点未被访问过，则执行以下操作 visited.add(node) # 将该节点标记为已访问 neighbors = graph[node] # 获取该节点的所有邻居节点 queue.extend(neighbors) # 将邻居节点加入队列中 return visited # 返回已访问的节点集合 ``` 在上述代码中，start表示起始节点，graph是一个字典，表示图的邻接表。函数返回已访问的节点集合。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值