LeetCode 地图分析

题目

题目链接

思路

这道题的大意是对于每一个海洋区域，求出它到陆地的最短距离，然后取求出的这些距离的最大值；
可以遍历地图中的每一个元素，如果是海洋，则去找它到最近陆地的距离；如果是陆地，则不用管；
如何去找海洋到陆地的最短距离，可以用BFS的思想，借助队列实现；
在BFS的过程中，如果需要知道一个元素是在第几次被遍历的，可以用一个变量cnt记录，
每次查看当前队列中的元素个数，这些元素一定是上一轮入队的，然后循环这么多次，就到了下一轮，cnt++；

代码

class Solution {
public:
    int row, col;//记录行数和列数
    bool vis[100][100];//判断一个元素是否被查看过
    int x[4] = {0, 1, 0, -1}, y[4] = {1, 0, -1, 0};
    int solve(int i, int j, vector<vector<int>>& grid){
        int res = 0;//记录在第几次找到
        memset(vis, false, sizeof(vis));
        queue<pair<int, int>> Q;
        Q.push(make_pair(i, j));
        while(!Q.empty()){
            int cnt = Q.size();//每次查询上一轮入队的元素个数
            for(int k = 0; k < cnt; k ++){
                pair<int, int> ele = Q.front();//取出队首元素
                Q.pop();
                for(int c= 0; c < 4; c ++){
                    //先判断位置是否合法，不合法直接下一个判断
                    int x0 = ele.first + x[c], y0 = ele.second + y[c];
                    if(x0 < 0 || x0 > col || y0 < 0 || y0 > row) continue;
                    //如果找到一个陆地
                    if(grid[x0][y0] == 1) return res + 1;
                    else if(vis[x0][y0] == false){
                        Q.push(make_pair(x0,y0));//元素入队
                        vis[x0][y0] = true;//标记为已读
                    } 
                }
            }
            res++;//循环步骤加一
        }
        return -1;
    }
    int maxDistance(vector<vector<int>>& grid) {
        row = grid.size() - 1, col = grid[0].size() - 1;
        int ans = -1;
        for(int i = 0; i <= row; i ++){
            for(int j = 0; j <= col; j ++){
                if(grid[i][j] == 0){
                    int dis = solve(i, j, grid);
                    ans = max(ans, dis);
                }
            }
        }
        return ans;
    }
};

其实还可以为每个节点带一个第几次访问到的属性，代码更简洁一些；
但是耗时都差不多，看官方用到了多源最短路，等学到图了再来看看会不会快一点~~~~

struct node{
    int x, y, m;
    node(int x0, int y0, int m0){
        x = x0;
        y = y0;
        m = m0;
    }
};
class Solution {
public:
    int row, col;
    bool vis[100][100];
    int x[4] = {0, 1, 0, -1}, y[4] = {1, 0, -1, 0};
    int solve(int i, int j, vector<vector<int>>& grid){
        memset(vis, false, sizeof(vis));
        queue<node> Q;
        Q.push(node(i, j, 0));
        while(!Q.empty()){
            node ele = Q.front();
            Q.pop();
            for(int c= 0; c < 4; c ++){
                //先判断位置是否合法
                int x0 = ele.x + x[c], y0 = ele.y + y[c];
                if(x0 < 0 || x0 > col || y0 < 0 || y0 > row) continue;
                if(grid[x0][y0] == 1) return ele.m + 1;
                else if(vis[x0][y0] == false){
                    Q.push(node(x0, y0, ele.m + 1));
                    vis[x0][y0] = true;
                } 
            }
        }
        return -1;
    }
    int maxDistance(vector<vector<int>>& grid) {
        row = grid.size() - 1, col = grid[0].size() - 1;
        int ans = -1;
        for(int i = 0; i <= row; i ++){
            for(int j = 0; j <= col; j ++){
                if(grid[i][j] == 0){
                    int dis = solve(i, j, grid);
                    ans = max(ans, dis);
                }
            }
        }
        return ans;
    }
};