广度优先搜索（Breadth First Search) 学习
Posted 楠c
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了广度优先搜索（Breadth First Search) 学习相关的知识，希望对你有一定的参考价值。
借助队列其先进先出的特点，将要搜索的放在队尾，他是一种地毯式搜索，所以第一次找到目标，一定是最短路径
员工重要性
/*
// Definition for Employee.
class Employee {
public:
int id;
int importance;
vector<int> subordinates;
};
*/
class Solution {
public:
int getImportance(vector<Employee*> employees, int id) {
unordered_map<int,Employee*> map;
for(auto& e:employees)
{
map[e->id]=e;
}
queue<int> q;
q.push(id);
int ret=0;
while(!q.empty())
{
int top=q.front();
q.pop();
ret+=map[top]->importance;
for(auto& e:map[top]->subordinates)
{
q.push(e);
}
}
return ret;
}
};
N叉树的层序遍历
和二叉树层序遍历思路一样，只不过他这里的结构体里用数组存储了他的孩子。将孩子一次入队即可。
/*
// Definition for a Node.
class Node {
public:
int val;
vector<Node*> children;
Node() {}
Node(int _val) {
val = _val;
}
Node(int _val, vector<Node*> _children) {
val = _val;
children = _children;
}
};
*/
class Solution {
public:
vector<vector<int>> levelOrder(Node* root) {
vector<vector<int>> vv;
if(root==NULL)
return vv;
queue<Node*> q;
q.push(root);
while(!q.empty())
{
int size=q.size();
vector<int> temp;
while(size--)
{
Node* Tnode=q.front();
q.pop();
temp.push_back(Tnode->val);
for(auto& e:Tnode->children)
{
if(e)
q.push(e);
}
}
vv.push_back(temp);
}
return vv;
}
};
腐烂的橘子
这里需要对四周同时污染，所以定义一个二维数组，表示其搜索范围。
class Solution {
public:
int orangesRotting(vector<vector<int>>& grid) {
int next[4][2]={{1,0},
{-1,0},
{0,1},
{0,-1}};
int m=grid.size();
if(m==0)
return 0;
int n=grid[0].size();
queue<pair<int,int>> q;
//找到腐烂的橘子入队
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
if(grid[i][j]==2)
{
q.push(make_pair(i,j));
}
}
}
int count=0;
while(!q.empty())
{
int flag=0;
//处理当前队列中腐烂的橘子,因为要算出分钟，所以必须用size来保存每一次队列中腐烂的橘子
//因为这一批腐烂的橘子是同时污染的。
int size=q.size();
while(size--)
{
pair<int,int> top=q.front();
q.pop();
//把它的周围变成腐烂的橘子
for(int i=0;i<4;i++)
{
int nx=top.first+next[i][0];
int ny=top.second+next[i][1];
if(nx<0||ny<0||nx>=m||ny>=n||grid[nx][ny]!=1)
{
continue;
}
flag=1;
grid[nx][ny]=2;
//变成腐烂橘子之后入队，腐烂他周围新鲜橘子
q.push(make_pair(nx,ny));
}
}
//队列中当前一批腐烂橘子处理完才++一次
if(flag)
count++;
}
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
if(grid[i][j]==1)
{
return -1;
}
}
}
return count;
}
};
单词接龙
将所给的单词放入哈希表中作为字典。
需要用标记字典，单词有可能重复。
他们两都为哈希set，查询效率高。
- 先入单词到队列中，同时对其做标记
- 取出这个单词，用26个字母对齐拼接
- 必须是，在字典中且没有被标记过才能入队列，用26个字母试探
- 处理完一批在++，因为有可能有一批单词转换
代表样例便是hit->hot。hot可以转换为dot和lot，但是dot转换步数最小。
class Solution {
public:
int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
//字典
unordered_set<string> dict;
for(auto& e:wordList)
{
dict.insert(e);
}
//标记
unordered_set<string> vist;
vist.insert(beginWord);
queue<string> q;
q.push(beginWord);
int count=1;
while(!q.empty())
{
int size=q.size();
//对队列中的一批单词进行转换
while(size--)
{
string Tstr=q.front();
q.pop();
if(Tstr==endWord)
return count;
for(int i=0;i<Tstr.size();i++)
{
//写到这里是因为每次对第一位26次试探结束，重新变回原样对第二位进行试探
//例如第一次 hit从 ait,bit,cit...一直试探，
string Nstr=Tstr;
for(char j='a';j<='z';j++)
{
Nstr[i]=j;
//存在字典中，且没有被遍历过
if(dict.count(Nstr)&&!vist.count(Nstr))
{
//入队
q.push(Nstr);
//然后打上标记
vist.insert(Nstr);
}
}
}
}
count++;
}
return 0;
}
};
最小基因变化
和单词接龙类似，bank为词典，vis我们定义的标记词典。拼接序列是它给定的ACGT
class Solution {
public:
int minMutation(string start, string end, vector<string>& bank) {
//词典
unordered_set<string> dict;
for(auto& e:bank)
{
dict.insert(e);
}
//标记
unordered_set<string> vist;
vist.insert(start);
//队列
queue<string> q;
q.push(start);
int count=0;
string str="ACGT";
while(!q.empty())
{
int size=q.size();
while(size--)
{
string Tstr=q.front();
q.pop();
if(Tstr==end)
return count;
for(int i=0;i<start.size();i++)
{
string Nstr=Tstr;
for(char j=0;j<str.size();j++)
{
Nstr[i]=str[j];
//词典包含基因序列，且没被遍历过过才入队
if(dict.count(Nstr)&&!vist.count(Nstr))
{
q.push(Nstr);
vist.insert(Nstr);
}
}
}
}
count++;
}
return -1;
}
};
打开转盘锁
字典为死亡字典，之前的逻辑是在字典中且未被标记过才能入队，根据这里的题干要求，等会的逻辑需要变成不在死亡字典，且未被标记过才能入队。
之前的单词接龙和基因变化，需要拼接单词，但是这里的转盘锁，直接在锁的基础上对每一位进行变化，而且还有两种方式，所以需要定义两个临时字符串，一个+，一个-。当9继续++时需要变成0，当0再继续–时需要变成9。
class Solution {
public:
int openLock(vector<string>& deadends, string target) {
//字典
unordered_set<string> dict(deadends.begin(),deadends.end());
//丧心病狂的用例，起始位置直接死亡
if(dict.count("0000"))
return -1;
queue<string> q;
q.push("0000");
//标记字典以防重复
unordered_set<string> vis;
vis.insert("0000");
int step=0;
while(!q.empty())
{
int size=q.size();
while(size--)
{
string Tstr=q.front();
q.pop();
if(Tstr==target)
{
return step;
}
for(int i=0;i<Tstr.size();i++)
{
//因为它有两种变化方式
string str1=Tstr;
string str2=Tstr;
//等于0,--变成9，否则每次减1
str1[i]=str1[i]=='0'?'9':str1[i]-1;
//等于9,++变成0，否则每次加1
str2[i]=str2[i]=='9'?'0':str2[i]+1;
//不在死亡字典，且没有被遍历过
if(!dict.count(str1) && !vis.count(str1))
{
q.push(str1);
vis.insert(str1);
}
if(!dict.count(str2) && !vis.count(str2))
{
q.push(str2);
vis.insert(str2);
}
}
}
step++;
}
return -1;
}
};
以上是关于广度优先搜索（Breadth First Search) 学习的主要内容，如果未能解决你的问题，请参考以下文章
CS 188 Breadth First Search BFS(广度优先搜索算法)
广度优先搜索（Breadth First Search) 学习
广度优先搜索（Breadth First Search) 学习