紧接着上文，我们继续学习BFS算法的剩下的内容
class Solution {
public:
vector<vector<int>> updateMatrix(vector<vector<int>>& mat) {
int m=mat.size(),n=mat[0].size();
vector<vector<int>> nums(m,vector<int>(n,-1));
queue<pair<int,int>> q;
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(mat[i][j]==0){
nums[i][j]=0;
q.push({i,j});
}
}
}
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
while(q.size())
{
auto [a,b]=q.front();
q.pop();
for(int k=0;k<4;k++){
int x=a+dx[k],y=b+dy[k];
if(x>=0&&x<m&&y>=0&&y<n&&nums[x][y]==-1){
nums[x][y]=nums[a][b]+1;
q.push({x,y});
}
}
}
return nums;
}
};
class Solution {
public:
int numEnclaves(vector<vector<int>>& nums) {
int m=nums.size(),n=nums[0].size();
vector<vector<bool>> vis(m,vector<bool>(n));
queue<pair<int,int>> q;
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(i==0||i==m-1||j==0||j==n-1){
if(nums[i][j]==1){
q.push({i,j});
vis[i][j]=true;
}
}
}
}
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
while(q.size()){
auto [a,b]=q.front();
q.pop();
for(int k=0;k<4;k++){
int x=a+dx[k],y=b+dy[k];
if(x>=0&&x<m&&y>=0&&y<n&&nums[x][y]==1&&!vis[x][y]){
q.push({x,y});
vis[x][y]=true;
}
}
}
int ret=0;
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(!vis[i][j]&&nums[i][j]==1) ret++;
}
}
return ret;
}
};
class Solution {
public:
vector<vector<int>> highestPeak(vector<vector<int>>& is) {
int m=is.size(),n=is[0].size();
queue<pair<int,int>> q;
vector<vector<int>> nums(m,vector(n,-1));
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(is[i][j]==1){
nums[i][j]=0;
q.push({i,j});
}
}
}
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
while(q.size()){
auto [a,b]=q.front();
q.pop();
for(int k=0;k<4;k++){
int x=a+dx[k],y=b+dy[k];
if(x>=0&&x<m&&y>=0&&y<n&&nums[x][y]==-1){
nums[x][y]=nums[a][b]+1;
q.push({x,y});
}
}
}
return nums;
}
};
class Solution {
public:
int maxDistance(vector<vector<int>>& nums) {
int m=nums.size(),n=nums[0].size();
queue<pair<int,int>> q;
vector<vector<int>> an(m,vector<int>(n,-1));
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(nums[i][j]==1){
an[i][j]=0;
q.push({i,j});
}
}
}
int ret=-1;
int dx[4]={0,0,1,-1};
int dy[4]={1,-1,0,0};
while(q.size()){
auto [a,b]=q.front();
q.pop();
for(int k=0;k<4;k++){
int x=a+dx[k],y=b+dy[k];
if(x>=0&&x<m&&y>=0&&y<n&&an[x][y]==-1){
an[x][y]=an[a][b]+1;
q.push({x,y});
ret=max(ret,an[x][y]);
}
}
}
return ret;
}
};
我们下面将要对扩朴排序进行使用哈！
class Solution {
public:
bool canFinish(int n, vector<vector<int>>& p) {
unordered_map<int,vector<int>> edges;
vector<int> in(n);
for(auto e: p){
int a=e[0],b=e[1];
edges[b].push_back(a);
in[a]++;
}
queue<int> q;
for(int i=0;i<n;i++){
if(in[i]==0) q.push(i);
}
while(!q.empty()){
int t=q.front();
q.pop();
for(int e:edges[t]){
in[e]--;
if(in[e]==0) q.push(e);
}
}
for(int i:in)
if(i) return false;
return true;
}
};
class Solution {
public:
vector<int> findOrder(int n, vector<vector<int>>&nums) {
unordered_map<int,vector<int>> edges;
vector<int> in(n);
for(auto e: nums){
int a=e[0],b=e[1];
edges[b].push_back(a);
in[a]++;
}
queue<int> q;
for(int i=0;i<n;i++){
if(in[i]==0) q.push(i);
}
vector<int> ret;
while(q.size()){
int t=q.front();
q.pop();
ret.push_back(t);
for(auto e:edges[t]){
in[e]--;
if(in[e]==0) q.push(e);
}
}
if(ret.size()==n) return ret;
else return {};
}
};
class Solution {
public:
unordered_map<char,unordered_set<char>> edges;
unordered_map<char,int> in;
bool check;
string alienOrder(vector<string>& words) {
for(auto& s:words){
for(auto ch:s){
in[ch]=0;
}
}
int n=words.size();
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
add(words[i],words[j]);
if(check) return "";
}
}
queue<char> q;
for(auto&[a,b]: in){
if(b==0) q.push(a);
}
string ret;
while(q.size()){
char t=q.front();
q.pop();
ret+=t;
for(auto ch: edges[t]){
in[ch]--;
if(in[ch]==0) q.push(ch);
}
}
for(auto &[a,b]: in){
if(b!=0) return "";
}
return ret;
}
void add(string& s1,string& s2){
int n=min(s1.size(),s2.size());
int i=0;
for(;i<n;i++){
if(s1[i]!=s2[i]){
char a=s1[i],b=s2[i];
if(!edges.count(a)||!edges[a].count(b)){
edges[a].insert(b);
in[b]++;
}
break;
}
}
if(i==s2.size()&&i<s1.size()) check=true;
}
};