BFS 解决最短路径问题， 迷宫中离入口最近的出口，最小基因变化，单词接龙，为高尔夫比赛砍树

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

边权为1的最短路径问题

1. 我们要知道上下左右都是可以走的 （用队列）
2. 走过的地方不要在走了，这样会进入死循环（可以把走过的地方变成墙 “.” -> “+”） （创建vis[101][101]对走过的路标记）
3. 获取到上下左右坐标的时候确认是路 “.” 还是墙 “+” （判断条件）
4. 判断是否在边界，如果达到边界位置就可以返回对应步数 （判断条件）
5. 如果发现四周都是墙的时候，说明出不去了，返回 -1
6. 先走完所有子级的上下左右后，在走 （进出队列）

class Solution {
public:
    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0}; //上下左右走使用
    bool vis[101][101]; //对走过的路标记

    int nearestExit(vector<vector<char>>& maze, vector<int>& entrance) {
        int m = maze.size();
        int n = maze[0].size();
        memset(vis,0,sizeof(vis));

        int ret = 0;
        queue<pair<int,int>> q; //创建队列
        q.push({entrance[0],entrance[1]}); //将目前自己所处位置放入队列
        vis[entrance[0]][entrance[1]] = true;//对走过的路标记
        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];
                    int y = b + dy[j];
                    if(x >= 0 && x < m && y >= 0 && y < n && maze[x][y] == '.' && !vis[x][y])//判断条件，不能走墙壁和标记过的路
                    {
                        if(x == 0 || x == m-1 || y == 0 || y == n-1)//边界条件
                            return ret; 
                        q.push({x,y});//不是边界且可以走就进入队列
                        vis[x][y] = true;//标记
                    }
                }
            }
        }
        return -1; //无法走出去就返回-1
    }
};

433. 最小基因变化

思路分析：
由题可知：基因序列 A 变化至另一个基因序列 B，需要满足一下条件：

1. 序列 A 与 序列 B 之间只有一个字符不同；
2. 变化字符只能从 ‘A’, ‘C’, ‘G’, ‘T’ 中进行选择；
3. 变换后的序列 B 一定要在字符串数组 bank 中。

具体的大概思路就是利用回溯的方式是逐个改变基因中的字符(A、C、G、T)，当改变后的基因在基因库中 步数 num+1 并进入下一层。
但是本题是有限制条件就是每一次基因变化都要能在基因库中找到，因此单层处理逻辑中需要遍历基因库，找到库中与当前基因相差一个字符的就是下一步变化的基因，这时步数 num+1 并进入下一层。

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 change = "ACGT";

        if(!hash.count(endGene)) return -1; //最终基因在基因库中找不到返回-1
        if(startGene == endGene) return 0; //如果相等就直接返回0

        queue<string> q;//创建队列
        q.push(startGene);//放入最初的基因
        vis.insert(startGene);//放入已经搜索过的基因库

        int ret = 0;
        while(q.size())
        {
            ret++;//次数++
            int sz = q.size();
            while(sz--) //队列里的个数决定循环次数
            {
                string s = q.front();//取头
                q.pop();
                for(int i = 0; i<8; i++) //循环8次是因为基因长度为8，每一个都有四种变化
                {
                    string tmp = s; //不能直接对原基因修改，用tmp代替
                    for(int j = 0; j<4; j++) //四种替换情况
                    {
                        tmp[i] = change[j]; //替换单个字符
                        if(hash.count(tmp) && !vis.count(tmp)) //变化后的基因必须位于基因库中并且没有标记过
                        {
                            if(tmp == endGene) //变化完成就返回
                                return ret;
                            q.push(tmp); //没有完成就接着进入队列
                            vis.insert(tmp);//进行标记
                        }
                    }
                }

            }
        }
        return -1; //都不能变化成就返回-1
    }
};

127. 单词接龙

跟上面那道题思路完全一样，留给各位练习使用

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

            if(!hash.count(endWord))   return 0;

            queue<string> q;
            q.push(beginWord);
            vis.insert(beginWord);

            int ret = 1;
            while(q.size())
            {
                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) && !vis.count(tmp))
                            {
                                if(tmp == endWord) return ret;
                                q.push(tmp);
                                vis.insert(tmp);
                            }
                        }
                    }
                }
            }
            return 0;
       }
};

675. 为高尔夫比赛砍树

由题意可以知道：

1. 先找出砍树的顺序
2. 按顺序进行砍树
3. 按顺序进行砍树就是bfs算法

class Solution {
    int m, n;
public:
    int cutOffTree(vector<vector<int>>& forest) {
        //1.找出砍树的顺序
        vector<pair<int,int>> trees; //创建vector数组放入有树的坐标
        for(int i = 0; i<forest.size(); i++)
        {
            for(int j = 0; j<forest[0].size(); 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 ax = 0,ay = 0;
        int ret = 0;
        for(auto& [a,b] : trees)
        {
            int step = bfs(forest,ax,ay,a,b); //bfs从（ax，ay）到（a，b）的最短步数
            if(step == -1)
                return -1;
            ret += step; //然后依次相加
            ax = a, ay = b; //将（a，b）赋给（ax，ay），然后再次循环进入bfs
        }

        return ret;
    }

    int dx[4] = {0,0,1,-1};
    int dy[4] = {1,-1,0,0};
    bool vis[51][51];
    int bfs(vector<vector<int>>& forest,int bx,int by, int ex, int ey)//bfs和之前都一样
    {
        if(bx == ex && by == ey) return 0;
        queue<pair<int,int>> q;
        memset(vis,0,sizeof(vis));
        q.push({bx,by});
        vis[bx][by] = true;

        int step = 0;
        while(q.size())
        {
            step++;
            int sz = q.size();
            while(sz--)
            {
                auto [a,b] = q.front();
                q.pop();
                for(int i = 0; i<4; i++)
                {
                    int x = a + dx[i];
                    int y = b + dy[i];
                    if(x >= 0 && x < forest.size() && y>=0 && y < forest[0].size() && forest[x][y] && !vis[x][y])
                    {
                        if(x == ex && y == ey) return step;
                        q.push({x,y});
                        vis[x][y] = true;
                    }
                }
            }
        }
        return -1;
    }

};