Number of Islands I & II

Given a boolean 2D matrix, find the number of islands.

Notice

0 is represented as the sea, 1 is represented as the island. If two 1 is adjacent, we consider them in the same island. We only consider up/down/left/right adjacent.

Example

Given graph:

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

return 3.

分析：

从第一个数到最后一个数，如果遇到1，则island count  加1， 并且不断递归去寻找周围的1。

 public class Solution {
     public int numIslands(char[][] grid) {
         int count = ;
         if (grid == null || grid.length == ) return count;

         int m = grid.length, n = grid[].length;
         boolean[][] visited = new boolean[m][n];

         for (int i = ; i < m; i++) {
             for (int j = ; j < n; j++) {
                 if (!visited[i][j] && grid[i][j] == '') {
                     count++;
                     flood(i, j, grid, visited);
                 }
             }
         }
         return count;
     }

     private void flood(int i, int j, char[][] grid, boolean[][] visited) {
         if (i <  || i >= grid.length || j <  || j >= grid[].length) return;
         if (grid[i][j] == '' || visited[i][j]) return;
         visited[i][j] = true;
         flood(i + , j, grid, visited);
         flood(i - , j, grid, visited);
         flood(i, j + , grid, visited);
         flood(i, j - , grid, visited);
     }
 } 

Follow up:

Find the perimeter of the island. Answer: find the # of 1 which is next to 0.

Number of Islands II

A 2d grid map of m rows and n columns is initially filled with water. We may perform an addLand operation which turns the water at position (row, col) into a land. Given a list of positions to operate, count the number of islands after each addLand operation. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example:

Given m = 3, n = 3, positions = [[0,0], [0,1], [1,2], [2,1]].
Initially, the 2d grid grid is filled with water. (Assume 0 represents water and 1 >represents land).

0 0 0
0 0 0
0 0 0

Operation #1: addLand(0, 0) turns the water at grid0 into a land.

1 0 0
0 0 0   Number of islands = 1
0 0 0

Operation #2: addLand(0, 1) turns the water at grid0 into a land.

1 1 0
0 0 0   Number of islands = 1
0 0 0

Operation #3: addLand(1, 2) turns the water at grid1 into a land.

1 1 0
0 0 1   Number of islands = 2
0 0 0

Operation #4: addLand(2, 1) turns the water at grid2 into a land.

1 1 0
0 0 1   Number of islands = 3
0 1 0

We return the result as an array: [1, 1, 2, 3]

分析：https://segmentfault.com/a/1190000004197552

很典型的union-find题。因为这里是动态的增加land，要能随时求出有多少个island，最简单的方法就是union-find。我们可以定义一个counter, 每增加一个land, 增加counter, 然后我们搜索那个land邻居区域，发现root不一样的话，意味着可以union, 每union一次，意味着两个island合并成一个，减小counter, 统计最终的counter值，即是增加land后的最终island的个数。

为了减小时间复杂度，代码实现是QuickUnion + Path Compression, Path Compression目的是为了调整树的高度，保持很平的树，而不是越来越高，这样找root不会出现worst case.

 public class Solution {
     public List<Integer> numIslands2(int m, int n, int[][] positions) {
         int[] id = new int[m * n]; // 表示各个index对应的root
         Arrays.fill(id, -); // 初始化root为-1，用来标记water, 非-1表示land

         List<Integer> res = new ArrayList<>();
         int count = ; // 记录island的数量
         int[][] dirs = { { -,  }, { ,  }, { ,  }, { , - } };

         for (int i = ; i < positions.length; i++) {
             count++;
             int index = positions[i][] * n + positions[i][];
             id[index] = index; // root初始化

             for (int j = ; j < dirs.length; j++) {
                 int x = positions[i][] + dirs[j][];
                 int y = positions[i][] + dirs[j][];
                 if (x >=  && x < m && y >=  && y < n && id[x * n + y] != -) {
                     int root = root(id, x * n + y); // this is the root of the neibor's islands
                     // 发现root不等的情况下，才union, 同时减小count。注意，一定要用当前index作为新的root，这样才能保证相连的岛是同一个root。
                     if (root != index) {
                         id[root] = index; // set the neighbor's island's root to be the new island index
                         count--;
                     }
                 }
             }
             res.add(count);
         }
         return res;
     }

     public int root(int[] id, int i) {
         while (i != id[i]) {
             id[i] = id[id[i]]; // 优化，为了减小树的高度
             i = id[i];
         }
         return i;
     }
 }