Leetcode542，1162 BFS在二维矩阵中的应用

1.BFS的核心要点

一、广度优先搜索
思路：
对于 「Tree 的 BFS」 （典型的「单源 BFS」） 大家都已经轻车熟路了：

首先把 root 节点入队，再一层一层无脑遍历就行了。
对于 「图 的 BFS」 （「多源 BFS」） 做法其实也是一样的，与 「Tree 的 BFS」的区别注意以下两条就 ok 。

1.Tree 只有 1 个 root，而图可以有多个源点，所以首先需要把多个源点都入队；
2.Tree 是有向的因此不需要标识是否访问过，而对于无向图来说，必须得标志是否访问过哦！并且为了防止某个节点多次入队，需要在其入队之前就将其设置成已访问！

2.Leetcode 542 0 1 矩阵

2.1题目

2.2代码

class Solution {
    int d[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
public:
    vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
        if(matrix.size()<=0)
            return {};
        int m=matrix.size(), n = matrix[0].size();
        queue<pair<int,int>> q;    //队列中存储的是二维矩阵的坐标
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(matrix[i][j] == 0)
                {
                    q.push(make_pair(i,j));  // 对应要点1， 多源入队列
                }else
                {
                    matrix[i][j] = -1;
                }
            }
        }
        
        while(!q.empty())
        {
            pair<int,int> temp = q.front();
            q.pop();
            int x = temp.first, y = temp.second;
            for(int k=0;k<4;k++)
            {
                int new_x = x + d[k][0];
                int new_y = y + d[k][1];
                if(inArea(new_x,new_y,m,n) && matrix[new_x][new_y] == -1) // -1就是flag，防止多次入队列。
                {
                    matrix[new_x][new_y] = matrix[x][y] + 1;	// 新入队的值进行更新
                    q.push(make_pair(new_x,new_y));
                }
            }
          
        }
      
        return matrix;
    }
    
    bool inArea(int x,int y,int m,int n)
    {
        return x>=0&&x<m&&y>=0&&y<n;
    }
};

3.Leetcode1162 地图分析

3.1题目

3.2代码

class Solution {
    int d[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
public:
    int maxDistance(vector<vector<int>>& grid) {
        if(grid.size()<=0)
            return -1;
        int m = grid.size(),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] == 1)
                {
                    q.push(make_pair(i,j));   //多源入队
                }
                
            }
        }
        bool isocean = false;
        int x,y;                      //保存最后一次出队列的坐标
        while(!q.empty())
        {
            pair<int,int> temp = q.front();
            q.pop();
            x = temp.first;
            y = temp.second;            
            for(int k=0;k<4;k++)
            {
                int new_x = x + d[k][0];
                int new_y = y + d[k][1];
                if(inArea(new_x,new_y,m,n) && grid[new_x][new_y]  == 0)  //0代表flag
                {
                    isocean = true;
                    q.push(make_pair(new_x,new_y));
                    grid[new_x][new_y] = grid[x][y] + 1;
                    
                }
            }
          
        }        
        if(!isocean)
            return -1;
        return grid[x][y]-1;
        
    }
    
    bool inArea(int x,int y,int m,int n)
    {
        return x>=0 && y>=0 && x<m&& y<n;
    }
};