LeetCode题目笔记——463. 岛屿的周长，/C++

题目描述

给定一个 row x col 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0
表示水域。

网格中的格子 水平和垂直
方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。

岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100
。计算这个岛屿的周长。

来源：力扣（LeetCode） 链接：https://leetcode.cn/problems/island-perimeter
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目难度——简单

方法一：迭代

  根据提示可以发现整个grid最大也就100×100，就是10000个格子，因此我们可以直接迭代的来求解。每个格子有4条边，如果有相邻的格子的话，有一条边就被计数了两次，因此我们要减去因为这一个相邻带来的多两次计数，所以，我们可以遍历grid，计数格子的数量N以及它们之间相邻的计数M。最后我们返回N4-M2就行。

代码

class Solution {
public:
    int islandPerimeter(vector<vector<int>>& grid) {
        int row, col, countInter, counter1;
        row = grid.size();
        col = grid[0].size();
        countInter = 0;
        counter1 = 0;
        //计数横着的格子相邻次数
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col - 1; j++){
                if ((grid[i][j] & grid[i][j + 1]) == 1){
                    countInter++;
                }
            }
        }
        //竖着格子相邻计数
        for(int j = 0; j < col; j++){
            for(int i = 0; i < row - 1; i++){
                if((grid[i][j] & grid[i + 1][j]) == 1){
                    countInter++;
                }
            }
        }
        //格子的数量
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if (grid[i][j] == 1){
                    counter1++;
                }
            }
        }
        return counter1 * 4 - countInter * 2;
    }
};

  上面这个代码很慢，注意到上面用了3次二重循环，很显然做了很多重复工作，那么怎么把他们融合到一个二重循环里去，同时进行格子计数和相邻边的计数呢。很简单，我们只需要判断位置[i][j]上的是不是格子，然后判断这个格子的上下左右是不是也为格子就行。

class Solution {
public:
    int islandPerimeter(vector<vector<int>>& grid) {
        int row, col, countInter, counter1;
        row = grid.size();
        col = grid[0].size();
        countInter = 0;
        counter1 = 0;
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(grid[i][j] == 0){
                    continue;
                }
                //else the grid[i][j] is 1
                counter1++;
                // if [i][j] is inter with upper one
                if(i > 0 && grid[i - 1][j] == 1){
                    countInter++;
                }
                //beneath
                if(i < row - 1 && grid[i + 1][j] == 1){
                    countInter++;
                }
                //left
                if(j > 0 && grid[i][j - 1] == 1){
                    countInter++;
                }
                //right
                if(j < col - 1 && grid[i][j + 1] == 1){
                    countInter++;
                } 
            }
        }
        return counter1 * 4 - countInter;
    }
};

方法二：深度优先遍历DFS

  可以用深度优先的思路来解决，但这种方法消耗的空间更多，但因为其不会访问到全部格子，所以相对来说计算量会少一些，当然也就更快。排在前面的方法几乎都是深度优先遍历。这里给出官方题解的代码。

代码

class Solution {
    constexpr static int dx[4] = {0, 1, 0, -1};
    constexpr static int dy[4] = {1, 0, -1, 0};
public:
    int dfs(int x, int y, vector<vector<int>> &grid, int n, int m) {
        if (x < 0 || x >= n || y < 0 || y >= m || grid[x][y] == 0) {
            return 1;
        }
        if (grid[x][y] == 2) {
            return 0;
        }
        grid[x][y] = 2;
        int res = 0;
        for (int i = 0; i < 4; ++i) {
            int tx = x + dx[i];
            int ty = y + dy[i];
            res += dfs(tx, ty, grid, n, m);
        }
        return res;
    }
    int islandPerimeter(vector<vector<int>> &grid) {
        int n = grid.size(), m = grid[0].size();
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (grid[i][j] == 1) {
                    ans += dfs(i, j, grid, n, m);
                }
            }
        }
        return ans;
    }
};

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/island-perimeter/solution/dao-yu-de-zhou-chang-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

总结

  第一种方法不可避免的要遍历所有格子，所以时间是O(MN)，只用到了常数个额外变量，所以空间是O(1)。第二种方法DFS因为用到了递归，所以时间也是O(MN)，空间在最坏情况下也是O(MN)。