文章目录
- 迷宫中离入口最近的出口
- 最小基因变化
- 单词接龙
- 为高尔夫比赛砍树
BFS 解决最短路问题
BFS(广度优先搜索) 是解决最短路径问题的一种常见算法。在这种情况下，我们通常使用BFS来查找从一个起始点到目标点的最短路径。
迷宫中离入口最近的出口
题目：迷宫中离入口最近的出口
思路
图论中边路权值为1的情况，利用层序遍历来解决是最经典的做法。
从起点开始层序遍历，在遍历的过程中记录当前遍历的层数。
C++代码
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>& entrance)
{
int m = maze.size(), n = maze[0].size();
vector<vector<bool>> visited(m, vector<bool>(n, false));
int ret = 0;
queue<pair<int, int>> q;
q.push({entrance[0], entrance[1]});
visited[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 k = 0; k < 4; k++)
{
int x = a + dx[k], y = b + dy[k];
if(0 <= x && x < m && 0 <= y && y < n && maze[x][y] == '.' && !visited[x][y])
{
if(x == 0 || x == m - 1 || y == 0 || y == n - 1)
return ret;
q.push({x, y});
visited[x][y] = true;
}
}
}
}
return -1;
}
};
最小基因变化
题目：最小基因变化
思路
转化成边路权值为1的图论问题
-
用
unordered_set<string> hash(bank.begin(), bank.end());来存储基因库，快速判断该基因是否存在于基因库 -
枚举出的每一个位置，我们先判断其是否为
合法基因（如果基因库中有并且该基因没有被访问） -
用一个
unordered_set<string> visited;用于标记是否访问过该基因序列 -
用BFS，尝试每个位置可能变异后得结果，如果变异后的基因是
合法基因，就加入队列中，并标记为已访问
C++代码
class Solution
{
public:
int minMutation(string startGene, string endGene, vector<string>& bank)
{
unordered_set<string> hash(bank.begin(), bank.end()); // 创建一个hash方便判断该基因序列是否合法
unordered_set<string> visited; // 用于标记是否访问过该基因序列
string change = "ACGT"; // 可能的基因变异字符
if(startGene == endGene) return 0; // 起始基因和目标基因相同，不用改变
if(!hash.count(endGene)) return -1; // 目标基因不在基因库，返回-1
queue<string> q;
q.push(startGene); // 起始基因入队
visited.insert(startGene); // 标记起始基因被访问
int ret = 0;
while(!q.empty())
{
int sz = q.size();
ret++;
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++) // 每个位置更改 4 次
{
tmp[i] = change[j];
// 如果基因库中有并且该基因没有被访问，则为合法基因
if(hash.count(tmp) && !visited.count(tmp))
{
// 合法基因等于目标基因返回结果
if(tmp == endGene)
return ret;
// 合法基因入队并且标记访问过了
q.push(tmp);
visited.insert(tmp);
}
}
}
}
}
return -1;
}
};
单词接龙
题目：单词接龙
思路
和上一题的思路一毛一样，只不过上题每个位置变化只有四种可能，而这题每个位置的变换有二十六种可能性
C++代码
class Solution
{
public:
int ladderLength(string beginWord, string endWord, vector<string>& wordList)
{
unordered_set<string> visited; // 记录该单词是否访问过了
unordered_set<string> hash(wordList.begin(), wordList.end());
if (beginWord == endWord) return 1; // 起始单词和目标单词相同，不用改变
if (!hash.count(endWord)) return 0; // 目标单词不在wordList，返回 0
queue<string> q;
q.push(beginWord); // 起始单词入队
visited.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++) // 每个位置更改 26 次
{
tmp[i] = ch;
// 判断是否为合法单词
if(hash.count(tmp) && !visited.count(tmp))
{
if (tmp == endWord)
return ret;
q.push(tmp);
visited.insert(tmp);
}
}
}
}
}
return 0;
}
};
为高尔夫比赛砍树
题目：为高尔夫比赛砍树
思路
其实本题就是多次的迷宫问题累计求和，不停的变换起始位置
(x, y)以及终止位置(nx, ny)
- 遍历森林，将树木的位置加入
trees数组中 - 树木的高度进行排序
- 用
BFS计算起始位置(x, y)以及终止位置(nx, ny)的距离 - 累加步数，并更新起始位置
(x, y)
C++代码
class Solution
{
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int m, n;
bool visited[51][51];
int bfs(vector<vector<int>>& forest, int x, int y, int nx, int ny)
{
if (x == nx && y == ny) return 0; // 如果起始位置和目标位置相同，步数为0
queue<pair<int, int>> q;
memset(visited, 0, sizeof visited);
q.push({x, y});
visited[x][y] = true;
int ret = 0;
while(!q.empty())
{
ret++;
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], y = b + dy[k];
if(0 <= x && x < m && 0 <= y && y < n && forest[x][y] && !visited[x][y])
{
if (x == nx && y == ny) // 如果到达目标位置，返回步数
return ret;
q.push({x, y});
visited[x][y] = true;
}
}
}
}
return -1;
}
public:
int cutOffTree(vector<vector<int>>& forest)
{
m = forest.size(), n = forest[0].size();
// 将树的坐标存放起来
vector<pair<int, int>> trees;
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];
});
int x = 0, y = 0; // 起始位置(0, 0)
int ret = 0;
// 从小到大遍历
for(auto& [nx, ny] : trees)
{
int step = bfs(forest, x, y, nx, ny);
if(step == -1) return -1;
ret += step;
x = nx, y = ny; // 更新起始位置
}
return ret;
}
};
