计算岛屿的周长(Java)

给定一个 m x n 的二维网格地图 grid ，其中：grid[i][j] = 1 表示陆地， grid[i][j] = 0 表示水域。
网格中的格子水平和垂直方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。
岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。

示例 1：

输入：grid = [[0,1,0,0],[1,1,1,0],[0,1,0,0],[1,1,0,0]]
输出：16
解释：它的周长是上面图片中的 16 个黄色的边

示例 2：
输入：grid = [[1]]
输出：4

示例 3：
输入：grid = [[1,0]]
输出：4

提示：
m == grid.length
n == grid[i].length
1 <= m, n <= 100
grid[i][j] 为 0 或 1

 

package com.loo;

public class IslandPerimeter {
    
    public static int[] DX = new int[] {1 , 0 , -1 , 0};
    public static int[] DY = new int[] {0 , 1 , 0 , -1};

    public static void main(String[] args) {
        int[][] grid1 = new int[][] {
            {0,1,0,0},
            {1,1,1,0},
            {0,1,0,0},
            {1,1,0,0}
        };
        int[][] grid2 = new int[][] {{1}};
        int[][] grid3 = new int[][] {{1 , 0}};
        System.out.println(getIslandPerimeter(grid1));
        System.out.println(getIslandPerimeter(grid2));
        System.out.println(getIslandPerimeter(grid3));
        
        System.out.println(getIslandPerimeter2(grid1));
        System.out.println(getIslandPerimeter2(grid2));
        System.out.println(getIslandPerimeter2(grid3));
    }
    
    // 迭代。对于一个陆地格子的每条边，它被算作岛屿的周长当且仅当这条边为网格的边界或者相邻的另一个格子为水域。 
    // 因此，可以遍历每个陆地格子，看其四个方向是否为边界或者水域，如果是，将这条边的贡献（即 1）加入答案 count 中即可。
    public static int getIslandPerimeter(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int count = 0;
        for (int i=0;i<m;i++) {
            for (int j=0;j<n;j++) {
                if (grid[i][j] == 1) {
                    int cnt = 0;
                    for (int k=0;k<4;k++) {
                        int tx = i + DX[k];
                        int ty = j + DY[k];
                        if (tx<0 || tx>=m || ty<0 || ty>=n || grid[tx][ty]==0) {
                            cnt += 1;
                        }
                    }
                    count += cnt;
                }
            }
        }
        return count;
    }
    
    // 深度优先.
    // 为了防止陆地格子在深度优先搜索中被重复遍历导致死循环，将遍历过的陆地格子标记为已经遍历过，
    // 下面的代码中我们设定值为 -1 的格子为已经遍历过的陆地格子。
    public static int getIslandPerimeter2(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int count = 0;
        for (int i=0;i<m;i++) {
            for (int j=0;j<n;j++) {
                if (grid[i][j] == 1) {
                    count += dfs(grid , i , j , m , n);
                }
            }
        }
        return count;
    }
    
    public static int dfs(int[][] grid , int x , int y , int m , int n) {
        if (x<0 || x>=m || y<0 || y>=n || grid[x][y]==0) {
            return 1;
        }
        if (grid[x][y]==-1) {
            return 0;
        }
        grid[x][y] = -1;
        int count = 0;
        for (int k=0;k<4;k++) {
            int tx = x + DX[k];
            int ty = y + DY[k];
            count += dfs(grid , tx , ty , m , n);
        }
        return count;
    }

}