58.洪水填充

思想

洪水填充是一种很简单的技巧，设置路径信息进行剪枝和统计，类似感染的过程

路径信息不撤销，来保证每一片的感染过程可以得到区分

看似是暴力递归过程，其实时间复杂度非常好，遍历次数和样本数量的规模一致
（图的dfs遍历+感染）

题目1、岛屿数量

问题描述：
给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成
此外，你可以假设该网格的四条边均被水包围

测试链接 :
https://leetcode.cn/problems/number-of-islands/

算法思想：
将图的每个节点都判断，如果当前节点是1，就代表当前是一片陆地（陆地数量++），然后用dfs将这个1的相链的1全感染成0

代码如下：

public class Code01_NumberOfIslands {

	// 洪水填充的做法
	// board : n * m
	// O(n*m)最优解！
	public static int numIslands(char[][] board) {
		int n = board.length;
		int m = board[0].length;
		int islands = 0;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (board[i][j] == '1') {
					islands++;
					dfs(board, n, m, i, j);
				}
			}
		}
		return islands;
	}

	public static void dfs(char[][] board, int n, int m, int i, int j) {
		if (i < 0 || i == n || j < 0 || j == m || board[i][j] != '1') {
			return;
		}
		// board[i][j] = '1'
		board[i][j] = 0;
		dfs(board, n, m, i - 1, j);
		dfs(board, n, m, i + 1, j);
		dfs(board, n, m, i, j - 1);
		dfs(board, n, m, i, j + 1);
	}

}

题目2、被围绕的区域

问题描述：
给你一个 m x n 的矩阵 board ，由若干字符 ‘X’ 和 ‘O’ ，找到所有被 ‘X’ 围绕的区域
并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。

测试链接 :
https://leetcode.cn/problems/surrounded-regions/

算法思想：
从最外层的边界开始判断，如果边界是“O”，则将“O”改成“F”，并且将它连着的“O”全部感染成“F”。
此时再遍历一次矩阵，这时的“O”一定是被“X”围住的，我们只需将“O”变为“X”。再遍历一次矩阵，“F”变回“O”即可

代码如下：

public class Code02_SurroundedRegions {

	public static void solve(char[][] board) {
		int n = board.length;
		int m = board[0].length;
		//最外层感染
		for (int j = 0; j < m; j++) {
			if (board[0][j] == 'O') {
				dfs(board, n, m, 0, j);
			}
			if (board[n - 1][j] == 'O') {
				dfs(board, n, m, n - 1, j);
			}
		}
		for (int i = 1; i < n - 1; i++) {
			if (board[i][0] == 'O') {
				dfs(board, n, m, i, 0);
			}
			if (board[i][m - 1] == 'O') {
				dfs(board, n, m, i, m - 1);
			}
		}
		//'O'填'X' 'F'填'0'
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (board[i][j] == 'O') {
					board[i][j] = 'X';
				}
				if (board[i][j] == 'F') {
					board[i][j] = 'O';
				}
			}
		}
	}

	public static void dfs(char[][] board, int n, int m, int i, int j) {
		if (i < 0 || i == n || j < 0 || j == m || board[i][j] != 'O') {
			return;
		}
		board[i][j] = 'F';
		dfs(board, n, m, i + 1, j);
		dfs(board, n, m, i - 1, j);
		dfs(board, n, m, i, j + 1);
		dfs(board, n, m, i, j - 1);
	}

}

题目3、最大人工岛

问题描述：
给你一个大小为 n * n 二进制矩阵 grid 。最多 只能将一格 0 变成 1 。
返回执行此操作后，grid 中最大的岛屿面积是多少？
岛屿 由一组上、下、左、右四个方向相连的 1 形成

测试链接 :
https://leetcode.cn/problems/making-a-large-island/

算法思想：
首先遍历一边矩阵，将岛都给他来一个编号。使用sizes数组来存放第i号到面积是多大。然后讨论所有的0，变成1，能带来的最大岛的大小

代码如下：

public class Code03_MakingLargeIsland {

	public static int largestIsland(int[][] grid) {
		int n = grid.length;
		int m = grid[0].length;
		int id = 2;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (grid[i][j] == 1) {
					dfs(grid, n, m, i, j, id++);
				}
			}
		}
		int[] sizes = new int[id];
		int ans = 0;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (grid[i][j] > 1) {
					ans = Math.max(ans, ++sizes[grid[i][j]]);
				}
			}
		}
		// 讨论所有的0，变成1，能带来的最大岛的大小
		boolean[] visited = new boolean[id];
		int up, down, left, right, merge;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (grid[i][j] == 0) {
					up = i > 0 ? grid[i - 1][j] : 0;
					down = i + 1 < n ? grid[i + 1][j] : 0;
					left = j > 0 ? grid[i][j - 1] : 0;
					right = j + 1 < m ? grid[i][j + 1] : 0;
					visited[up] = true;
					merge = 1 + sizes[up];
					if (!visited[down]) {
						merge += sizes[down];
						visited[down] = true;
					}
					if (!visited[left]) {
						merge += sizes[left];
						visited[left] = true;
					}
					if (!visited[right]) {
						merge += sizes[right];
						visited[right] = true;
					}
					ans = Math.max(ans, merge);
					visited[up] = false;
					visited[down] = false;
					visited[left] = false;
					visited[right] = false;
				}
			}
		}
		return ans;
	}

	
	public static void dfs(int[][] grid, int n, int m, int i, int j, int id) {
		if (i < 0 || i == n || j < 0 || j == m || grid[i][j] != 1) {
			return;
		}
		//  grid[i][j] == 1
		grid[i][j] = id;
		dfs(grid, n, m, i - 1, j, id);
		dfs(grid, n, m, i + 1, j, id);
		dfs(grid, n, m, i, j - 1, id);
		dfs(grid, n, m, i, j + 1, id);
	}

}

题目4、打砖块

问题描述：
有一个 m * n 的二元网格 grid ，其中 1 表示砖块，0 表示空白
砖块 稳定（不会掉落）的前提是：
一块砖直接连接到网格的顶部，或者
至少有一块相邻（4 个方向之一）砖块 稳定 不会掉落时
给你一个数组 hits ，这是需要依次消除砖块的位置
每当消除 hits[i] = (rowi, coli) 位置上的砖块时，对应位置的砖块（若存在）会消失
然后其他的砖块可能因为这一消除操作而 掉落
一旦砖块掉落，它会 立即 从网格 grid 中消失（即，它不会落在其他稳定的砖块上）
返回一个数组 result ，其中 result[i] 表示第 i 次消除操作对应掉落的砖块数目。
注意，消除可能指向是没有砖块的空白位置，如果发生这种情况，则没有砖块掉落。

测试链接 :
https://leetcode.cn/problems/bricks-falling-when-hit/

算法思想：
1.炮弹所在位置矩阵数值-1
2.洪水填充天花板
3.时光倒流处理炮弹（从底向上考察当前炮弹如果+1能不能吧天花板接上）

代码如下：

public class Code04_BricksFallingWhenHit {

	public static int n, m;

	public static int[][] grid;

	public static int[] hitBricks(int[][] g, int[][] h) {
		grid = g;
		n = g.length;
		m = g[0].length;
		int[] ans = new int[h.length];
		if (n == 1) {
			return ans;
		}
		for (int[] hit : h) {
			grid[hit[0]][hit[1]]--;
		}
		for (int i = 0; i < m; i++) {
			dfs(0, i);
		}
		for (int i = h.length - 1, row, col; i >= 0; i--) {
			row = h[i][0];
			col = h[i][1];
			grid[row][col]++;
			if (worth(row, col)) {
				ans[i] = dfs(row, col) - 1;
			}
		}
		return ans;
	}

	// 从(i,j)格子出发，遇到1就感染成2
	// 统计新增了几个2！
	public static int dfs(int i, int j) {
		if (i < 0 || i == n || j < 0 || j == m || grid[i][j] != 1) {
			return 0;
		}
		grid[i][j] = 2;
		return 1 + dfs(i + 1, j) + dfs(i, j + 1) + dfs(i - 1, j) + dfs(i, j - 1);
	}

	public static boolean worth(int i, int j) {
		return grid[i][j] == 1
				&&
				(i == 0
				|| (i > 0 && grid[i - 1][j] == 2)
				|| (i < n - 1 && grid[i + 1][j] == 2)
				|| (j > 0 && grid[i][j - 1] == 2)
				|| (j < m - 1 && grid[i][j + 1] == 2));
	}

}