一、边权相同最短路问题简介
二、迷宫中离入口最近的出口
. - 力扣（LeetCode）
class Solution {
public:
const int dx[4]={1,-1,0,0};
const int dy[4]={0,0,1,-1};
int nearestExit(vector<vector<char>>& maze, vector<int>& e) {
int m=maze.size(),n=maze[0].size();
queue<pair<int,int>> q;//队列
bool check[m][n]; //非全局的bool是乱值 全局的会初始化为0
//力扣支持这样的写法
memset(check,0,sizeof(check)); //初始化成0
q.emplace(e[0],e[1]);
check[e[0]][e[1]]=true;
int step=0;//统计步数
while(!q.empty())
{
++step;
//要控制同一层出
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=dx[k]+a,y=dy[k]+b;
if(x>=0&&x<m&&y>=0&&y<n&&maze[x][y]=='.'&&check[x][y]==false)
{
//如果找到最后一个了，就可以直接返回了
if(x==0||x==m-1||y==0||y==n-1) return step;
//如果没找到，继续进
q.emplace(x,y);
check[x][y]=true;
}
}
}
}
return -1;
}
};三、最小基因变化（经典图论bfs）
. - 力扣（LeetCode）
class Solution {
public:
//转化成图论中的bfs问题
int minMutation(string startGene, string endGene, vector<string>& bank) {
if(startGene==endGene) return 0;
string s("AGCT");//四种变化情况
unordered_set<string> hash1(bank.begin(),bank.end());//负责帮助我们快速查找字符串是否在基因库中
if(hash1.count(endGene)==0) return -1;
queue<string> q;//存储在基因库中出现过的变化后字符串
q.emplace(startGene);
unordered_set<string> hash2;//负责标记哪些字符串被搜索过
hash2.insert(startGene);
int step=0;//用来统计步数
while(!q.empty())
{
++step;
int sz=q.size();//控制一行一行出
for(int i=0;i<sz;++i)
{
string temp=q.front();//待处理的字符串
q.pop();
for(int j=0;j<8;++j) //遍历字符串的每个位置
{
for(int k=0;k<4;++k)
{
string cur=temp;
cur[j]=s[k];//修改
if(hash1.count(cur)&&hash2.count(cur)==0)//如果基因库找到了 就丢进去
{
if(cur==endGene) return step;
hash2.insert(cur);
q.emplace(cur);
}
}
}
}
}
return -1;
}
};四、单词接龙
. - 力扣（LeetCode）
class Solution {
public:
int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
int n=beginWord.size();
//需要一个哈希表存储字典中的字符串，方便快速搜索是否存在
unordered_set<string> hash(wordList.begin(),wordList.end());
//需要一个标记哈希表帮助我们判断被搜索过的字符串
if(!hash.count(endWord)) return 0;
unordered_set<string> vis;
queue<string> q;
vis.insert(beginWord);
q.emplace(beginWord);
int ret=1;
while(!q.empty())
{
++ret;
//要控制一行一行出
int sz=q.size();
for(int i=0;i<sz;++i)
{
string t=q.front();
q.pop();
//开始想办法修改
for(int j=0;j<n;++j) //遍历字符串的每个位置
for(char k='a';k<='z';++k)
{
string temp=t;
temp[j]=k;//修改
//如果修改后在字典中找到，就可以加入队列中 如果是最终结果就返回
if(hash.count(temp)&&!vis.count(temp))
{
if(temp==endWord) return ret;
vis.insert(temp);
q.emplace(temp);
}
}
}
}
return 0;
}
};五、为高尔夫比赛砍树（经典bfs）
. - 力扣（LeetCode）
转化成多个最短路问题，但是我们需要知道从哪树开始砍，第一个方法就是用map进行存储，可以顺便帮助我们排序，第二个方法就是用vector进行存储，然后sort+lambda表达式解决问题
策略1：用map
class Solution {
public:
typedef pair<int,int> PII;
int m,n;
const int dx[4]={1,-1,0,0};
const int dy[4]={0,0,1,-1};
int cutOffTree(vector<vector<int>>& f) {
//转化成若干个迷宫问题
//得存下标和值 并且要方便排序
m=f.size(),n=f[0].size();
map<int,PII> hash;//前面存值 后面存下标
for(int i=0;i<m;++i)
for(int j=0;j<n;++j)
if(f[i][j]>1) hash[f[i][j]]=make_pair(i,j); //map会帮助我们排好序
//然后按顺序砍树
int bx=0,by=0; //初始位置
int ret=0;
for(auto&it:hash)
{
auto&[a,b]=it.second;
int step=bfs(f,bx,by,a,b);
if(step==-1) return -1;
ret+=step;
//往下迭代
bx=a,by=b;
}
return ret;
}
bool vis[50][50];
int bfs(vector<vector<int>>& f,int bx,int by,int a,int b)
{
//转化成迷宫问题 从起点到终点的最短路问题
if(bx==a&&by==b) return 0; //有可能直接从起始位置开始砍
queue<PII> q;
//必须要清空之前的数据
memset(vis,0,sizeof(vis));
q.emplace(bx,by);
vis[bx][by]=true;
int step=0;
while(!q.empty())
{
//要控制一层一层走
++step;
int sz=q.size();
for(int i=0;i<sz;++i)
{
auto[ex,ey] =q.front();
q.pop();
for(int k=0;k<4;++k)
{
int x=dx[k]+ex,y=dy[k]+ey;
if(x>=0&&x<m&&y>=0&&y<n&&f[x][y]!=0&&vis[x][y]==false)
{
if(x==a&&y==b) return step;
//丢进去
q.emplace(x,y);
vis[x][y]=true;
}
}
}
}
return -1;
}
};策略2：vector+sort+lambda
class Solution {
public:
typedef pair<int,int> PII;
int m,n;
const int dx[4]={1,-1,0,0};
const int dy[4]={0,0,1,-1};
int cutOffTree(vector<vector<int>>& f) {
//转化成若干个迷宫问题 关键就在于我们怎么确定砍树的顺序
//得存下标和值 并且要方便排序
m=f.size(),n=f[0].size();
//用一个vector存储下标，然后排序的时候用lambda表达式
vector<PII> trees;
for(int i=0;i<m;++i)
for(int j=0;j<n;++j)
if(f[i][j]>1) trees.emplace_back(i,j);
//sort+lambda 进行排序
sort(trees.begin(),trees.end(),[&f](const PII&kv1,const PII&kv2) //lambda捕获f
{
return f[kv1.first][kv1.second]<f[kv2.first][kv2.second];
});
//然后按顺序砍树
int bx=0,by=0; //初始位置
int ret=0;
for(auto&[a,b]:trees)
{
int step=bfs(f,bx,by,a,b);
if(step==-1) return -1;//说明无路可走了
ret+=step;
//往下迭代
bx=a,by=b;
}
return ret;
}
bool vis[50][50];
int bfs(vector<vector<int>>& f,int bx,int by,int a,int b)
{
//转化成迷宫问题 从起点到终点的最短路问题
if(bx==a&&by==b) return 0; //有可能直接从起始位置开始砍
queue<PII> q;
//必须要清空之前的数据
memset(vis,0,sizeof(vis));
//如果不定义成全局的标记数据的话， 也可以定义成局部的标记数组，但同样需要进行初始化
q.emplace(bx,by);
vis[bx][by]=true;
int step=0;
while(!q.empty())
{
//要控制一层一层走
++step;
int sz=q.size();
for(int i=0;i<sz;++i)
{
auto[ex,ey] =q.front();
q.pop();
for(int k=0;k<4;++k)
{
int x=dx[k]+ex,y=dy[k]+ey;
if(x>=0&&x<m&&y>=0&&y<n&&f[x][y]!=0&&vis[x][y]==false)
{
if(x==a&&y==b) return step;
//丢进去
q.emplace(x,y);
vis[x][y]=true;
}
}
}
}
return -1;
}
};
