岛问题（感染过程）

题目描述;

一个矩阵中有0和1两种值，每个位置都可以和自己的上下左右四个位置相连，如果有一片1连成一片，这个部分叫做一个岛，求一个矩阵中有几个岛？

代码如下：

package demopacket;

import java.util.*;

public class Solution {
    public static void main(String[] args) {
        int[][] arr = {
                {0, 0, 1, 0, 1, 0},
                {1, 1, 1, 0, 1, 0},
                {1, 0, 0, 1, 0, 0},
                {0, 0, 0, 0, 0, 0}
        };
        int ans = countIslands(arr);
        System.out.println(ans);
    }


    public static int countIslands(int[][] arr) {
        if (arr == null || arr[0] == null) {
            return 0;
        }
        int n = arr.length;
        int m = arr[0].length;
        int ans = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (arr[i][j] == 1) {
                    ans++;
                    infect(arr, i, j, n, m);
                }
            }
        }
        return ans;
    }

    public static void infect(int[][] arr, int i, int j, int n, int m) {
        if (i < 0 || i >= n || j < 0 || j >= m || arr[i][j] != 1) {
            return;
        }
        arr[i][j] = 2;//i,j没有越界，并且arr[i][j]为1，感染相邻的变为2
        infect(arr, i + 1, j, n, m);
        infect(arr, i - 1, j, n, m);
        infect(arr, i, j + 1, n, m);
        infect(arr, i, j - 1, n, m);
    }

}

执行结果：3

695. 岛屿的最大面积

题目描述：

给定一个包含了一些 0 和 1 的非空二维数组 grid 。一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为 0 。)

注意: 给定的矩阵grid 的长度和宽度都不超过 50。

示例 1:

[[0,0,1,0,0,0,0,1,0,0,0,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,1,1,0,1,0,0,0,0,0,0,0,0],
 [0,1,0,0,1,1,0,0,1,0,1,0,0],
 [0,1,0,0,1,1,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,1,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,0,0,0,0,0,0,1,1,0,0,0,0]]

对于上面这个给定矩阵应返回 6。注意答案不应该是 11 ，因为岛屿只能包含水平或垂直的四个方向的 1 。

示例 2:
[[0,0,0,0,0,0,0,0]]
对于上面这个给定的矩阵, 返回 0。

代码如下：

class Solution {
    public int maxAreaOfIsland(int[][] arr) {
        if (arr == null || arr[0] == null) {
            return 0;
        }
        int n = arr.length;
        int m = arr[0].length;
        int ans = 0;
        int max = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (arr[i][j] == 1) {
                    List<Integer> list = new ArrayList<>();
                    infect(arr, i, j, n, m, list);
                    max = Math.max(max, list.size());
                }
            }
        }
        return max;
    }

    public static void infect(int[][] arr, int i, int j, int n, int m, List<Integer> list) {
        if (i < 0 || i >= n || j < 0 || j >= m || arr[i][j] != 1) {
            return;
        }
        arr[i][j] = 2;//i,j没有越界，并且arr[i][j]为1，感染相邻的变为2
        if (arr[i][j] == 2) {
            list.add(-1);
        }
        infect(arr, i + 1, j, n, m, list);
        infect(arr, i - 1, j, n, m, list);
        infect(arr, i, j + 1, n, m, list);
        infect(arr, i, j - 1, n, m, list);
    }
}

执行结果：

733. 图像渲染

有一幅以二维整数数组表示的图画，每一个整数表示该图画的像素值大小，数值在 0 到 65535 之间。

给你一个坐标 (sr, sc) 表示图像渲染开始的像素值（行 ，列）和一个新的颜色值 newColor，让你重新上色这幅图像。

为了完成上色工作，从初始坐标开始，记录初始坐标的上下左右四个方向上像素值与初始坐标相同的相连像素点，接着再记录这四个方向上符合条件的像素点与他们对应四个方向上像素值与初始坐标相同的相连像素点，……，重复该过程。将所有有记录的像素点的颜色值改为新的颜色值。

最后返回经过上色渲染后的图像。

示例 1:
输入:
image = [[1,1,1],[1,1,0],[1,0,1]]
sr = 1, sc = 1, newColor = 2
输出: [[2,2,2],[2,2,0],[2,0,1]]
解析:
在图像的正中间，(坐标(sr,sc)=(1,1)),
在路径上所有符合条件的像素点的颜色都被更改成2。
注意，右下角的像素没有更改为2，
因为它不是在上下左右四个方向上与初始点相连的像素点。

注意:
image 和 image[0] 的长度在范围 [1, 50] 内。
给出的初始点将满足 0 <= sr < image.length 和 0 <= sc < image[0].length。
image[i][j] 和 newColor 表示的颜色值在范围 [0, 65535]内。

代码如下：

class Solution {
    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
        int n = image.length;
        int m = image[0].length;
        int num = image[sr][sc];
        infect(image, sr, sc, n, m, num);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (image[i][j] == -1) {
                    image[i][j] = newColor;
                }
            }
        }
        return image;
    }
    
    public static void infect(int[][] grid, int row, int col, int n, int m, int num) {
        if (row < 0 || row >= n || col < 0 || col >= m || grid[row][col] != num) {
            return;
        }
        grid[row][col] = -1;
        infect(grid, row + 1, col, n, m, num);
        infect(grid, row - 1, col, n, m, num);
        infect(grid, row, col + 1, n, m, num);
        infect(grid, row, col - 1, n, m, num);
    }
}

执行结果：

463. 岛屿的周长

给定一个 row x col 的二维网格地图 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

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

代码如下：

class Solution {
    public int islandPerimeter(int[][] grid) {
        int m = 0, n = 0;
        if (grid == null || (m = grid.length) == 0 || (n = grid[0].length) == 0) {
            return 0;
        }
        int count = 0; // 岛屿格子数量
        int edge = 0; // 岛屿格子之间的相邻边
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0) {
                    continue;
                }
                count++;
                if (j + 1 < n && grid[i][j + 1] == 1) {
                    edge++; // 判断右边是不是 陆地格子
                }
                if (i + 1 < m && grid[i + 1][j] == 1) {
                    edge++; // 判断下面是不是 陆地格子
                }
            }
        }
        return 4 * count - 2 * edge;
    }
}

执行结果：

1034. 边界着色

给你一个大小为 m x n 的整数矩阵 grid ，表示一个网格。另给你三个整数 row、col 和 color 。网格中的每个值表示该位置处的网格块的颜色。

当两个网格块的颜色相同，而且在四个方向中任意一个方向上相邻时，它们属于同一 连通分量 。

连通分量的边界 是指连通分量中的所有与不在分量中的网格块相邻（四个方向上）的所有网格块，或者在网格的边界上（第一行/列或最后一行/列）的所有网格块。

请你使用指定颜色 color 为所有包含网格块 grid[row][col] 的 连通分量的边界 进行着色，并返回最终的网格 grid 。

示例 1：
输入：grid = [[1,1],[1,2]], row = 0, col = 0, color = 3
输出：[[3,3],[3,2]]

示例 2：
输入：grid = [[1,2,2],[2,3,2]], row = 0, col = 1, color = 3
输出：[[1,3,3],[2,3,3]]

示例 3：
输入：grid = [[1,1,1],[1,1,1],[1,1,1]], row = 1, col = 1, color = 2
输出：[[2,2,2],[2,1,2],[2,2,2]]

提示：
m == grid.length
n == grid[i].length
1 <= m, n <= 50
1 <= grid[i][j], color <= 1000
0 <= row < m
0 <= col < n

class Solution {
    public int[][] colorBorder(int[][] grid, int row, int col, int color) {
        int n = grid.length;
        int m = grid[0].length;
        int num = grid[row][col];
        int[][] ints = new int[n][m];
        int[][] nums = new int[n][m];
        for (int i = 0; i < n; i++) {
            System.arraycopy(grid[i], 0, ints[i], 0, m);
        }
        for (int i = 0; i < n; i++) {
            System.arraycopy(grid[i], 0, nums[i], 0, m);
        }
        infect(grid, row, col, n, m, num);
        infect(ints, row, col, n, m, num);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (i > 0 && i < n - 1 && j > 0 && j < m - 1) {
                    if (grid[i - 1][j] == -1 && grid[i + 1][j] == -1 && grid[i][j - 1] == -1 && grid[i][j + 1] == -1) {
                        ints[i][j] = nums[i][j];
                    }
                }
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (ints[i][j] == -1) {
                    ints[i][j] = color;
                }
            }
        }
        return ints;
    }

    public static void infect(int[][] grid, int row, int col, int n, int m, int num) {
        if (row < 0 || row >= n || col < 0 || col >= m || grid[row][col] != num) {
            return;
        }
        grid[row][col] = -1;
        infect(grid, row + 1, col, n, m, num);
        infect(grid, row - 1, col, n, m, num);
        infect(grid, row, col + 1, n, m, num);
        infect(grid, row, col - 1, n, m, num);
    }
}

执行结果：