【C++】BFS类型题目总结

已于 2024-04-08 10:34:38 修改
阅读量1.2k 收藏 8
点赞数 1
分类专栏： 数据结构与算法 文章标签： leetcode bfs 算法
于 2021-11-12 01:23:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51064412/article/details/121279775
版权

文章目录

一. FloodFill 系列

1、墙与门

题目连接

题目描述：
在这里插入图片描述
注意：

  • m == rooms.length
  • n == rooms[i].length
  • 1 <= m, n <= 250
  • rooms[i][j] 是 -1、0 或 231 - 1

解题思路：
核心在于用队列把只存门和空房间的位置，把墙排除在外。刚好门的值为0，这样拿出队列里的每一个元素，搜索它的上下左右位置有没有空房间，有的话更新空房间的最近门距离就是该元素的值+1，之后把空房间的位置也入队列，继续拿出队列的下一个元素去更新它周围空房间的值。

  • 遍历数组，把所有门的下标入队列。
  • 依次拿出队列的元素，检查该元素的上下左右位置是否有空房间，有的话空房间的值改为：刚从队列拿出元素的值 + 1，就是该位置空房间的最近的门距离，之后把空房间的下标也入队列。重复前面的动作直到队列为空。

完整代码：

class Solution 
{
private:
    int around[4][2] = 
        {
            {1, 0},
            {-1, 0},
            {0, 1},
            {0, -1}
        };

public:
    void wallsAndGates(vector<vector<int>>& rooms) 
    {
        queue<pair<int, int>> q;
        int m = rooms.size();
        int n = rooms[0].size();
        // 1、先把所有的门都入队列
        for(int i=0; i<m; ++i)
        {
            for(int j=0; j<n; ++j)
            {
                if(rooms[i][j] == 0)
                {
                    q.push(make_pair(i, j));
                }
            }
        }
        // 2、依次拿出队列里的坐标，看看该位置的上下左右是否有空房间
        // 如果有空房间，那么空房间的最近门距离就是该位置的值+1，完成后原来空房间的坐标入队列
        while(!q.empty())
        {
            pair<int, int> pr = q.front();
            q.pop();
            int row = pr.first;
            int col = pr.second;
            for(int i=0; i<4; ++i)
            {
                int newRow = row + around[i][0];
                int newCol = col + around[i][1];
                if(newRow<0 || newRow>=m || newCol<0 || newCol>=n || rooms[newRow][newCol] != INT_MAX)
                {
                    continue;
                }
                rooms[newRow][newCol] = rooms[row][col] + 1;
                q.push(make_pair(newRow, newCol));
            }
        }
    }
};

性能分析：

  • 时间复杂度：O(m*n)。
  • 空间复杂度：O(m*n)。最坏情况全部都是门，全部入队列

2、图像渲染

图像渲染

题目描述：
有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。

给你一个坐标 (sr, sc) 表示图像渲染开始的像素值（行 ，列）和一个新的颜色值 newColor，让你重新上色这幅图像。

为了完成上色工作，从初始坐标开始，记录初始坐标的上下左右四个方向上像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应四个方向上像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为新的颜色值。

最后返回经过上色渲染后的图像。

示例：

输入:
image = [[1,1,1],[1,1,0],[1,0,1]]
sr = 1, sc = 1, newColor = 2
输出:
[[2,2,2],[2,2,0],[2,0,1]]
解析:
在图像的正中间，(坐标(sr,sc)=(1,1)),
在路径上所有符合条件的像素点的颜色都被更改成2。
注意，右下角的像素没有更改为2，
因为它不是在上下左右四个方向上与初始点相连的像素点。

注意：

  • image 和 image[0] 的长度在范围 [1, 50] 内。
  • 给出的初始点将满足 0 <= sr < image.length 和 0 <= sc < image[0].length。
  • image[i][j] 和 newColor 表示的颜色值在范围 [0, 65535]内。

解题思路：
给定一个位置，记该位置颜色为curColor，把这个位置附近的所有这个curColor颜色的区域块染成newColor。典型的单路径BFS，注意搜索前要先把当前位置的颜色染成newColor。

完整代码：

class Solution 
{
private:
    // 控制上下左右四个方向
    int distance[4][4] = 
    {
        {0, 1},
        {1, 0},
        {0, -1},
        {-1, 0}
    };

    int m, n, pColor; //把经常用到的变量设为类的成员变量，这样类的成员函数都能直接拿到

    void bfs(vector<vector<int>>& image, pair<int, int> pr, int color)
    {
        // 一个数据入队列后，记得要把它的颜色改了
        queue<pair<int, int>> q;
        q.push(pr);
        image[pr.first][pr.second] = color;
        while(!q.empty())
        {
            auto [row, col] = q.front();
            q.pop();
            for(int k = 0; k < 4; ++k)
            {
                int newRow = row + distance[k][0];
                int newCol = col + distance[k][1];
                if(newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && image[newRow][newCol] == pColor)
                {
                    image[newRow][newCol] = color;
                    q.push({newRow, newCol});
                }
            }
        }
    }

public:
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) 
    {
        // 0、预处理
        pColor = image[sr][sc];
        if(pColor == color) return image;
        // 1、数据初始化
        m = image.size();
        n = image[0].size();
        // 2、bfs
        bfs(image, make_pair(sr, sc), color);
        // 3、返回值
        return image;
    }
};

性能分析：

  • 时间复杂度：O(n*m)。最坏情况这个矩阵颜色都是curColor。
  • 空间复杂度：O(n*m)。队列的开销。

3、01 矩阵

题目连接

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

两个相邻元素间的距离为 1 。

在这里插入图片描述
在这里插入图片描述
注意：

  • m == mat.length
  • n == mat[i].length
  • 1 <= m, n <= 104
  • 1 <= m * n <= 104
  • mat[i][j] is either 0 or 1
  • mat 中至少有一个 0

解题思路：
多路径源的搜索问题，考虑创建一个超级0来作为搜索时的标识。一开始把原矩阵中所有值为0的下标入队列，然后BFS搜索。

完整代码：

class Solution 
{
    int constExr[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) 
    {
        // 1、创建
        // 最终返回的结果矩阵ret
        // 用来标志多路径源集合的矩阵super，一开始把mat中值为0的下标对应到super中标志为1
        // bfs时用到的存储下标键值对的队列，一开始把所有值为0的下标入队列
        int row = mat.size();
        int col = mat[0].size();
        vector<vector<int>> ret(row, vector<int>(col));
        vector<vector<int>> super(row, vector<int>(col));
        queue<pair<int, int>> q;
        for(int i = 0; i < row; ++i)
        {
            for(int j = 0; j < col; ++j)
            {
                if(mat[i][j] == 0)
                {
                    q.push(make_pair(i, j));
                    super[i][j] = 1;
                }
            }
        }
        // 2、进行多路径的广度优先搜索
        while(!q.empty())
        {
            pair<int, int> front = q.front();
            int i = front.first;
            int j = front.second;
            q.pop();
            for(int d = 0; d < 4; ++d)
            {
                int ni = i+constExr[d][0];
                int nj = j+constExr[d][1];
                if(ni>=0 && ni<row && nj>=0 && nj<col && !super[ni][nj])
                {
                    q.push(make_pair(ni, nj));
                    ret[ni][nj] = ret[i][j] + 1;
                    super[ni][nj] = 1;
                }
            }
        }
        // 返回结果矩阵ret
        return ret;
    }
};

性能分析：

  • 时间复杂度：O(n*m)。最坏情况遍历整个数组。
  • 空间复杂度：O(n*m)。队列的开销。

4、岛屿数量

题目连接

题目描述：
给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

在这里插入图片描述
注意：

  • m == grid.length
  • n == grid[i].length
  • 1 <= m, n <= 300
  • grid[i][j] 的值为 ‘0’ 或 ‘1’

解题思路：
创建一个队列，遍历数组如果遇到岛屿的话ret加一，并把岛屿的值改为’0’和它的下标入队列，如果队列不为空就取出队列的元素，搜索该位置的上下左右是否还有其他岛屿，有的话也同样把岛屿的值改为’0’和它的下标入队列，直到最后队列为空就算排除一座岛屿。

完整代码：

class Solution 
{
private:
    int around[4][2]=
    {
        {1, 0},
        {-1, 0},
        {0, 1},
        {0, -1}
    };

public:
    int numIslands(vector<vector<char>>& grid) 
    {
        int ret = 0;
        queue<pair<int, int>> q;
        int m = grid.size();
        int n = grid[0].size();
        // 1、遍历数组，遇到岛屿ret就加一
        for(int i=0; i<m; ++i)
        {
            for(int j=0; j<n; ++j)
            {
                // 2、遇到岛屿ret就加一，把该岛屿下标入队列，并把其值置为'0'
                if(grid[i][j] == '1')
                {
                    q.push(make_pair(i, j));
                    ++ret;
                    // 搜索入栈岛屿的上下左右位置是否还有其他岛屿，有的话也入队列，把值置为'0'
                    // 直到最后队列为空，就算排除了一座岛屿
                    while(!q.empty())
                    {
                        int row = q.front().first;
                        int col = q.front().second;
                        grid[row][col] = '0';
                        q.pop();
                        for(int k=0; k<4 ;++k)
                        {
                            int newRow = row+around[k][0];
                            int newCol = col+around[k][1];
                            if(newRow<0 || newRow>=m || newCol<0 || newCol>=n || grid[newRow][newCol] != '1')
                            {
                                continue;
                            }
                            grid[newRow][newCol] = '0';
                            q.push(make_pair(newRow, newCol));
                        }
                    }
                }
            }
        }
        return ret;
    }
};

性能分析：

  • 时间复杂度：O(m*n)。
  • 空间复杂度：O(min(m, n))。最坏情况全部是岛屿，因为一次可以排除该位置的上下左右，所以最多队列一次性存储元素的长度为min(m, n)。

5、岛屿的最大面积

题目链接

题目描述
给你一个大小为 m x n 的二进制矩阵 grid 。

岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

岛屿的面积是岛上值为 1 的单元格的数目。

计算并返回 grid 中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

示例一
在这里插入图片描述

示例二
输入：grid = [[0,0,0,0,0,0,0,0]]
输出：0

提示

  • m == grid.length
  • n == grid[i].length
  • 1 <= m, n <= 50
  • grid[i][j] 为 0 或 1

解题思路
每次 bfs 就是去找一块相联的岛屿，在这个过程中统计岛屿的面积

完整代码

class Solution 
{
private:
    int distance[4][4] = 
    {
        {0, 1},
        {0, -1},
        {1, 0},
        {-1, 0}
    };

    int m, n;

    int bfs(vector<vector<int>>& grid, pair<int, int> pr)
    {
        // 第一个岛屿先入队列
        queue<pair<int, int>> q;
        q.push(pr);
        grid[pr.first][pr.second] = 0;
        int count = 1;
        // 合并周围岛屿
        while(!q.empty())
        {
            auto [row, col] = q.front();
            q.pop();
            for(int k = 0; k < 4; ++k)
            {
                int newRow = row + distance[k][0];
                int newCol = col + distance[k][1];
                if(newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && grid[newRow][newCol] == 1)
                {
                    ++count;
                    q.push({newRow, newCol});
                    grid[newRow][newCol] = 0;
                }
            }
        }
        // 返回值
        return count;
    }

public:
    int maxAreaOfIsland(vector<vector<int>>& grid1)
    {
        vector<vector<int>> grid(grid1);
        // 1、数据初始化
        m = grid.size(), n = grid[0].size();
        // 2、数据处理
        int ret = 0;
        for(int i = 0; i < m; ++i)
            for(int j = 0; j < n; ++j)
                if(grid[i][j] == 1)
                    ret = max(ret, bfs(grid, make_pair(i, j)));
        // 3、返回值
        return ret;
    }
};

6、钥匙和房间

题目连接

题目描述：
在这里插入图片描述
解题思路：
最初，除 0 号房间外的其余所有房间都被锁住，我们从0号房间开始搜索，遍历每个房间中其他房间的钥匙，搜索过程中统计可以进入的房间数量并标记每个房间是否已经进入。

完整代码：

class Solution {
public:
    bool canVisitAllRooms(vector<vector<int>>& rooms) 
    {
        // 1、定义了三个对象
        // q：用来进行BFS的存储房间下标的队列
        // count：统计能进入房间的数量
        // vis：标记每个房间是否有被进入过
        queue<int> q;
        int count = 0;
        vector<bool> vis(rooms.size(), false);
        // 2、第0号房间先入队列进行BFS
        q.push(0);
        ++count;
        vis[0] = true;
        while(!q.empty())
        {
            int front = q.front();
            q.pop();
            // 遍历当前房间中其他房间的钥匙
            for(auto e : rooms[front])
            {
                if(!vis[e])
                {
                    q.push(e);
                    ++count;
                    vis[e] = true;
                }
            }
        }
        // 3、最终返回记录的count是否等于总的房间数
        return count == rooms.size();
    }
};

性能分析：

  • 时间复杂度：O(n+m)。n为房间总数，m为所有房间中钥匙的总数。
  • 空间复杂度：O(n)。队列和vis的开销。

7、机器人移动范围

题目连接

题目描述：
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？

输入描述：
一行三个正整数由空格分开，分别代表行数m，列数n，和坐标数位之和的阈值k，0 < m <= 100, 0 < n <= 100, 0 < k <= 20。

输出描述：
一个正整数，代表该机器人能够到达的格子数量。

示例：

输入：
3 3 6
输出：
9

解题思路：
从(0, 0)开始向上下左右四个方向搜索，如果坐标合法、坐标数位之和不大于k，并且没有被访问过就把这个坐标入队列。

完整代码：

#include <queue>
#include <utility>
#include <vector>
#include <iostream>
using namespace std;

// 判断当前格子能否进入
bool IsEnter(int m, int n, int k)
{
  int sum = 0;
  while(m)
  {
    sum += m%10;
    m /= 10;
  }
  while(n)
  {
    sum += n%10;
    n /= 10;
  }
  return sum <= k;
}

int PathRange(vector<vector<bool>>& matrix, int k)
{
  // 1、定义相关对象
  // matrix：标记格子的访问情况
  // count：统计机器人能够达到多少个格子
  // q：进行BFS的存储坐标键值对的队列
  int count = 0;
  queue<pair<int, int>> q;
  // 2、从坐标0,0的格子开始搜索
  if(IsEnter(0, 0, k))
  {
    matrix[0][0] = true;
    ++count;
    q.push(make_pair(0, 0));
  }
  while(!q.empty())
  {
    pair<int, int> front = q.front();
    int m = front.first;
    int n = front.second;
    q.pop();
	// 上下左右四个方向搜索
    if(m-1>=0 && !matrix[m-1][n] && IsEnter(m-1, n, k))
    {
      matrix[m-1][n] = true;
      ++count;
      q.push(make_pair(m-1, n));
    }
    if(m+1<(int)matrix.size() && !matrix[m+1][n] && IsEnter(m+1, n, k))
    {
      matrix[m+1][n] = true;
      ++count;
      q.push(make_pair(m+1, n));
    }
    if(n-1>=0 && !matrix[m][n-1] && IsEnter(m, n-1, k))
    {
      matrix[m][n-1] = true;
      ++count;
      q.push(make_pair(m, n-1));
    }
    if(n+1<(int)matrix[0].size() && !matrix[m][n+1] && IsEnter(m, n+1, k))
    {
      matrix[m][n+1] = true;
      ++count;
      q.push(make_pair(m, n+1));
    }
  }
  // 3、count就是最终到达的格子数
  return count;
}

int main()
{
  int row = 0;
  int col = 0;
  int k = 0;
  cin>>row>>col>>k;
  vector<vector<bool>> matrix(row, vector<bool>(col, false));
  cout<<PathRange(matrix, k)<<endl;
  return 0;
}

性能分析：

  • 时间复杂度：O(m*n)。最多每一个格子都能到达。
  • 空间复杂度：O(m*n)。队列的开销。

8、被围绕的区域


题目链接

题目描述
给你一个 m x n 的矩阵 board ，由若干字符 ‘X’ 和 ‘O’ ，找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。

在这里插入图片描述

示例 2：
输入：board = [[“X”]]
输出：[[“X”]]

提示

  • m == board.length
  • n == board[i].length
  • 1 <= m, n <= 200
  • board[i][j] 为 ‘X’ 或 ‘O’

解题思路
该题因为边界情况比较特殊，直接处理的话不好处理，正难则反，我们先把边界 ’ O ’ 的相联区域用 ’ *’ 都给替换掉，最后再遍历一遍数组：

  • 如果遇到 ’ O ’ ，把它用 ’ X’ 给替换掉
  • 如果遇到 ’ * ’ ，把它还原成 ’ O ’

完整代码

class Solution
{
private:
    vector<vector<int>> distance = 
    {
        {0, 1},
        {0, -1},
        {1, 0},
        {-1, 0}
    };

    int m, n;

    void bfs(vector<vector<char>>& board, int i, int j, char ch)
    {
        // 初始化
        queue<pair<int, int>> q;
        q.push({i, j});
        board[i][j] = ch;
        // bfs
        while(!q.empty())
        {
            auto [row, col] = q.front();
            q.pop();
            for(int d = 0; d < 4; ++d)
            {
                int newRow = row + distance[d][0];
                int newCol = col + distance[d][1];
                if(newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && board[newRow][newCol] == 'O')
                {
                    q.push({newRow, newCol});
                    board[newRow][newCol] = ch;
                }
            }
        }
    }


public:
    void solve(vector<vector<char>>& board) 
    {
        // 1、数据初始化
        m = board.size(), n = board[0].size();
        queue<pair<int, int>> q;
        // 2、bfs 把边界的 'O' 用 'X' 填充
        for(int j = 0; j < n; ++j)
        {
            if(board[0][j] == 'O')     bfs(board, 0, j, '*');
            if(board[m - 1][j] == 'O') bfs(board, m - 1, j, '*');
        }
        for(int i = 0; i < m; ++i)
        {
            if(board[i][0] == 'O')     bfs(board, i, 0, '*');
            if(board[i][n - 1] == 'O') bfs(board, i, n - 1, '*');
        }
        // 3、还原
        for(int i = 0; i < m; ++i)
            for(int j = 0; j < n; ++j)
                if(board[i][j] == 'O') board[i][j] = 'X';
                else if(board[i][j] == '*') board[i][j] = 'O';

    }
};

二. 最短路径问题

1、迷宫中离入口最近的出口

题目链接

题目描述
给你一个 m x n 的迷宫矩阵 maze （下标从 0 开始），矩阵中有空格子（用 ‘.’ 表示）和墙（用 ‘+’ 表示）。同时给你迷宫的入口 entrance ，用 entrance = [entrancerow, entrancecol] 表示你一开始所在格子的行和列。

每一步操作，你可以往 上，下，左 或者 右 移动一个格子。你不能进入墙所在的格子，你也不能离开迷宫。你的目标是找到离 entrance 最近 的出口。出口 的含义是 maze 边界 上的 空格子。entrance 格子 不算 出口。

请你返回从 entrance 到最近出口的最短路径的 步数 ，如果不存在这样的路径，请你返回 -1 。

示例一
在这里插入图片描述

示例二
在这里插入图片描述

提示

  • maze.length == m
  • maze[i].length == n
  • 1 <= m, n <= 100
  • maze[i][j] 要么是 ‘.’ ，要么是 ‘+’ 。
  • entrance.length == 2
  • 0 <= entrancerow < m
  • 0 <= entrancecol < n
  • entrance 一定是空格子。

解题思路
从起始位置开始 bfs，每次把上下左右四个方向能走的位置入队列，然后出的时候，把上一批能走的点位全部出出来，继续重复 bfs，如果谁先走到边界了，谁就是最短路径

完整代码

class Solution 
{
private:
    vector<vector<int>> distance = 
    {
        {0, 1},
        {0, -1},
        {1, 0},
        {-1, 0}
    };

public:
    int nearestExit(vector<vector<char>>& maze, vector<int>& entrance) 
    {
        // 1、数据初始化
        int m = maze.size();
        int n = maze[0].size();
        queue<pair<int, int>> q;
        q.push({entrance[0], entrance[1]});
        vector<vector<bool>> vis(m, vector<bool>(n));
        vis[entrance[0]][entrance[1]] = true;

        // 2、bfs
        int step = 0;
        while(!q.empty())
        {
            ++step;
            for(int i = q.size(); i > 0; --i)
            {
                auto [row, col] = q.front();
                q.pop();
                for(int k = 0; k < 4; ++k)
                {
                    int newRow = row + distance[k][0];
                    int newCol = col + distance[k][1];
                    if(newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && !vis[newRow][newCol] && maze[newRow][newCol] != '+')
                    {
                        if(newRow == 0 || newRow == m - 1 || newCol == 0 || newCol == n - 1) 
                        {
                            // cout << newRow << ':' << newCol;
                            return step;
                        }
                        q.push({newRow, newCol});
                        vis[newRow][newCol] = true;
                    }
                }
            }            
        }

        // 3、走不出去，返回 -1
        return -1;
    }
};
Luojj_2020
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++之bfs算法题汇总
12-28
C++的bfs算法题目汇总，主要是leetcode原题，题目+代码
【刷题日记】BFS 经典题目
白晨的博客
10-04 2197
广度优先搜索（Breadth First Search）简称广搜或者 BFS，概念相对于深度优先搜索。深度优先搜索广度优先搜索可以看到深度优先搜索和广度优先搜索在二叉树的遍历上分别体现为前序遍历和层序遍历。广度优先搜索的思路首先，将开始遍历的结点加入队列，遍历这个结点后，将其孩子结点入队。接着，按照队列的顺序将结点出队，遍历并将其孩子结点入队。重复2过程，直到队列为空。广度优先搜索的优势没有过多的堆栈消耗，耗时少。在求最大或者最小问题时比较好用。
【算法 | 广度优先搜索】5道BFS题（解析+代码）
最新发布
翼同学
03-28 922
我们可以将广度优先搜索理解为“水波扩散”，想象一下，你在一个平静的湖面上扔了一块石头，石头落入水面的那一点，就像是广度优先搜索的起始节点。石头落水后，水面会形成一圈圈扩散开去的波纹，每一圈波纹就像是从起始节点开始，经过相同步数可以到达的所有节点。
【数据结构与算法-搜索（BFS、DFS）系列典例题汇总】
是小武呀
03-21 1211
【数据结构与算法-搜索（BFS、DFS）系列典例题汇总】典例1、岛屿数量（medium）典例2、词语阶梯（medium）典例3、词语阶梯2（hard）典例4、火柴棍摆正方形（medium）典例5、收集雨水（hard） 典例1、岛屿数量（medium） 题目描述： 思路： LeetCode提交OJ测试链接: OJ测试代码实现： 可本地运行测试的完整代码： 典例2、词语阶梯（medium） 题目描述： 思路： LeetCode提交OJ测试链接: OJ测试代码实现
C++数据结构与算法分析——BFS(宽度优先遍历)
l_red_forest的博客
09-13 2541
BFS 介绍 BFS也叫宽度优先遍历，广度优先遍历，宽度优先搜索，广度优先搜索，是一种常用的搜索手段。
bfs常见题型总结
Jefferson__的博客
08-15 1035
文章目录（一）bfs模板题（二）Flood Fill（三）最短路模型（四）多源bfs （一）bfs模板题 题目描述 给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。 最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。 请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。 数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。 输入格式
C++ 算法篇 广度（宽度）优先搜索（BFS）
流年的博客
01-28 8265
广度优先遍历 广度优先遍历(Breadth_First_Search)，又称为广度优先搜索，简称BFS。 图的BFS类似于树的层序遍历。 广度优先遍历 如图将左边的图变形，得到右边的图，然后一层一层的遍历。 这里借助一个队列来实现一层一层的遍历。 邻接矩阵的BFS 核心代码 /** * 邻接矩阵的广度优先遍历算法 */ void BFSTraverse(MGraph G){...
C++算法——BFS（图解）
热门推荐
qq_44616044的博客
09-02 3万+
简介 宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。 相信初次接触的人已经蒙圈了，那么我们先不要探究其代码，直接从这个算法的过程来观察它怎样运算 BFS常用于迷宫，即从一点到另一点...
BFS入门这一篇就够了——C++
枯木何日可逢春
03-13 3750
BFS英文全称是Breadth First Search。 广度优先搜索使用队列（queue）来实现，整个过程也可以看做一个倒立的树形： 1、把根节点放到队列的末尾。 2、每次从队列的头部取出一个元素，查看这个元素所有的下一级元素，把它们放到队列的末尾。并把这个元素记为它下一级元素的前驱。 3、找到所要找的元素时结束程序。 4、如果遍历整个树还没有找到，结束程序。 队列使用详见：STL内...
C++算法：广度优先搜索(BFS)的原理和实现
闻缺陷则喜何志丹
09-28 830
O(m) ,m是边的数量。许多经典应用场景，如2D游戏地图、网格，出边固定不超过4或8(4联通或8联通），这种情况也可以说BFS的时间复杂度是O(n)，n是端点数。每个端点只会访问一次，显然第一次访问的是最小距离，第二次访问时距离只会变大或不变，没有继续访问的意义。假定s到x2的最短最短距离经过x1，如果s到x1距离变大，x1到x2的距离不变，则s到x2的距离变大。
c++宽度优先搜索BFS
zhaoniuniu0309的博客，刚刚开始写博文的新手，有不对的地方请谅解。
07-27 1524
宽度优先搜索，又叫做广度优先搜索，简称宽搜（BFS），是另一种常见搜索算法（还有一种是深搜）。宽搜是一种图的搜索算法，运用非常广泛，也很基础，是每一个编程者必学的算法。因为它是一个很便捷的算法，可拓展性也很高。一些图的最短路算法基本上都是用的是宽搜，或者是基于宽搜。比如Dijstra(求单源最短路径的)，和Prim(最小生成树)。这两个都是比较进阶一点的算法，只有把宽搜学扎实了，才有拓展的可能。总之，宽搜必学！
c++中stack、queue和vector的基本操作示例
12-31
前言 这几天在接触搜索的题目，用bfs时基本都用到队列，就顺便学习了数据结构的栈、队列。本文将详细给大家介绍关于c++中stack、queue和vector的基本操作，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧。 stack 的基本操作有： 入栈，如例：s.push(x); 出栈，如例：s.pop();注意，出栈操作只是删除栈顶元素，并不返回该元素。 访问栈顶，如例：s.top() 判断栈空，如例：s.empty() ，当栈空时，返回true。 访问栈中的元素个数，如例：s.size() 。 queue 的基本操作有： 入队，如例：q.push(x); 将x 接
Leetcode经典01背包-UVA_and_classic_problem:c++写的一些UVA题目的解答以及一些LeetCode的解答
07-01
Leetcode经典01背包UVA Problem This repository include my answer about the UVA exam problem at the same time include some comment and what my thinking about problem 同时还会放入一些经典的问题的解答思考方式。 LeetCode: 70. Climbing Stairs 01. two sum 经典例题： 1. 二维数组查找问题。限制条件为左到右递增，上到下递增。 2. KMP算法实现 UVA problem 100 - The 3n + 1 problem 151 - Power Crisis -> 约瑟夫问题DP 问题 10607 - Joseph's Cousin -> 约瑟夫问题变形 532 - Dungeon Master -> BFS类型的题目 299 - Train Swapping 10038 - Jolly Jumpers 10193 - All You Need Is Love -> 简单题，主要考察最大公约数问题g
DoWalle#algo#752-[双向bfs]-打开转盘锁1
07-25
题目：752. 打开转盘锁执行用时：204 ms, 在所有 C++ 提交中击败了40.14%的用户内存消耗：40.3 MB, 在所有 C++ 提交中击败了25.
【提高】小 X 学游泳(swim)
04-15
题目描述 暑假快到啦，小 X 准备趁着这个暑假去学游泳。可是一开始小 X 就遇到了一个难题。 游泳池划分成了一个 n×mn×m 的方格， 这里 n×mn×m 表示 nn 行 mm 列。 因 为游泳池里的水深浅不一，所以这 n×mn×m 个方格对于小 X 的危险系数也会不一样。 而小 X 目前需要从左上角 的方格（1， 1）出发， 游到右下角 的方格（nn， mm），小 X 每次只 能从当前方格游到上下左右四个相邻的方格中的某一格，并且在到达终点前不能离开游泳池。 小 X 很担心会发生什么危险，所以希望你能帮他找一条危险系数最小的路径。 一条路径的危险系数定义为这条路径所经过的方格的危险系数之和。 注意：这条路径不能经过同一个方格两次（小 X 当然不希望去那么危险的地方再游一次） 输入 输入数据第一行有两个用空格隔开的正整数 n 和 m， 表示泳池的行数和列数。 接下来共有 n 行数据，每行有 m 个用空格隔开的大于等于 0 的整数， 表示每个方格的危险系数 输出 输出仅有一行包含一个整数ans， 表示要求的从左上角的方格（ 1， 1）出发， 游到右下角的方格（n， m） 的最小的危
【BFS】经典例题
SY奇星的OI博客
02-20 590
【BFS】经典例题
c++ bfs搜索详讲
struct_cym的博客
07-18 1368
文章目录一、bfs是什么？二、bfs怎么用？bfs模板简单例题1中等例题2总结 一、bfs是什么？ bfs,广度搜索优先，是层序遍历的一种使用 一般用来求没有边权的情况下的最短路径问题 用队列存储 把题目中的问题情况想象成一颗树（数据类型），根据层次来遍历，找最早时间或路程 一般用队列来完成，比dfs节省很多时间 二、bfs怎么用？ bfs模板 bfs和dfs都是有模板的，一般都是以模板为基础进行编码的 //使用STL中的队列 void BFS() { 首状态结点入队列Q; while (
C++：第十三讲BFS广度优先搜索
喷火龙廖的博客
01-23 2133
今天带领大家学一下BFS。DFS可以看——C++:第十二讲DFS深搜（二）_c++匿名函数dfs-CSDN博客广度优先搜索（breadth-first search，缩写为bfs）又名宽度优先搜索，是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。BFS算法从问题的初始状态（起点）出发，根据状态转换规则（图结构中的边），遍历所有可能的状态（其他节点），直到找到终结状态（终点）。
java 常见算法题 2021
10-20
Java常见的算法题有很多，以下是一些常见的算法题目及其解决方法。 1. 求两个整数的最大公约数和最小公倍数。可以使用辗转相除法来求最大公约数，即不断用较大数除以较小数，直到余数为0，则较小数就是最大公约数。最小公倍数等于两数的乘积除以最大公约数。 2. 数组中找出第K大（小）的数。可以使用快速排序的思想，选取一个基准元素，将数组分为大于基准元素和小于基准元素的两部分，递归地在其中一部分中查找第K大（小）的数。 3. 判断一个字符串是否为回文串。可以使用双指针法，分别从字符串的开头和结尾开始遍历，判断对应字符是否相等，直到两指针相遇或交叉。 4. 实现链表的反转。可以使用迭代或递归的方式，将当前节点的下一个节点指向上一个节点，然后继续遍历链表。 5. 实现二分查找算法。对于有序数组，可以使用二分查找法，在数组的中间位置判断目标值与中间值的大小关系，然后缩小查找范围，直到找到目标值或查找范围为空。 6. 实现图的深度优先搜索（DFS）和广度优先搜索（BFS）。DFS使用递归的方式进行搜索，遍历当前节点的邻接节点，直到遍历完所有节点或找到目标节点。BFS使用队列进行搜索，将当前节点的邻接节点加入队列，并依次出队访问，直到找到目标节点或队列为空。 以上只是一些常见的算法题目，掌握这些算法可以帮助我们更好地理解和解决实际问题。当然，还有许多其他的算法题目，不断学习和练习才能更好地掌握。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值