文章目录
- 1926. 迷宫中离入口最近的出口
- 433. 最小基因变化
- 127. 单词接龙
- 675. 为高尔夫比赛砍树
1926. 迷宫中离入口最近的出口
边权为1的最短路径问题
- 我们要知道上下左右都是可以走的 （用队列）
- 走过的地方不要在走了，这样会进入死循环（可以把走过的地方变成墙 “.” -> “+”） （创建vis[101][101]对走过的路标记）
- 获取到上下左右坐标的时候确认是路 “.” 还是墙 “+” （判断条件）
- 判断是否在边界，如果达到边界位置就可以返回对应步数 （判断条件）
- 如果发现四周都是墙的时候，说明出不去了，返回 -1
- 先走完所有子级的上下左右后，在走 （进出队列）
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，需要满足一下条件：
- 序列 A 与 序列 B 之间只有一个字符不同；
- 变化字符只能从 ‘A’, ‘C’, ‘G’, ‘T’ 中进行选择；
- 变换后的序列 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. 为高尔夫比赛砍树
由题意可以知道：
- 先找出砍树的顺序
- 按顺序进行砍树
- 按顺序进行砍树就是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;
}
};
