LeetCode小算法记录（七十六）岛屿数量
给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。
示例 1:
输入:
11110
11010
11000
00000
输出: 1
示例 2:
输入:
11000
11000
00100
00011
输出: 3
解释: 每座岛屿只能由水平和/或竖直方向上相邻的陆地连接而成。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-islands
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package leetCodeTest;
import java.util.Arrays;
public class 岛屿数量 {
public static void main(String[] args) {
char[][] grid = new char[][]{
{'1','1','1','1','0'},
{'1','1','0','0','0'},
{'1','1','0','1','0'},
{'0','0','1','1','1'}};
int i = numIslands(grid);
System.out.println("i = " + i);
}
/**
* 并查集，
* 首先记录所有值为1的位置的总数为count。
* 将等于一的位置指向于最先遇到的一的位置，即如下所示集合
* 1 1 0
* 1 0 0
* 0 1 1
* 则有以下指向,
* 1 ← 1 0
*↑
* 1 0 0
* 0 1 ← 1
* 然后每多出一次指向就减少一次count值即可，当遍历时遇到0则不减少count，
* 所以最后的count值就是所得结果。
*/
// static class UnionFind {
// int count;
// //表示指向的数组，每一位的值表示当前位指向哪个位置（初始时都指向自己）
// //该数组经过拉伸处理，即将原数组从左上横向遍历到右下每个值分别存入该数组，
// // 形成新的一行数组（就是将原来的二维数组按照横纵坐标转换为一维数组。方便之后存储指向位置）
// int[] parent;
// //表示根节点的数组，
// // 即标识每一组指向的节点（当某一位置的值为一的时候表示该位置是一个根节点）
// int[] rank;
//
// public UnionFind(char[][] grid) {
// count = 0;
// int m = grid.length;
// int n = grid[0].length;
// parent = new int[m * n];
// rank = new int[m * n];
// for (int i = 0; i < m; ++i) {
// for (int j = 0; j < n; ++j) {
// if (grid[i][j] == '1') {
// parent[i * n + j] = i * n + j;
// ++count;
// }
// rank[i * n + j] = 0;
// }
// }
// }
//
// public int find(int i) {
// if (parent[i] != i) parent[i] = find(parent[i]);
// return parent[i];
// }
//
// public void union(int x, int y) {
// int rootx = find(x);
// int rooty = find(y);
// if (rootx != rooty) {
// if (rank[rootx] > rank[rooty]) {
// parent[rooty] = rootx;
// } else if (rank[rootx] < rank[rooty]) {
// parent[rootx] = rooty;
// } else {
// parent[rooty] = rootx;
// rank[rootx] += 1;
// }
// --count;
// }
// }
//
// public int getCount() {
// return count;
// }
// }
//
// public static int numIslands(char[][] grid) {
// if (grid == null || grid.length == 0) {
// return 0;
// }
//
// int nr = grid.length;
// int nc = grid[0].length;
// UnionFind uf = new UnionFind(grid);
// System.out.println(Arrays.toString(uf.parent));
// System.out.println(Arrays.toString(uf.rank));
// for (int r = 0; r < nr; ++r) {
// for (int c = 0; c < nc; ++c) {
// if (grid[r][c] == '1') {
// grid[r][c] = '0';
// if (r - 1 >= 0 && grid[r-1][c] == '1') {
// uf.union(r * nc + c, (r-1) * nc + c);
// }
// if (r + 1 < nr && grid[r+1][c] == '1') {
// uf.union(r * nc + c, (r+1) * nc + c);
// }
// if (c - 1 >= 0 && grid[r][c-1] == '1') {
// uf.union(r * nc + c, r * nc + c - 1);
// }
// if (c + 1 < nc && grid[r][c+1] == '1') {
// uf.union(r * nc + c, r * nc + c + 1);
// }
// }
// }
// }
// System.out.println(Arrays.toString(uf.parent));
// System.out.println(Arrays.toString(uf.rank));
// return uf.getCount();
// }
/**
* 传统的bfs算法
* @param grid
* @return
*/
private static int result = 0;
private static int m;
private static int n;
public static int numIslands(char[][] grid) {
if (grid == null || grid.length == 0 || grid[0].length == 0)
return 0;
int i,j;
m = grid.length;
n = grid[0].length;
for (i=0;i= m || j >= m) return;
if (grid[i][j] == '0') return;
grid[i][j] = '0';
dfs(grid, i-1, j);
dfs(grid, i+1, j);
dfs(grid, i, j-1);
dfs(grid, i, j+1);
}
}