BFS解决最短路问题（4题&&边权为1）-优快云博客

本文链接：https://blog.youkuaiyun.com/myhhhhhhhh/article/details/145510257

解法：从起点开始，来一个BFS即可

为什么能找出最短路？

其实相当于从起点同时出发很多个小人，大家的速度都相同，看谁先到终点。在路途中如果有小人经过一个地方，但是发现已经有人来过了，那么这个小人就会被抛弃，因为大家速度一样，这说明有其他小人的路径比你短

如何找出最短路径的长度呢？扩展的层数就是最短路的长度

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

由于我们是先扩展再判断，因此不用考虑入口在边界处的情况

class Solution {
public:
    int m, n;
    bool check[110][110];
    int dx[4] = {0 , 0, -1, 1};
    int dy[4] = {1 , -1 ,0 , 0};
    int nearestExit(vector<vector<char>>& maze, vector<int>& entrance) {
        m = maze.size();
        n = maze[0].size();
        queue<pair<int, int>> q;
        q.push({entrance[0], entrance[1]});
        check[entrance[0]][entrance[1]] = 1;
        int ret = 0;
        while(q.size())
        {
            int count = q.size();
            ret++;
            for(int z = 0; z < count; z++)
            {
                auto [a, b] = q.front();
                q.pop();

                for(int k = 0; k < 4; k++)
                {
                    int i = a + dx[k];
                    int j = b + dy[k];
                    if(i >= 0 && i < m && j >=0 && j < n && check[i][j] == false && maze[i][j] == '.' )
                    {
                        if(i == 0 || i == m - 1 || j == 0 || j == n - 1)return ret;
                        q.push({i ,j});
                        check[i][j] = true;
                    }
                }
            }
        }
        return -1;
        }
};

2.最小基因变化

433. 最小基因变化 - 力扣（LeetCode）

这题有一个注意点，就是更改字符串的时候每到下一个位置要记得恢复，不然会把上一次的变化带到下一个位置去

class Solution {
public:
    int minMutation(string startGene, string endGene, vector<string>& bank) {
        unordered_set<string> vis;
        unordered_set<string> hash(bank.begin(), bank.end());
        string gene = "ACGT";
        queue<string> q;
        q.push(startGene);
        vis.insert(startGene);
        int ret = 0;

        if(startGene == endGene)return 0;
        if(!hash.count(endGene))return -1;
        while(q.size())
        {
            int count = q.size();
            ret++;
            for(int z = 0; z < count; z++)
            {
                string t = q.front();
                q.pop();
                for(int i = 0; i < t.size(); i++)
                {
                    string tmp = t;//我们要重新弄一个变量，不然上一个位置更改的结果会带到下一个位置去
                    for(int j = 0; j < 4; j++)
                    {
                        tmp[i] = gene[j];
                        if(tmp == endGene) return ret;//判断一下，如果已经到终止位置那就直接返回
                        if(!vis.count(tmp) && hash.count(tmp))
                        {
                            q.push(tmp);
                            vis.insert(tmp);
                        }
                    }
                }
            } 
        }
        return -1;
    }
};

3.单词接龙

127. 单词接龙 - 力扣（LeetCode）

与最小基因变化几乎一模一样

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        unordered_set<string> vis;
        unordered_set<string> hash(wordList.begin(), wordList.end());
        queue<string> q;
        q.push(beginWord);
        vis.insert(beginWord);
        int ret = 1;

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

        while(q.size())
        {
            int count = q.size();
            ret++;
            for(int z = 0; z < count; z++)
            {
                string t = q.front();
                q.pop();
                for(int i = 0; i < t.size(); i++)
                {
                    string tmp = t;//我们要重新弄一个变量，不然上一个位置更改的结果会带到下一个位置去
                    for(int j = 0; j < 26; j++)
                     {
                        tmp[i] = 'a' + j;
                        if(tmp == endWord) return ret;//判断一下，如果已经到终止位置那就直接返回
                        if(!vis.count(tmp) && hash.count(tmp))
                        {
                            q.push(tmp);
                            vis.insert(tmp);
                        }
                    }
                }
            } 
        }
        return 0;
    }
};

4.为高尔夫比赛砍树

675. 为高尔夫比赛砍树 - 力扣（LeetCode）

这题我们首先需要将树的坐标根据树的高度进行排序。

然后从0 0位置开始砍树即可。

class Solution {
public:
    int dx[4] = {0 , 0, -1, 1};
    int dy[4] = {1 , -1 ,0 , 0};
    int m, n;
    int cutOffTree(vector<vector<int>>& forest) {

        m = forest.size();
        n = forest[0].size();
        vector<pair<int, int>> trees;
        
        //1.准备工作 找出砍树的顺序
        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(), [&](const pair<int, int>& p1, const pair<int, int>& p2)
        {
            return forest[p1.first][p1.second] < forest[p2.first][p2.second];
        });
        //2.按顺序砍树
        int beginx = 0, beginy = 0;
        int ret = 0;
        for(auto& [a, b] : trees)
        {
            int step = bfs(forest, beginx, beginy, a, b);
            if(step == -1)return -1;
            ret += step;
            beginx = a, beginy = b;
        }
        return ret;
    }

    bool check[51][51];
    int bfs(vector<vector<int>>& f, int bx, int by, int ex, int ey)
    {
        if(bx == ex && by == ey)return 0;

        queue<pair<int, int>> q;
        memset(check, 0, sizeof check); //清空之前的数据
        q.push({bx, by});
        check[bx][by] = true;

        int step = 0;
        while(q.size())
        {
            step++;
            int sz = q.size();
            for(int count = 0; count < sz; count++)
            {
                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 && check[x][y] == false && f[x][y] != 0)
                    {
                        if( x == ex && y == ey)
                        {
                            return step;
                        }
                        q.push({x ,y});
                        check[x][y] = true;
                    }
                }
            }
        }
        return -1;
    }
};