队列与BFS的常见做法

已于 2022-03-22 22:00:17 修改
阅读量758 收藏 2
点赞数
分类专栏： 数据结构 文章标签： leetcode 算法 数据结构 c# bfs
于 2022-03-22 21:59:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43533956/article/details/123671652
版权
本文介绍了如何运用广度优先搜索（BFS）算法来寻找图中最短路径。通过创建bool数组记录节点状态，使用队列进行层次遍历，更新节点路径长度。分别展示了在不同场景下，如计算房间中最短路径、解锁转盘锁及01矩阵中距离最近0的计算等应用。在实现过程中，队列的数据类型根据问题需求可选择List<int>或List<string>。文章强调了BFS在处理最短路径问题时的有效性和灵活性。
摘要由CSDN通过智能技术生成

广度优先搜索（BFS）的一个常见应用是找出从根结点到目标结点的最短路径。队列非常适合用来处理标准的BFS。

以计算最短路径为例，BFS通常有以下步骤：

  1. 创建一个合适大小的bool数组或哈希表来记录节点是否被遍历过，初始时将所有所有位置置为false；
  2. 创建队列，注意队列的数据类型
  3. 确定起点，并将起点入队，将起点对应位置置为true，路径长度level=1
  4. 当队列不为空时并且没有到达终点时循环以下步骤
  5. 将当前队列长度记为count，出队所有count个元素
  6. 每出队一个节点，依次判断它周围的点是否符合条件
  7. 若符合则入队并将相应位置置为true
  8. level+1，返回第三步

第6步中的条件可能有几种：

  • 数组边界条件，0<=x<length
  • 是否被遍历过
  • 是否是可行的路径
  • 如果节点记录了路径长度，原路径是否已经短于现路径

第5步是如果必须严格按照层次遍历时必须执行的，count记录了本层的元素数量

注意第4步，并不是所有问题都有终点，没有终点时条件仅为队列不空

墙与门

 本题就没有严格遵照以上的第四步，因为每个节点都已经记录了当前最短的路径长度，不需知道当前的层次数，只要比前一层大1就可以了。循环条件也没有终点。

本题队列中的数据是坐标，所以队列数据类型是List<int>

public class Solution {
    public void WallsAndGates(int[][] rooms) {
        List<List<int>> door=new List<List<int>>();
        for(int i=0;i<rooms.Length;i++)
        for(int j=0;j<rooms[0].Length;j++)
        {
            if(rooms[i][j]==0)
            {
                List<int> temp=new List<int>();
                temp.Add(i);
                temp.Add(j);
                door.Add(temp);
            }
        }//得到所有门的坐标
        bool[,] gone=new bool[rooms.Length,rooms[0].Length];
        for(int a=0;a<door.Count;a++)//几个门循环几次
        {
            for(int i=0;i<rooms.Length;i++)
            for(int j=0;j<rooms[0].Length;j++)
            gone[i,j]=false;
            Queue<List<int>> q=new Queue<List<int>>();
            q.Enqueue(door[a]);gone[door[a][0],door[a][1]]=true;
            while(q.Count!=0)
            {
                List<int> index=new List<int>();
                index=q.Dequeue();
                if(index[0]-1>=0&&!gone[index[0]-1,index[1]]&&rooms[index[0]-1][index[1]]!=-1
                &&rooms[index[0]][index[1]]+1<rooms[index[0]-1][index[1]])
                {
                    rooms[index[0]-1][index[1]]=rooms[index[0]][index[1]]+1;
                    List<int> temp=new List<int>();
                    temp.Add(index[0]-1);temp.Add(index[1]);
                    gone[index[0]-1,index[1]]=true;
                    q.Enqueue(temp);
                }
                if(index[0]+1<rooms.Length&&!gone[index[0]+1,index[1]]
                &&rooms[index[0]+1][index[1]]!=-1
                &&rooms[index[0]][index[1]]+1<rooms[index[0]+1][index[1]])
                {
                    rooms[index[0]+1][index[1]]=rooms[index[0]][index[1]]+1;
                    List<int> temp=new List<int>();
                    temp.Add(index[0]+1);temp.Add(index[1]);
                    gone[index[0]+1,index[1]]=true;
                    q.Enqueue(temp);
                }
                if(index[1]-1>=0&&!gone[index[0],index[1]-1]
                &&rooms[index[0]][index[1]-1]!=-1
                &&rooms[index[0]][index[1]]+1<rooms[index[0]][index[1]-1])
                {
                    rooms[index[0]][index[1]-1]=rooms[index[0]][index[1]]+1;
                    List<int> temp=new List<int>();
                    temp.Add(index[0]);temp.Add(index[1]-1);
                    gone[index[0],index[1]-1]=true;
                    q.Enqueue(temp);
                }
                if(index[1]+1<rooms[0].Length&&!gone[index[0],index[1]+1]
                &&rooms[index[0]][index[1]+1]!=-1
                &&rooms[index[0]][index[1]]+1<rooms[index[0]][index[1]+1])
                {
                    rooms[index[0]][index[1]+1]=rooms[index[0]][index[1]]+1;
                    List<int> temp=new List<int>();
                    temp.Add(index[0]);temp.Add(index[1]+1);
                    gone[index[0],index[1]+1]=true;
                    q.Enqueue(temp);
                }
            }
        }
        return;
    }
}

打开转盘锁

这道题实际上就是一个四维图中的最短路径，处理bool数组时把字符串转化为数字比较方便。

C#中字符+数字得到的相应ASCII码值，如'0'+1=49，再进行强制转换可以得到相应字符，

如(char)('0'+1)='1'

本题队列中的数据是字符串，不过为了处理数据的方便，所以队列数据类型是List<string>

public class Solution {
    public int OpenLock(string[] deadends, string target) {
        Queue<List<string>> q=new Queue<List<string>>();
        int num=0;bool arrive=false;
        bool[] gone=new bool[10000];
        for(int i=0;i<10000;i++)
        gone[i]=false;
        string start="0000";
        if(indead(deadends,start))
        return -1;
        List<string> s=new List<string>();
        s.Add(start);q.Enqueue(s);
        while(q.Count!=0&&!arrive)
        {
            num++;int count=q.Count;
            for(int i=0;i<count;i++)
            {
                List<string> temp=new List<string>();
                temp=q.Dequeue();
                for(int j=0;j<temp.Count;j++)
                {
                    if(temp[j]!=target)
                    q.Enqueue(rotate(deadends,temp[j],gone));
                    else
                    {arrive=true;break;}
                }
                if(arrive)
                break;
            }
        }
        if(arrive)
        return num-1;
        else
        return -1;
    }
    public List<string> rotate(string[] deadends,string initial,bool[] gone)
    {
        List<string> res=new List<string>();
        for(int i=0;i<4;i++)
        {
            string temp="";
            for(int j=0;j<4;j++)
            {
                if(j!=i)
                temp+=initial[j];
                else
                {
                if(initial[i]<'9')
                temp+=(char)(initial[i]+1);
                else
                temp+='0';
                }
            }
            if(!gone[Convert.ToInt32(temp)]&&!indead(deadends,temp))
            {
                res.Add(temp);
                gone[Convert.ToInt32(temp)]=true;
            }
            temp="";
            for(int j=0;j<4;j++)
            {
                if(j!=i)
                temp+=initial[j];
                else
                {
                if(initial[i]>'0')
                temp+=(char)(initial[i]-1);
                else
                temp+='9';
                }
            }
            if(!gone[Convert.ToInt32(temp)]&&!indead(deadends,temp))
            {
                res.Add(temp);
                gone[Convert.ToInt32(temp)]=true;
            }
        }
        return res;
    }
    public bool indead(string[] deadends,string str)
    {
        for(int i=0;i<deadends.Length;i++)
        if(deadends[i]==str)
        return true;
        return false;
    }
}

01 矩阵

给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。两个相邻元素间的距离为 1 。

 首先确定起点，看起来0是不用改变，似乎可以从1开始，但是1还分为与0相邻和不相邻两种，其中实际可能有多层，所以起点应该是0结点。

队列中的数据是坐标，所以队列数据类型为List<int>

因为路径长度严格等于层次数，所以，每次出队必须出队所有元素。

public class Solution {
    public int[][] UpdateMatrix(int[][] mat) {
        bool[,] gone=new bool[mat.Length,mat[0].Length];
        Queue<List<int>> q=new Queue<List<int>>();
        for(int i=0;i<mat.Length;i++)
        for(int j=0;j<mat[0].Length;j++)
        {
            if(mat[i][j]==0)
            {
                List<int> index=new List<int>();
                index.Add(i);index.Add(j);
                q.Enqueue(index);
                gone[i,j]=true;
            }
            else
            gone[i,j]=false;
        }
        int level=1;
        while(q.Count!=0)
        {
            int count=q.Count;
            for(int i=0;i<count;i++)
            {
                List<int> index=new List<int>();
                index=q.Dequeue();
                if(index[0]-1>=0&&!gone[index[0]-1,index[1]])
                {
                    List<int> temp=new List<int>();
                    temp.Add(index[0]-1);temp.Add(index[1]);
                    gone[temp[0],temp[1]]=true;
                    mat[temp[0]][temp[1]]=level;
                    q.Enqueue(temp);
                }
                if(index[0]+1<mat.Length&&!gone[index[0]+1,index[1]])
                {
                    List<int> temp=new List<int>();
                    temp.Add(index[0]+1);temp.Add(index[1]);
                    gone[temp[0],temp[1]]=true;
                    mat[temp[0]][temp[1]]=level;
                    q.Enqueue(temp);
                }
                if(index[1]-1>=0&&!gone[index[0],index[1]-1])
                {
                    List<int> temp=new List<int>();
                    temp.Add(index[0]);temp.Add(index[1]-1);
                    gone[temp[0],temp[1]]=true;
                    mat[temp[0]][temp[1]]=level;
                    q.Enqueue(temp);
                }
                if(index[1]+1<mat[0].Length&&!gone[index[0],index[1]+1])
                {
                    List<int> temp=new List<int>();
                    temp.Add(index[0]);temp.Add(index[1]+1);
                    gone[temp[0],temp[1]]=true;
                    mat[temp[0]][temp[1]]=level;
                    q.Enqueue(temp);
                }
            }
            level++;
        }
        return mat;
    }
}

ZEKEGU1997
关注
专栏目录
关于对BFS广度搜索+队列的理解
凡心所向，素履所往，生如逆旅，一苇以航
08-04 6756
1.概念：        广度优先搜索算法（Breadth-First-Search），又译作宽度优先搜索，或横向优先搜索，简称BFS，是一种图形搜索算法。简单的说，BFS是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。广度优先搜索的实现一般采用open-closed表。 2.解析：          如果说DFS（深度优先搜索）靠的是栈，那BFS（广度优先搜索）...
队列与BFS
qq_43604517的博客
01-07 635
一、队列 1.队列的定义 队列是FIFO（先入先出） 数据结构。插入（insert）操作也称作入队（enqueue），新元素始终被添加在队列的末尾。 删除（delete）操作也被称为出队（dequeue)，你只能移除第一个元素。 2.队列的实现 用动态数组实现的队列 **class MyQueue { private: vector<int> data; ...
数据结构与算法——BFS(广度优先搜索)
最新发布
大三计算机在读，分享我的算法之路
08-17 4113
广度优先搜索（Breadth-First Search，简称BFS）是一种遍历或搜索树和图的算法，也称为宽度优先搜索，BFS算法从图的某个节点开始，依次对其所有相邻节点进行探索和遍历，然后再对这些相邻节点的相邻节点进行探索，直到遍历完所有的节点。
bfs 队列的使用
a1204675546的博客
07-24 532
    Plague Inc. is a famous game, which player develop virus to ruin the world. JSZKC wants to model this game. Let's consider the world has N\times MN×M cities. The world has NN rows and MMcolumns...
BFS与队列实现
qq_52750266的博客
06-20 983
队列是一种常见的数据结构，它具有先进先出（FIFO）的特点。在队列中，新的元素总是添加到队列的末尾（称为队尾），而旧的元素总是从队列的前面（称为队头）被移除。队列通常用于在多个线程之间共享数据，或者在算法中执行广度优先搜索等任务。Java中提供了Queue接口来表示队列。Queue接口扩展了Collection接口，提供了专门针对队列操作的方法。
队列与BFS的简单介绍
一只弱渣
03-13 1244
队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列具有先进先出的特点。 如图 当在队列中进行读取操作（front）时，会读取队首元素，也就是元素1，使用pop时删除的也是队首元素，经过front与pop操作，队列会变成 而进...
队列和 BFS —— 栈和 DFS
爱写Bug
08-15 694
队列和 BFS： 广度优先搜索（BFS）的一个常见应用是找出从根结点到目标结点的最短路径。 示例 这里我们提供一个示例来说明如何使用 BFS 来找出根结点 A 和目标结点 G 之间的最短路径。 洞悉 观看上面的动画后，让我们回答以下问题： 1. 结点的处理顺序是什么？ 在第一轮中，我们处理根结点。在第二轮中，我们处理根结点旁边的结点；在第三轮中，我们处理距根结点两步的结点；等等等等。 与树的...
优先队列和bfs算法
02-01
优先队列是一种特殊的队列数据结构，它的特点是每个元素都有一个与之关联的优先级。在优先队列中，元素按照优先级的顺序进行插入和删除操作，而不是按照它们被插入的顺序。常见的实现方式有二叉堆、斐波那契堆等。 ...
BFS常见模板题（初学BFS推荐，附例题由浅入深）
Zhengyangxinn的博客
03-08 2213
本人为一名普通二本学校自动化专业的大二学生，对编程有着少许兴趣。 最近觉得BFS类型题目不太擅长，就在网上查了些资料，写了几道较为基础的BFS题目，想写一篇博客作为学习笔记。希望这篇博客能让你有所收获。 BFS类题目：主要考查对队列（queue）的掌握。 First question：馋嘴羊 BFS思路（可能会比较抽象，建议结合代码理解）： 第一步：输入矩阵、开始吃草位置 第二步：判断开始吃草位...
队列和BFS
roymustang的博客
04-20 223
文章目录广度优先搜索模板练习题 广度优先搜索模板 之前，我们已经介绍了使用 BFS 的两个主要方案：遍历或找出最短路径。通常，这发生在树或图中。正如我们在章节描述中提到的，BFS 也可以用于更抽象的场景中。 模板1 ** * Return the length of the shortest path between root and target node. */ int BFS(Nod...
基于BFS算法的图的遍历设计与实现共24页.pdf.zip
10-31
本主题将深入探讨一种常见的图遍历算法——广度优先搜索（Breadth-First Search，简称BFS）。 **一、BFS算法简介** BFS是一种按照“先访问邻居节点，后访问远距离节点”的顺序遍历图的算法。它的主要特点是使用...
BFS和队列
lllllan
07-12 279
　　深度优先搜索（DFS）和广度优先搜索（BFS）是基本的暴力技术，常用于解决图、树的遍历问题。 　　首先考虑算法思路。以老鼠走迷宫为例： 　　（1）：一只老鼠走迷宫。它在每个路口都选择先走右边，直到碰壁无法继续前进，然后回退一步，这一次走左边，接着继续往下走。用这个办法能走遍所有的路，而且不会重复。这个思路就是DFS。 　　（2）：一群老鼠走迷宫。假设老鼠是无限多的，这群老鼠进去后，在每个路口派出部分老鼠探索没有走过的路。走某条路的老鼠，如果碰壁无法前进，就停下；如果到达的路口已经有其他的老鼠探索过
算法入门到进阶（三）——搜索技术（BFS和队列）
m0_56145255的博客
01-30 911
文章目录BFS和DFS案例：“Rad and Black”题目思路源码运行结果分析总结 BFS和DFS 深度优先搜索（Depth-First Search,DFS）和广度优先搜索（Breadth-First Search，BFS 或称为宽度优先搜索）是基本的暴力技术，常用于解决图，树的遍历问题。 首先考虑算法思路。以老鼠走迷宫为例，这是DFS和BFS在现实中的模型。迷宫内部的路错综复杂，老鼠从入口进去以后怎么才能找到出口呢？有两种不同的方法： 一只老鼠走迷宫。它在每个路口都选择先走右边（当然，选择先走左
bfs中的队列相关函数
让你一生残梦的博客
07-24 433
成员函数： empty()判断队列空，当队列空时，返回true。 size()访问队列中的元素个数。 push()会将一个元素置入queue中。 front()会返回queue内的第一个元素(也就是第一个被置入的元素)。 back()会返回queue中最后一个元素(也就是最后被插入的元素)。 pop()会从queue中移除一个元素。 注意：      pop()虽然会移
暑假学习——队列与BFS
R的博客
08-01 145
BFS和队列，这两种东西的实现方式非常像，以hdu1312为例 此题中我们需要从起点开始，不断向外围扩散，扩散的过程中所有第一次遇到的黑砖都是我们需要记录的对象。 那么就有如下三种解释 第一种图形解释 第二种，树状图形解释 第三种，根据树状图形来的文字解释 起点1入队 ｛1｝ 第一步：1出队，2，3入队 ｛2，3｝ 第二步：2，3出队4 5 6和7 8分别入对｛4，5，6，7，8｝ 第三步：4出 9入 5出10入 6出11入 8出 7出13 12入｛9，10，11，13，12｝ 第四步：1
暑期集训（7） 队列与BFS
m0_55828624的博客
07-12 247
队列与BFS一.队列1.定义2.特点与理解3.五种写法1>手写队列2>STL队列3>小/大根堆优先队列4>普通优先队列5>结构体优先队列4.例题1)合并果子5.模板6.尺取法最短子序列&&队列&&尺取法二.BFS（广搜）1.定义2.模板3.例题1>洪水升级版2>迷宫3>填涂颜色总结 一.队列 1.定义 一种受限制的线性表 我们可以从队列末尾插入一个元素，可以从队列开头删掉一个元素， 也可以查询队列开头是什么 就像在食堂买饭不能插
栈与队列的实现及其应用场景
一键难忘的博客
05-23 1445
栈和队列作为常见的数据结构，在计算机科学中发挥着重要的作用。它们不仅在算法和数据处理中有着广泛的应用，而且在实际的软件开发中也有着丰富的场景。通过深入理解栈和队列的原理和应用，可以帮助我们更好地设计和优化程序，提高代码的效率和可维护性。
BFS - 队列实现模板
泰山与水
03-10 814
每日一练，突破自我，梦想无惧算法！
BFS 队列等
wxyfennie的博客
09-23 463
#include #include using namespace std; class T { public: int x, y, z; T(int a, int b, int c):x(a), y(b), z(c) { } }; bool operator { return t1.z } main() { priority_queue q; q.
BFS+队列JAVA
dadateenager的博客
03-17 459
入坑蓝桥杯,总结了一下BFS的大致模板. BFS的思想就不写了，写一下BFS的实现(队列)。 1.将起点入队。 2.将队首节点可扩展的点入队，如果队首节点没有可扩展的点，将队首节点出队。 3.重复该步骤，直到到达目标位置或者队列为空。 int a[][]=new .....;//表示格子 int dx[]={0,1,0,-1};//横坐标移动方向 下右上左 int dy[]={1,0,-1,0};//纵坐标移动 boolean flag[][]=new .......; for(){
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值