BFS算法专题

已于 2024-05-26 10:23:08 修改
阅读量831 收藏 15
点赞数 28
分类专栏： 算法 文章标签： 算法 leetcode BFS
于 2024-05-17 11:24:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74126249/article/details/138706050
版权

目录

BFS解决FloodFill算法

一、图像渲染

二、岛屿数量

三、岛屿的最大面积

四、被围绕的区域

BFS解决单源最短路问题

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

二、最小基因变化

三、单词接龙

四、为高尔夫比赛砍树

BFS解决多源最短路问题

一、01矩阵

二、飞地的数量

 三、地图中的最高点

四、地图分析

五、腐烂的苹果

BFS解决拓扑排序问题

一、课程表

二、课程表 II

三、火星字典

BFS解决FloodFill算法

FloodFill算法中文名是洪水灌溉， 本质是在矩阵中找到性质相同的联通块~

一、图像渲染

733. 图像渲染 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/flood-fill/description/1.题目解析

给定起始位置，把与起始位置像素值相同的联通块全部修改成指定颜色， 重复该过程~

2.算法分析

bfs算法，从起始位置开始上下左右往外扩，将像素值相同的点颜色都进行修改，重复该过程

3.算法代码

class Solution {
    typedef pair<int, int> PII;
    //向量数组
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
public:
    vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) 
    {
        int prev = image[sr][sc];
        if(prev == color) return image; //处理边界情况

        int m = image.size(), n = image[0].size(); 

        queue<PII> q;
        q.push({sr, sc});
        while(!q.empty())
        {
            auto [a, b] = q.front();
            q.pop();
            image[a][b] = color;
            for(int i = 0; i < 4; i++) //向四周扩展
            {
                int x = a + dx[i], y = b + dy[i];
                if(x >= 0 && x < m && y >= 0 && y <= n && image[x][y] == prev) //注意防越界
                    q.push({x, y});
            } 
        }
        return image;
    }
};

二、岛屿数量

200. 岛屿数量 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/number-of-islands/1.题目解析

求岛屿的数量， 岛屿是指被水包围的陆地联通块(0表示陆地，1表示水)

2.算法分析

从头开始遍历岛屿，遍历到一个陆地，就用bfs扩展出一个联通块，但是有1个问题，就是扩展到下一层的时候，依旧要上下左右遍历，就会重新扩展回去，因此可以用一个visit数组记录一下，遍历到陆地之后，如果是false, 将visit数组的该位置修改成true即可

3.算法代码

class Solution {
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    int m, n;
    bool vis[301][301];
public:
    int numIslands(vector<vector<char>>& grid) {
        m = grid.size(), n = grid[0].size();
        int ret = 0;
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(grid[i][j] == '1' && !vis[i][j])
                {
                    ret++;
                    bfs(grid, i, j);
                }
            }
        }
        return ret;
    }
    void bfs(vector<vector<char>>& grid, int i, int j)
    {
        queue<pair<int, int>> q;
        q.push({i, j});
        vis[i][j] = true;
        while(q.size())
        {
            auto [a, b] = q.front();
            q.pop();
            for(int k = 0; k < 4; k++)
            {
                int x = a + dx[k], y = b + dy[k];
                if(x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == '1' && !vis[x][y])
                {
                    q.push({x, y});
                    vis[x][y] = true;
                }
            }
        }
    }
};

三、岛屿的最大面积

695. 岛屿的最大面积 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/max-area-of-island/description/1.题目解析

求岛屿的最大面积(岛屿的概念相信题目二已经解释了)

2.算法分析

与题目二基本是完全一样的，区别就是在bfs函数中要求出每块岛屿的面积

3.算法代码

class Solution {
    typedef pair<int, int> PII;
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, -1, 1};
    bool vis[51][51] = {false};
    int m, n;
public:
    int maxAreaOfIsland(vector<vector<int>>& grid) 
    {
        m = grid.size(), n = grid[0].size();
        int ret = 0;
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(grid[i][j] == 1 && !vis[i][j])
                    ret = max(ret, bfs(grid, i, j));
            }
        }
        return ret;
    }

    int bfs(vector<vector<int>>& grid, int i, int j)
    {
        int area = 0; //记录当前岛屿的面积
        queue<PII> q;
        q.push({i, j});
        area++;
        vis[i][j] = true;
        while(!q.empty())
        {
            auto [a, b] = q.front();
            q.pop();
            for(int k = 0; k < 4; k++)
            {
                int x = a + dx[k], y = b + dy[k];
                if(x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 && !vis[x][y])
                {
                    q.push({x, y});
                    area++;
                    vis[x][y] = true;
                }
            }
        }
        return area;
    }
};

四、被围绕的区域

130. 被围绕的区域 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/surrounded-regions/1.题目解析

找到被'x'字符围绕的'o'区域, 将这些'o'改为'x', 注意边界上的o是不能被修改的，与边界'o'直接相连的'o'也是不能被修改的，因为这些'o'区域并不算被'x'字符给包围了

2.算法分析

本题直接使用bfs做是不太方便的，就是因为本题边界'o'的特殊情况

我们可以采用"正难则反"的策略来解决该问题~

先处理矩阵的四条边，把与边上的'o'相连的联通块全部都修改成'.',  然后把矩阵剩余的'o'联通块修改成'x'即可, 同时把边上的'.'联通块还原成 ‘o’ 即可

3.算法代码

class Solution {
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
    int m, n;
public:
    void solve(vector<vector<char>>& board) 
    {
        m = board.size(), n = board[0].size();
        //1.先处理边界上的'O'连通块
        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);
        }

        //2.还原
        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';
    }

    void bfs(vector<vector<char>>& board, int i, int j)
    {
        queue<pair<int, int>> q;
        q.push({i, j});
        board[i][j] = '.';
        
        while (q.size()) 
        {
            auto [a, b] = q.front();
            q.pop();
            for(int k = 0; k < 4; k++) 
            {
                int x = a + dx[k], y = b + dy[k];
                if(x >= 0 && x < m && y >= 0 && y < n && board[x][y] == 'O') 
                {
                    q.push({x, y});
                    board[x][y] = '.';
                }
            }
        }
    }
};

BFS解决单源最短路问题

下面几道题目都是边权为1的最短路问题，边权为1(边权一样的最短路问题也归到该类问题) 是最短路问题的一种，所以代码都是大同小异的！

ps: bfs解决最短路问题都是只能解决边权为1的最短路问题~

解法: 从起点开始来一次bfs即可

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

1926. 迷宫中离入口最近的出口 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/nearest-exit-from-entrance-in-maze/1.题目解析

给定起始点，'+'表示墙，'.'表示空格，位于边上的'.'都是出口，求从起点到出口的最短步数

ps: 位于边上的起始点不能算出口

2.算法分析

bfs解决最短路问题

3.算法代码

class Solution {
    //向量数组
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
public:
    int nearestExit(vector<vector<char>>& maze, vector<int>& e) 
    {
        int m = maze.size(), n = maze[0].size();
        bool visit[m][n]; //记录遍历过的点
        memset(visit, 0, sizeof(visit)); //将visit数组初始化成false

        queue<pair<int, int>> q;
        q.push({e[0], e[1]}); //让入口点入队列
        visit[e[0]][e[1]] = true;
        int step = 0; //记录扩展的层数，也就是从起点到出口的最短距离
        while(!q.empty())
        {
            step++;
            int sz = q.size();
            for(int i = 0; i < sz; i++) //让sz个元素出队列
            {
                auto [a, b] = q.front();
                q.pop();
                for(int j = 0; j < 4; j++)
                {
                    int x = a + dx[j], y = b + dy[j];
                    if(x >= 0 && x < m && y >= 0 && y < n && maze[x][y] == '.' && !visit[x][y])
                    {
                        if(x == 0 || x == m-1 || y == 0 || y == n-1) //判断是否到达出口
                            return step;
                        q.push({x, y});
                        visit[x][y] = true;
                    }
                }
            }
        }
        return -1;
    }
};

二、最小基因变化

433. 最小基因变化 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/minimum-genetic-mutation/1.题目解析

给定起始基因序列和最终基因序列(都是八个字符, 从"ACGT"挑选)， 每次变化只能变一个字符, 变成的字符依旧是"ACGT", 求最少变化次数

2.算法分析

将问题转化成边权为1的最短路问题

1.把起始基因序列看成起点, 把最终基因序列看成终点, 本质就是求起点到终点的最短路

2.由于变化后的基因序列要在基因库中，因此我们可以提前把基因序列加入哈希表中

3.求变化后的字符串，可以先定义字符串string change = "ACGT",  然后将队头字符串每个字符改成change中的字符即可，但是要注意需要先保存队头字符串，否则队头字符串发生的就不是一次基因变换了！

3.算法代码

class Solution 
{
public:
    int minMutation(string startGene, string endGene, vector<string>& bank)
    {
        unordered_set<string> hash(bank.begin(), bank.end()); //将基因库中的基因序列存入哈希表中
        unordered_set<string> visit; //记录变化过的基因序列
        string change = "ACGT";

        if(startGene == endGene) return 0;
        if(!hash.count(endGene)) return -1;

        queue<string> q;
        q.push(startGene);
        visit.insert(startGene);

        int ret = 0;
        while(q.size())
        {
            ret++;
            int sz = q.size();
            while(sz--)
            {
                string t = q.front();
                q.pop();
                for(int i = 0; i < 8; i++)
                {
                    string tmp = t;
                    for(int j = 0; j < 4; j++)
                    {
                        tmp[i] = change[j];
                        if(hash.count(tmp) && !visit.count(tmp))
                        {
                            if(tmp == endGene) return ret;
                            q.push(tmp);
                            visit.insert(tmp);
                        }
                    }
                }
            }
        }
        return -1;
    }
};

三、单词接龙

127. 单词接龙 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/word-ladder/1.题目解析

本题和题目二本质一样，不过求的是变化过程中的单词数目, 所以要给变化的次数+1

2.算法分析

注意与题目二的不同即可，比如无法变成最终单词返回0，起始单词和最终单词相等返回1

3.算法代码

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) 
    {
        unordered_set<string> hash(wordList.begin(), wordList.end());
        unordered_set<string> visit;

        if(beginWord == endWord) return 1;
        if(!hash.count(endWord)) return 0;

        queue<string> q;
        q.push(beginWord);
        visit.insert(beginWord);
        int ret = 1;
        while(!q.empty())
        {
            ret++;
            int sz = q.size();
            while(sz--)
            {
                string t = q.front();
                q.pop();
                for(int i = 0; i < t.size(); i++)
                {
                    string tmp = t;
                    for(char ch = 'a'; ch <= 'z'; ch++)
                    {
                        tmp[i] = ch;
                        if(hash.count(tmp) && !visit.count(tmp))
                        {
                            if(tmp == endWord) return ret;
                            q.push(tmp);
                            visit.insert(tmp);
                        }
                    }
                }
            }
        }
        return 0;
    }
};

四、为高尔夫比赛砍树

675. 为高尔夫比赛砍树 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/cut-off-trees-for-golf-event/1.题目解析

给定一个矩阵，1表示地面，0表示障碍物，大于1的数字表示树的高度，从左上角开始砍树，每次可以上下左右四个方向移动，每次砍到一棵树后该位置就变成地面，但是要求砍树的顺序是树高从小到大，求砍完所有树需要的最少步骤

2.算法分析

问题的本质就是若干次迷宫问题(题目一), 因为要按照树的高度砍树，所以我们需要提前把树的位置(横纵坐标)按照树高从小到大存入到vector中,  问题就转化成了从起点到vector中的每个位置(终点位置)的最短路问题(dfs), 一次dfs之后，将起始位置更新成刚才的终点位置即可

3.算法代码

class Solution {
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    int m, n;
public:
    int cutOffTree(vector<vector<int>>& f) 
    {
        //1.确定砍树顺序
        m = f.size(), n = f[0].size();
        vector<pair<int, int>> trees; 
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(f[i][j] > 1) trees.push_back({i, j});    
        sort(trees.begin(), trees.end(), [&](const pair<int, int>& p1, const pair<int, int>& p2)
        {
            return f[p1.first][p1.second] < f[p2.first][p2.second];
        });

        //2.按照顺序砍树, 转化成若干次迷宫问题
        int bx = 0, by = 0; //起始位置
        int ret = 0; //最终结果
        for(auto& [a, b] : trees)
        {
            int step = bfs(f, bx, by, a, b); //step记录每一次bfs的结果
            if(step == -1) return -1;
            ret += step;
            bx = a, by = b; //更新起始位置
        }
        return ret;
    }

    int bfs(vector<vector<int>>& f, int bx, int by, int ex, int ey) //ex, ey记录最终位置
    {
        if(bx == ex && by == ey) return 0; 
        queue<pair<int, int>> q;
        bool visit[51][51] = {false};
        q.push({bx, by});
        visit[bx][by] = true;
        int step = 0;
        while(!q.empty())
        {
            step++;
            int sz = q.size();
            for(int i = 0; i < sz; i++)
            {
                auto [a, b] = q.front();
                q.pop();
                for(int j = 0; j < 4; j++)
                {
                    int x = a + dx[j], y = b + dy[j];
                    if(x >= 0 && x < m && y >= 0 && y < n && f[x][y] != 0 && !visit[x][y])
                    {
                        if(x == ex && y == ey)  return step;
                        q.push({x, y});
                        visit[x][y] = true;
                    }
                }
            }
        }  
        return -1;
    }
};

BFS解决多源最短路问题

单源最短路问题是指只有1个起点和一个终点，而多源最短路问题是有若干个起点的，终点也是只有1个, 求某个起点到终点的最短路~

解法：

1.暴力解法: 从每个起点到终点都进行单源bfs,  求这些路中的最短路(大概率超时)

2.把所有的"源点"变成一个"源点", 问题就转化成了单一的"单源最短路"问题, 一次bfs就解决问题

感性理解: A往外扩会先扩到B, C这一层，因此从A出发到H一定不是最短路，因此我们可以将A, B, C全部等效成一个点即可

一、01矩阵

542. 01 矩阵 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/01-matrix/description/1.题目解析

给定一个01矩阵，返回一个同等规模的矩阵，每个元素是原矩阵的该位置离最近的0的距离

2.算法分析

解法一:一个位置一个位置求(超时)

解法二: 多源BFS+正难则反

如果直接用多源BFS， 也就是把所有的1看成一个点，找到离最近的0的距离，但问题是无法知道该距离是哪一个1到0的最短距离，而且无法退回去填表，因此采用正难则反的策略

把所有的0当成起点，1当成终点，分为两步:

1.将所有值为0的位置(横纵坐标)加入到队列中

2.一层一层的向外扩展即可

ps:单源最短路中，我们用到了visit矩阵标记元素是否访问过，step变量记录扩展的层数，size变量记录每次多少元素出队列，而本题中这三个都可以不要，都可以借助最终要求的dist矩阵来解决, 把dist矩阵初始化成-1，表示元素没有访问过，而step和sz变量也都不需要了，因为我们一边扩展，一边填dist矩阵，dist矩阵中存储了扩展到第几层了并且记录了从起点到该位置的最短记录，因此我们并不需要一层一层往外扩展，也就不需要size变量与step变量了~

3.算法代码

class Solution 
{
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, -1, 1};
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& mat)
    {
        int m = mat.size(), n = mat[0].size();
        vector<vector<int>> dist(m, vector<int>(n, -1));
        queue<pair<int, int>> q;
        //1.将所有的源点加入到队列中
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(mat[i][j] == 0)
                {
                    q.push({i, j});
                    dist[i][j] = 0;
                }
            }
        }
        //2.往外扩展
        while(q.size())
        {
            auto [a, b] = q.front();
            q.pop();
            for(int i = 0; i < 4; i++)
            {
                int x = a + dx[i], y = b + dy[i];
                if(x >= 0 && x < m && y >= 0 && y < n && dist[x][y] == -1)
                {
                    dist[x][y] = dist[a][b] + 1; //dist[a][b]已经存储了从起始位置到a, b的最短距离，而[a, b]可以一步到[x, y], 因此直接+1即可
                    q.push({x, y});
                }
            }
        }
        return dist;
    }
};

二、飞地的数量

1020. 飞地的数量 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/number-of-enclaves/1.题目解析

给定矩阵单元格，1表示陆地，0表示海洋, 每次可以上下左右移动一格,  求无法走出整个矩阵单元格的陆地的数量

2.算法分析

解法一: 一个位置一个位置去判断，也就是对于每个1都进行bfs, 看是否能走出单元格(超时)

优化: 利用visit数组，从某个位置出发进行bfs, 如果能走出单元格，那就再从刚才的位置来一次bfs, 将遍历到的值为1的单元格标记一下； 如果不能走出单元格，那就再从刚才的位置来一次bfs, 将遍历到的值为1的单元格用另一种方式标记一下；最终再遍历一次原始矩阵，统计值为1且没有被访问的单元格数量即可！

缺陷: 要进行两次bfs, 并且代码不太一样

解法二: 正难则反 + 多源bfs

从边界的1开始进行多源bfs，用数组visit标记访问过的单元格，多源bfs完成之后，所有和边界1相连的单元格的visit数组对应位置都被标记成了true, 此时再遍历一遍原始矩阵，统计值为1且没有被访问的单元格数量即可！

3.算法代码

解法二:

class Solution 
{
    bool visit[501][501];
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
public:
    int numEnclaves(vector<vector<int>>& grid) 
    {
        int m = grid.size(), n = grid[0].size();
        queue<pair<int, int>> q;
        //1.将边界的1加入队列
        for(int j = 0; j < n; j++)
        {
            if(grid[0][j] == 1)  //第1行
            {
                q.push({0, j});
                visit[0][j] = true;
            }
            if(grid[m-1][j] == 1) //最后一行
            {
                q.push({m-1, j});
                visit[m-1][j] = true;
            }
        }
        for(int i = 0; i < m; i++) 
        {
            if(grid[i][0] == 1) //第一列
            {
                q.push({i, 0});
                visit[i][0] = true;
            }
            if(grid[i][n-1] == 1) //最后一列
            {
                q.push({i, n-1});
                visit[i][n-1] = true;
            }
        }
        //2.多源bfs
        while(!q.empty())
        {
            auto [a, b] = q.front();
            q.pop();
            for(int i = 0; i < 4; i++)
            {
                int x = a + dx[i], y = b + dy[i];
                if(x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 && !visit[x][y])
                {
                    q.push({x, y});
                    visit[x][y] = true;
                }
            }
        }
        //3.统计结果
        int ret = 0;
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(grid[i][j] == 1 && !visit[i][j])
                    ret++;
        return ret;
    }
};

 三、地图中的最高点

1765. 地图中的最高点 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/map-of-highest-peak/1.题目解析

给定矩阵，1代表水域，0代表陆地，现在要求我们给每个格子设定高度，要求水域高度为0，相邻的格子(上下左右)高度差不超过1，求最终安排的矩阵中的的最高单元格的高度

2.算法分析

由于水域高度是固定的，因此我们可以先把水域高度都填成0，然后向外扩展，由于最终要高度最高，因此向外扩展时，把所有的单元格高度都设置成1即可，继续向外扩展，设置成2即可，因此本题解法也是多源bfs, 所以本题的代码和题目一"01矩阵"基本一模一样

3.算法代码

class Solution {
    int dx[4] = {0, 0, 1, -1};
    int dy[4] = {1, -1, 0, 0};
public:
    vector<vector<int>> highestPeak(vector<vector<int>>& isWater) 
    {
        int m = isWater.size(), n = isWater[0].size();
        vector<vector<int>> dist(m, vector<int>(n, -1));
        queue<pair<int, int>> q;
        //1.将所有的源点加入到队列中
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(isWater[i][j] == 1)
                {
                    dist[i][j] = 0;
                    q.push({i, j});
                }
            }
        }
        //2.多源bfs
        while(q.size())
        {
            auto [a, b] = q.front();
            q.pop();
            for(int i = 0; i < 4; i++)
            {
                int x = a + dx[i], y = b + dy[i];
                if(x >= 0 && x < m && y >=0 && y < n && dist[x][y] == -1)
                {
                    dist[x][y] = dist[a][b] + 1;
                    q.push({x, y});
                }
            }
        }
        return dist;
    }
};

四、地图分析

1162. 地图分析 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/as-far-from-land-as-possible/1.题目解析

给定矩阵，0表示海洋，1表示陆地，求海洋距离最近的陆地的最大距离

2.算法分析

可以从陆地(填成0)出发，向外扩展(+1), 返回扩展结束的数字即可，本质是bfs问题， 所以本题的代码和题目一"01矩阵"基本一模一样

3.算法代码

class Solution {
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
public:
    int maxDistance(vector<vector<int>>& grid) 
    {
        int m = grid.size(), n = grid[0].size();
        vector<vector<int>> dist(m, vector<int>(n, -1));
        queue<pair<int, int>> q;
        //1.将所有的源点加入到队列中
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(grid[i][j] == 1)
                {
                    dist[i][j] = 0;
                    q.push({i, j});
                }
            }
        }
        //2.多源bfs
        int ret = -1; //保存最大值
        while(q.size())
        {
            auto [a, b] = q.front();
            q.pop();
            for(int i = 0; i < 4; i++)
            {
                int x = a + dx[i], y = b + dy[i];
                if(x >= 0 && x < m && y >=0 && y < n && dist[x][y] == -1)
                {
                    dist[x][y] = dist[a][b] + 1;
                    q.push({x, y});
                    ret = max(ret, dist[x][y]);
                }
            }
        }
        return ret;
    }
};

五、腐烂的苹果

腐烂的苹果_牛客题霸_牛客网 (nowcoder.com)icon-default.png?t=N7T8https://www.nowcoder.com/practice/54ab9865ce7a45968b126d6968a77f34?tpId=196&tqId=40529&ru=/exam/oj1.题目解析

0表示格子为空，1表示苹果完好，2表示苹果腐烂,  每一分钟腐烂的苹果都会将四周扩展，将完好的苹果变腐烂，问

2.算法分析

多源bfs求最短路即可

法一: 每次向外扩展后腐烂一个苹果，就把该苹果位置的值修改为2

法二:不修改原始矩阵，定义bool矩阵标记扩展过程中腐烂的苹果

3.算法代码

法一:

class Solution {
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, -1, 1};
public:
    int rotApple(vector<vector<int>>& grid)
    {
        int m = grid.size(), n = grid[0].size();
        queue<pair<int, int>> q;
        //1.将所有的源点加入到队列中
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(grid[i][j] == 2)
                    q.push({i, j});
    
        //2.bfs
        int ret = 0; //记录扩展了多少层
        while(q.size())
        {
            ret++;
            int sz = q.size();
            for(int i = 0;i < sz; i++)
            {
                auto [a, b] = q.front();
                q.pop();
                for(int j = 0; j < 4; j++)
                {
                    int x = a + dx[j], y = b + dy[j];
                    if(x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1)
                    {
                        grid[x][y] = 2;
                        q.push({x, y});
                    }
                }
            }
        }
        
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(grid[i][j] == 1)
                    return -1;
        return ret - 1; //注意,最后相当于多扩展了一层，因此要-1
    }
};

法二:

class Solution {
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, -1, 1};
    bool visit[1001][1001];
public:
    int rotApple(vector<vector<int>>& grid)
    {
        int m = grid.size(), n = grid[0].size();
        queue<pair<int, int>> q;
        //1.将所有的源点加入到队列中
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(grid[i][j] == 2)
                    q.push({i, j});
    
        //2.bfs
        int ret = 0; //记录扩展了多少层
        while(q.size())
        {
            ret++;
            int sz = q.size();
            for(int i = 0;i < sz; i++)
            {
                auto [a, b] = q.front();
                q.pop();
                for(int j = 0; j < 4; j++)
                {
                    int x = a + dx[j], y = b + dy[j];
                    if(x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == 1 && !visit[x][y])
                    {
                        visit[x][y] = true;
                        q.push({x, y});
                    }
                }
            }
        }
        
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(grid[i][j] == 1 && !visit[i][j])
                    return -1;
        return ret - 1; //注意,最后相当于多扩展了一层，因此要-1
    }
};

BFS解决拓扑排序问题

在分享下面几道题目前，应该先弄懂几个概念: 有向无环图(DAG图)， AOV网(是DAG图的具体应用，点表示活动，边的方向表示活动的先后顺序),  拓扑排序(找到活动的先后顺序)， 下面简单介绍一下拓扑排序的过程和实现

拓扑排序过程:

1.找到图中入度为0的点，然后输出

2.删除与该点连接的边

3.重复1、2操作，直到图中没有点为止或者没有入度为0的点为止

因为图中可能有环，所以删除到只剩下这个环时，此时没有入度为0的点了，但图中还有点，说明是个环，拓扑排序也就结束了!!!

所以拓扑排序的一个重要应用: 判断有向图是否有环

ps：由上图也可以看出，由于某一时刻入度为0的点不一定只有1个，选任意一个都可以，因此拓扑排序的结果不是唯一的

拓扑排序实现:

1.把所有入度为0的点加入队列中

2.当队列不为空的时候:

2.1 拿出队头元素，加入到最终结果中

2.2.删除与该元素相连的边

2.3 判断与删除边相连的点，是否入度变为0， 如果入度为0，加入到队列中

一、课程表

207. 课程表 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/course-schedule/1.题目解析

抽象一下题目:

给定一个数组，数组的每个元素是一个包含两个元素的数组，其中[a, b]表示，b发生之后才能发生a, 问最终能否将所有的活动排好序进行

2.算法分析

本质就是建立有向图，用拓扑排序判断图中是否有环即可，如何用拓扑排序上文已经介绍了，所以关键就是如何建图

建图有两种方式: 本文主要介绍邻接表

1.邻接矩阵(主要用于稠密图)

2.邻接表(主要用于稀疏图)

3.算法代码

class Solution 
{
public:
    bool canFinish(int n, vector<vector<int>>& prerequisites) 
    {
        //1.准备工作
        unordered_map<int, vector<int>> edges; //邻接表
        vector<int> in(n); //存储每一个节点的入度
        //2.建图
        for(auto& e : prerequisites)
        {
            int a = e[0], b = e[1];
            edges[b].push_back(a); //b->a
            in[a]++; //a的入度++
        }
        //3.拓扑排序
        queue<int> q;
        //3.1 把所有入度为0的点加入队列
        for(int i = 0; i < n; i++)
            if(in[i] == 0) q.push(i);
        //3.2 bfs
        while(q.size())
        {
            int t = q.front();
            q.pop();
            for(auto a : edges[t]) //edges[t]是t所连接的所有点构成的数组
            {
                in[a]--; //将t连接的点的入度--(本质就是删除了与t相连的边)
                if(in[a] == 0) q.push(a); //删除之后, 将入度为0的点加入队列
            }
        }
        //4.判断是否有环
        for(int i = 0; i < n; i++)
            if(in[i]) return false; //还有点入度不为0, 表示有环, 返回false
        return true;    
    }  
};

二、课程表 II

210. 课程表 II - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/course-schedule-ii/description/1.题目解析

抽象题目:

如果没有环，输出拓扑排序的结果即可

2.算法分析

见题目一

3.算法代码

class Solution {
public:
    vector<int> findOrder(int n, vector<vector<int>>& prerequisites) 
    {
        //1.准备工作
        unordered_map<int, vector<int>> edges;
        vector<int> in(n);

        //2.建图
        for(auto& e : prerequisites)
        {
            int a = e[0], b = e[1];
            edges[b].push_back(a);
            in[a]++;
        }

        //3.拓扑排序
        queue<int> q;
        vector<int> ret; //记录最终结果
        for(int i = 0; i < n; i++)
            if(in[i] == 0) q.push(i);
        while(q.size())
        {
            int t = q.front();
            q.pop();
            ret.push_back(t);
            for(auto a : edges[t])
            {
                in[a]--;
                if(in[a] == 0) q.push(a);
            }   
        }
        //4.判断是否有环
        if(ret.size() == n)
            return ret;
        return {};
    }
};

三、火星字典

LCR 114. 火星词典 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/Jf1JuT/description/1.题目解析

给定一个字符串数组，数组每个元素是一个单词，火星上的英文字母顺序和我们地球上的字母顺序不一样，数组中的英文单词就是按照字母顺序给出的，现要求根据给定的字符串数组，给出数组中出现过的英文字母的顺序, 如果不存在合法顺序，返回空串即可

2.算法分析

本题的本质仍然是拓扑排序，而拓扑排序前必须先有图，但难点是如何从题目给定字符串数组中统计出字母顺序的信息，从而能建出图
1. 两层 for循环遍历数组，收集信息（确定出字母的先后顺序），建图
ps: 收集信息时，采用对应字母比较的方式
比如比较: "wrt"与 "wrf"时，依次比较'w'与'w', 'r'与'r',  比较 't'与'f'不相等，于是确定t->f
但是要特殊处理下面这种特殊情况:
"abc"  vs  "ab"，无论火星上的字母顺序如何，都不可能出现"abc"排在"ab"之前的情况，因此不存在合法顺序，直接返回空串
2. 由于本题图的顶点不是数字，而是字母，因此我们选择创建哈希表来存图，而两层for循环遍历的时候，可能会统计冗余信息，比如

比较 "wrf" 与 "er" 和 比较 "wrf" 与 "ett" 时，都能得出 w->e 的信息，但是不能重复存储在图中，因此我们创建哈希表中的value也是一个哈希表： unordered_map<char, unordered_set<char>> hash;
3. 用哈希表统计入度信息 unordered_map<char, int> in;
ps: 必须初始化哈希表，遍历words数组，每遇到一个字母，就将入度初始化成0

3.算法代码
 

class Solution 
{
    unordered_map<char, unordered_set<char>> edges; //邻接表存储图
    unordered_map<char, int> in; //统计每个节点的入度
    bool check; //标记收集信息时的特殊情况
public:
    string alienOrder(vector<string>& words) 
    {
        //1.初始化入度哈希表
        for(auto& s : words)
            for(auto ch : s)
                in[ch] = 0;
        //2.建图
        int n = words.size();
        for(int i = 0; i < n; i++)
        {
            for(int j = i + 1; j < n; j++)
            {
                add(words[i], words[j]);
                if(check) return ""; //特殊情况，直接返回空串
            }
        }
        //3.拓扑排序
        queue<char> q;
        for(auto& [a, b] : in)
        {
            if(b == 0) q.push(a); //将入度为0的点加入到队列中
        }
        string ret; //统计最终结果
        while(q.size())
        {
            char t = q.front();
            q.pop();
            ret += t;
            for(char ch : edges[t])
            {
                in[ch]--;
                if(in[ch] == 0) q.push(ch);
            }
        }
        //4.判断是否有环
        for(auto& [a, b] : in)
            if(b != 0) return "";
        return ret;
    }

    //收集信息函数(确定字母顺序)
    void add(string& s1, string& s2)
    {
        int n = min(s1.size(), s2.size());
        int i = 0;
        for(; i < n; i++)
        {
            if(s1[i] != s2[i])
            {
                char a = s1[i], b = s2[i]; //a->b
                if(!edges.count(a) || !edges[a].count(b)) //图中没有a 或 图中有a但是a没有->b, 都建图
                {
                    edges[a].insert(b);
                    in[b]++; 
                }
                break; //不要继续往后比较了,只看第一个不相等的字符
            }
        }   
        if(i == s2.size() && i < s1.size()) //特殊情况
            check = true;
    }
};
编程之路，妙趣横生
关注
  • 28
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言 | 算法 | BFS
Yalena_的博客
05-15 1521
算法笔记
考研面试算法专题.zip
01-03
《考研面试算法专题》是一个针对国内天津大学考研算法复习的重要资料集合。这个压缩包涵盖了数据结构与算法的多个核心主题，对于准备考研的学生来说，无疑是提升算法能力的关键资源。下面将详细阐述其中涉及的主要...
leetcode算法专题训练：九.BFS专题
Worthy_Wang的博客
01-29 172
九.BFS专题 127.单词接龙 126.单词接龙2 九.BFS专题 127.单词接龙 题目描述:给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则： 每次转换只能改变一个字母。 转换过程中的中间单词必须是字典中的单词。 说明: 如果不存在这样的转换序列，返回 0。 所有单词具有相同的长度。 所有单词只由小写字母组成。 字典中不存在重复的单词。 你可以假设 be.
bfs专题
qq_52011873的博客
07-16 137
一丶Knight Moves A friend of you is doing research on the Traveling Knight Problem (TKP) where you are to find the shortest closed tour of knight moves that visits each square of a given set of n squares on a chessboard exactly once. He thinks that the most
搜索算法专题
FraNny13的博客
10-26 225
搜索算法专题
leetcode刷题之BFS专题
Daisy_Wang777的博客
11-17 1678
参考资料： 广度优先算法 BFS（即广度优先搜索）是图论中一种常见的算法，常用于二叉树数据结构，能够实现对树或图中每个节点的遍历。本文将从leetcode的一些例题中详尽介绍这种算法的实现原理和在实际问题中的应用方式。 一、概念 原理：如其名字，BFS是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法终止。 结束条件：树或图中的所有节点都已被遍历。 如果还存在未被遍历的节点，则选择其中一个作为源节点并重复以上过程，整个过程反复进行知道所有节点都被遍历为止。 二、实现方法（利用栈） B
【算法专题三】BFS
weixin_43892514的博客
10-08 135
基本概念 BFS问题的本质就是让你在⼀幅「图」中找到从起点 start 到终点 target 的最近距离，这个例⼦听起来很枯燥，但是 BFS 算法问题其实都是在⼲这个事⼉，把枯燥的本质搞清楚了，再去欣赏各种问题的包装才能胸有成⽵嘛。 算法框架 // 计算从起点 start 到终点 target 的最近距离 int BFS(Node start, Node target) { Queue<Node> q; // 核⼼数据结构 Set<Node> visited
算法之搜索专题
`or 1 or 不正经の泡泡
04-09 459
深度优先搜索（DFS）和广度优先搜索（BFS）都是常见的图搜索算法。它们的目的是访问和遍历图中的所有节点，并找到满足特定条件的节点。虽然这两种算法的实现方式不同，但它们都有以下的特点。首先，DFS 和 BFS 都是无向图或者有向图的通用算法。其次，它们都需要使用一个队列来存放待处理的节点。在 DFS 中，该队列被称为堆栈，而在 BFS 中，该队列被称为队列。无论是哪一种方法，都会访问每个节点，并跟踪已经访问过的节点。
算法-基本专题bfs
weixin_30619101的博客
12-06 60
struct qin{ 　　int wei; 　　int ste; 　　qin(int xx,int yy):wei(xx),ste(yy){}//牛逼呀 }; 1，queue没有que<××struct>a(100)括号里花里胡哨的东西。 2，queue类型的定义 struct qin要初始化： queue<××struct> a;//广搜标配 qin ...
BFS专题
XXX
01-15 112
题目： 在m*n矩阵中找出块的个数（块“相邻为1的点组合而成） 1 1 0 0 0 0 1 1 1 0 0 1 则相邻整体块数为 3 BFS实现： #include <cstdio> #include <iostream> #include <queue> #include <algorithm> #include <string.h> #include <cmath> using namespace std; const int m
天津大学计算机考研面试（复试）算法专题（很全面）
01-03
天津大学计算机考研面试（复试）中的算法专题是一个重要的知识领域，涵盖了广泛的算法理论与实践内容。在准备这个环节时，考生需要对算法有深入的理解和熟练的应用能力。以下是一些关键的算法知识点： 1. **排序...
算法竞赛专题解析--搜索进阶(1)搜索基础1
08-04
《算法竞赛专题解析--搜索进阶(1)搜索基础1》 在算法竞赛的世界里，搜索是一种基础且重要的解决问题的方法，它源于“暴力法”思想，即通过穷举所有可能的解来找到正确答案。本篇文章主要探讨搜索的基础知识，包括...
C语言常见问题及算法专题整理资料
10-05
本资料“C语言常见问题及算法专题整理”深入探讨了几个核心的算法主题，包括约瑟夫环问题、魔方算法、迷宫探路、有向图的强连通分量、线段树的应用、Tarjan算法以及Hash函数和RMQ（Range Minimum Query）算法。...
算法笔记上机训练指南
02-28
作为一本《算法笔记》的配套材料，这本书的出发点是希望读者通过有计划地按照不同算法专题来解决实际问题，从而更有效地掌握算法知识。 在计算机科学和信息技术领域，算法作为核心内容之一，是影响程序性能和解决...
排序（归并排序，非比较排序）
qq_63074244的博客
08-20 916
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的 相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，⽽在排序后的序列中，r[i]仍在r[j]之 前，则称这种排序算法是稳定的；否则称为不稳定的。数据结构结构初阶的排序基本上总结完毕了，这里我学了冒泡，插入，选择，快排，希尔，堆，归并，计数排序，这几种排序在时间复杂度，空间复杂度以及稳定性上各有各的优点。下面我们用一张图进行总结。
算法日记day 45（单调栈之每日温度|接雨水）
最新发布
m0_74980681的博客
08-22 612
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 694
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
Leetcode 219. 存在重复元素 II⭐️
铁马冰河入梦来
08-20 374
哈希表解决存在重复元素二问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值