借助队列其先进先出的特点,将要搜索的放在队尾,他是一种地毯式搜索,所以第一次找到目标,一定是最短路径
员工重要性
/*
// 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;
}
};