算法：BFS 解决最短路问题

青春_strive

已于 2024-10-22 16:10:43 修改

阅读量957

点赞数 24

CC 4.0 BY-SA版权

分类专栏：算法文章标签：算法宽度优先

于 2024-07-27 19:36:47 首次发布

本文链接：https://blog.csdn.net/m0_64411530/article/details/140674197

算法专栏收录该内容

28 篇文章

订阅专栏

最短路问题

最短路就是指，从一个点到另一个点，最短需要走多少路程

我们这里只研究最简单的，边权为1的最短路问题，所以也可以扩展为每个边权全部相同的问题

一般想求从一点到另一点的最短路是多少，解法就是：从起点开始，进行一次bfs即可，至于为什么进行一次bfs就可以，其实很简单：

因为从一点到另一点有很多路，有最短路有最长路，但是层序遍历的过程，就相当于每次有很多小人从一个点同时向后移动一位，那么当其中一个小人最先到达终点时，就表明它走的这条路径一定是最短的

在使用队列辅助时，每次都会将队列中的值全部出队列，并bfs继续向后入队列，最终如果求的是最短路是多少，就只需要关注，出队列出了几次，也就是队列扩展了几次，就表明小人移动了多少次，也就是最短路径是多少

题目一：迷宫中离入口最近的出口

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

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

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

示例 1：

输入：maze = [["+","+",".","+"],[".",".",".","+"],["+","+","+","."]], entrance = [1,2]
输出：1
解释：总共有 3 个出口，分别位于 (1,0)，(0,2) 和 (2,3) 。
一开始，你在入口格子 (1,2) 处。
- 你可以往左移动 2 步到达 (1,0) 。
- 你可以往上移动 1 步到达 (0,2) 。
从入口处没法到达 (2,3) 。
所以，最近的出口是 (0,2) ，距离为 1 步。

示例 2：

输入：maze = [["+","+","+"],[".",".","."],["+","+","+"]], entrance = [1,0]
输出：2
解释：迷宫中只有 1 个出口，在 (1,2) 处。
(1,0) 不算出口，因为它是入口格子。
初始时，你在入口与格子 (1,0) 处。
- 你可以往右移动 2 步到达 (1,2) 处。
所以，最近的出口为 (1,2) ，距离为 2 步。

示例 3：

输入：maze = [[".","+"]], entrance = [0,0]
输出：-1
解释：这个迷宫中没有出口。

题意就是小人在一个迷宫中，判断小人需要最少走几步可以走出去

注意：

小人自己所处的位置不算出口
出口指的是靠近边界的位置
也可能没有出口，此时返回-1即可

所以题目的解法很简单，在上面介绍最短路问题时就已经说到了，只需进行一次bfs即可，直到边界位置为止

同样写代码时也需要一个vis数组，代表这个位置有没有遍历过

代码如下：

class Solution 
{
    // vis数组标记某位置是否走过
    typedef pair<int, int> PII;
    bool vis[110][110];
    int dx[4] = {0,0,-1,1};
    int dy[4] = {-1,1,0,0};
public:
    int nearestExit(vector<vector<char>>& maze, vector<int>& entrance) 
    {
        int m = maze.size(), n = maze[0].size(), ret = 0;
        int i = entrance[0], j = entrance[1];
        queue<PII> q;
        q.push({i, j});
        vis[i][j] = true;
        while(!q.empty())
        {
            // 每次出队列时，ret++
            ret++;
            int sz = q.size();
            // 每次将队列全部出完
            for(int t = 0; t < sz; t++)
            {
                auto [a, b] = q.front();
                q.pop();
                for(int k = 0; k < 4; k++)
                {
                    int x = a + dx[k];
                    int y = b + dy[k];
                    if(x >= 0 && x < m && y >= 0 && y < n && maze[x][y] == '.' && vis[x][y] == false)
                    {
                        // 判断是否走到出口
                        if(x == 0 || x == m - 1 || y == 0 || y == n - 1) return ret;
                        q.push({x, y});
                        vis[x][y] = true;
                    }
                }
            }
        }
        // 程序运行到这里，说明没有出口
        return -1;
    }
};

题目二：最小基因变化

基因序列可以表示为一条由 8 个字符组成的字符串，其中每个字符都是 'A'、'C'、'G' 和 'T' 之一。

假设我们需要调查从基因序列 start 变为 end 所发生的基因变化。一次基因变化就意味着这个基因序列中的一个字符发生了变化。

例如，"AACCGGTT" --> "AACCGGTA" 就是一次基因变化。

另有一个基因库 bank 记录了所有有效的基因变化，只有基因库中的基因才是有效的基因序列。（变化后的基因必须位于基因库 bank 中）

给你两个基因序列 start 和 end ，以及一个基因库 bank ，请你找出并返回能够使 start 变化为 end 所需的最少变化次数。如果无法完成此基因变化，返回 -1 。

注意：起始基因序列 start 默认是有效的，但是它并不一定会出现在基因库中。

示例 1：

输入：start = "AACCGGTT", end = "AACCGGTA", bank = ["AACCGGTA"]
输出：1

示例 2：

输入：start = "AACCGGTT", end = "AAACGGTA", bank = ["AACCGGTA","AACCGCTA","AAACGGTA"]
输出：2

示例 3：

输入：start = "AAAAACCC", end = "AACCCCCC", bank = ["AAAACCCC","AAACCCCC","AACCCCCC"]
输出：3

这道题也就是将start变为end，每次只能变一个位置，但是变完后的顺序必须要在bank中出现，不然就不能这样子变，例如示例二：

将AACCGGTT想要变为AAACGGTA，start和end有两个标红的位置不同，所以需要分别将这两个位置改变：
如果先改变第一个红色的位置，变为：AAACGGTT，这时发现bank中并没有这个顺序，所以不能这样子变
那么改变第二个红色的位置，变为：AACCGGTA，观察bank中是有这个顺序的，所以这次改变是正确的，此时还剩第一个红色位置，改变为：AAACGGTA，发现bank中也是有这种方式的，所以两次后改变成功，所以答案是2

那么这个问题为什么可以转化为边权为1的最短路问题呢？

其实很简单，我们将start和end字符串当做一个点，而每一个点都会发生变化，每次发生的这个变化也可以抽象为一个点，此时就相当于一个字符串，经过一系列的变化，变为了另一个字符串，计算这里的最短路程，也就是计算题目所求的最小变化次数

细节：

1、因为每次改变字符串的某一个字母，有可能会改成原来改过的字符串，就倒回去了，所以这里需要使用哈希表存储一下已经改变过的字符串

2、使用for循环枚举出所有的变化情况

3、枚举出来的所有字符串，只需要将其中存在于bank中的字符串存入队列，其他就不需要存到队列中了

4、判断字符串是否在bank中时，只需将bank中的字符串映射到哈希表中，这样就能够很快的判断出字符串是否在其中了，这里的哈希表只需要使用set即可，因为只需要判断是否出现过

代码如下：

class Solution {
public:
    int minMutation(string startGene, string endGene, vector<string>& bank) {
        int ret = 0;
        string change = "ACGT";
        // vis用来标记已经搜索过的状态，hash存储bank中的字符串
        unordered_set<string> vis;
        unordered_set<string> hash(bank.begin(), bank.end());
        // 判断两个边界条件
        if (startGene == endGene) return 0;
        if (!hash.count(endGene)) return -1;
        queue<string> q;
        q.push(startGene);
        vis.insert(startGene); // 每次push都标记一下该字符串已经出现过
        while (!q.empty()) 
        {
            // 每次扩之前ret++，每次将队列的元素全部出队列，表示这一次的情况走完了
            ret++;
            int sz = q.size();
            while (sz--) 
            {
                string cur = q.front();
                q.pop();
                // 将队头元素所有可能得情况全部枚举出来
                for (int i = 0; i < 8; i++) 
                {
                    // 修改前需要保证是最开始的队头元素
                    string tmp = cur;
                    for (int j = 0; j < 4; j++) 
                    {
                        tmp[i] = change[j];
                        // 如果tmp之前没标记过，并且出现在hash中，入队列
                        if(!vis.count(tmp) && hash.count(tmp))
                        {
                            // 判断是否找到了最终结果
                            if (tmp == endGene) return ret;
                            vis.insert(tmp);
                            q.push(tmp);
                        }
                    }
                }
            }
        }
        // 如果走到这里，就说明找不到最终结果
        return -1;
    }
};

题目三：单词接龙

字典 wordList 中从单词 beginWord 到 endWord 的 转换序列 是一个按下述规格形成的序列 beginWord -> s1 -> s2 -> ... -> sk：

每一对相邻的单词只差一个字母。
对于 1 <= i <= k 时，每个 si 都在 wordList 中。注意， beginWord 不需要在 wordList 中。
sk == endWord

给你两个单词 beginWord 和 endWord 和一个字典 wordList ，返回从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0 。

示例 1：

输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
输出：5
解释：一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog", 返回它的长度 5。

示例 2：

输入：beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
输出：0
解释：endWord "cog" 不在字典中，所以无法进行转换。

这道题上一道最小基因变化的题就是一模一样的，上一道是只会变化ACGT，而这一道是从a到z都可能会变

并且还需要注意的是，这一题问的是最短的转换序列是多少，而上一题问的是需要变化多少次，也就是此题会比上一题的结果多1，因为转换序列也需要加上最开始的那一个单词

下面就是代码了，与上一题几乎一样，只是处理了一些细节：

class Solution 
{
public:

    int ladderLength(string beginWord, string endWord, vector<string>& wordList) 
    {
        unordered_set<string> vis; // 标记已经搜索过的单词
        unordered_set<string> hash(wordList.begin(), wordList.end());
        // 边界条件判断
        if(beginWord == endWord) return 1;
        if(!hash.count(endWord)) return 0;
        // num是begin和end的字符串长度，ret是最终返回的结果
        int num = beginWord.size(), ret = 1;
        queue<string> q;
        q.push(beginWord);
        // 每次push都再vis中标记
        vis.insert(beginWord);
        while(!q.empty())
        {
            ret++;
            int sz = q.size();
            // 每次都将队列的元素全部出队列
            while(sz--)
            {
                string cur = q.front();
                q.pop();
                // 枚举每一位可能出现的变化
                for(int i = 0; i < num; i++)
                {
                    string tmp = cur;
                    for(char ch = 'a'; ch <= 'z'; ch++)
                    {
                        tmp[i] = ch;
                        // 如果在hash中，并且没有搜索过，就可以push
                        if(hash.count(tmp) && !vis.count(tmp))
                        {
                            // 判断当前字符串是否是最终结果
                            if(tmp == endWord) return ret;
                            q.push(tmp);
                            vis.insert(tmp);
                        }
                    }
                }
            }
        }
        // 代码运行到这里，说明没有转换成功
        return 0;
    }
};

题目四：为高尔夫比赛砍树

你被请来给一个要举办高尔夫比赛的树林砍树。树林由一个 m x n 的矩阵表示，在这个矩阵中：

0 表示障碍，无法触碰
1 表示地面，可以行走
比 1 大的数 表示有树的单元格，可以行走，数值表示树的高度

每一步，你都可以向上、下、左、右四个方向之一移动一个单位，如果你站的地方有一棵树，那么你可以决定是否要砍倒它。

你需要按照树的高度从低向高砍掉所有的树，每砍过一颗树，该单元格的值变为 1（即变为地面）。

你将从 (0, 0) 点开始工作，返回你砍完所有树需要走的最小步数。如果你无法砍完所有的树，返回 -1 。

可以保证的是，没有两棵树的高度是相同的，并且你至少需要砍倒一棵树。

示例 1：

输入：forest = [[1,2,3],[0,0,4],[7,6,5]]
输出：6
解释：沿着上面的路径，你可以用 6 步，按从最矮到最高的顺序砍掉这些树。

示例 2：

输入：forest = [[1,2,3],[0,0,0],[7,6,5]]
输出：-1
解释：由于中间一行被障碍阻塞，无法访问最下面一行中的树。

示例 3：

输入：forest = [[2,3,4],[0,0,5],[8,7,6]]
输出：6
解释：可以按与示例 1 相同的路径来砍掉所有的树。
(0,0) 位置的树，可以直接砍去，不用算步数。

这道题目也就是说，任务初始是在(0,0)点，如果某个方格的数值是0，就表示不能行走，1表示可以行走，大于1的数表示树的高度

题目要求我们需要砍完所有的树，这里的砍树顺序必须是从最低的树到最高的树，按照顺序砍，求砍完所有树最小的步数

所以这道题的算法原理就是：

先找到所有需要砍的树的高度，再将这些高度进行排序，最后转化为这些高度从低到高每一次需要走的最短路径，加起来即可

如果某一棵树无法砍掉，就返回-1

细节：

需要将待砍的树的下标存到数组中，并能够很好的排序，这样就可以方便我们得到该砍哪棵树了，并且能够得到这棵树的下标是多少

代码如下：

class Solution 
{
    typedef pair<int, int> PII;
    bool vis[51][51];
    int dx[4] = {0,0,-1,1};
    int dy[4] = {-1,1,0,0};
    int ret, m, n;
public:
    int cutOffTree(vector<vector<int>>& forest) 
    {
        vector<PII> trees;
        m = forest.size(), n = forest[0].size();
        // 将所有树高度及其坐标插入进map中
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
                if(forest[i][j] > 1)
                    trees.push_back({i, j});
        // 将数组中的数据按照树的高度排序
        sort(trees.begin(), trees.end(), [&](PII& p1, PII& p2)
        {
            return forest[p1.first][p1.second] < forest[p2.first][p2.second];
        });
        int bx = 0, by = 0; // 最开始的下标是(0, 0)
        // 遍历从低到高的每个树，计算两两之间需要走的最短路径
        for(auto [a, b] : trees)
        {
            // bx、by和ex、ey分别表示开始的坐标和结束的下标
            int step = bfs(forest, bx, by, a, b);
            if(step == -1) return -1;
            ret += step; 
            bx = a, by = b;
        }
        return ret;
    }

    int bfs(vector<vector<int>>& forest, int bx, int by, int ex, int ey)
    {
        // 如果开始和结束位置相同，相当于没移动，返回0即可
        if(bx == ex && by == ey) return 0;
        // 每次都需要清理vis之前的数据
        memset(vis, 0, sizeof vis);
        // 下面就是标准的走迷宫的代码
        queue<PII> q;
        q.push({bx, by});
        vis[bx][by] = true;
        
        int step = 0;
        while(!q.empty())
        {
            step++;
            int sz = q.size();
            while(sz--)
            {
                auto [a, b] = q.front();
                q.pop();
                for(int k = 0; k < 4 ; k++)
                {
                    int x = a + dx[k];
                    int y = b + dy[k];
                    if(x >= 0 && x < m && y >=0 && y < n && vis[x][y] == false && forest[x][y] >= 1)
                    {
                        if(x == ex && y == ey) return step;
                        q.push({x, y});
                        vis[x][y] = true;
                    }
                }
            }
        }
        // 走到这说明没有走到目标位置
        return -1;
    }
};

BFS 解决最短路问题的题目到此结束