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 grid[0][0] 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 grid[0][1] 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 grid[1][2] 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 grid[2][1] 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] Challenge: Can you do it in time complexity O(k log mn), where k is the length of the positions?
Union Find
Princeton's lecture note on Union Find in Algorithms and Data Structures It is a well organized note with clear illustration describing from the naive QuickFind to the one with Weighting and Path compression. With Weighting and Path compression, The algorithm runs in
O((M+N) log* N) where M is the number of operations ( unite and find ), N is the number of objects, log* is iterated logarithm while the naive runs in O(MN).
方法一： Union Find based on Quick Find
我覺得：Union復雜度： O(M*N), where M is the number of calls of Union, and N is the size of id array, in our case N=m*n
Find復雜度： O(1)
實際運行時間199ms
1 public class Solution { 2 public List<Integer> numIslands2(int m, int n, int[][] positions) { 3 int[][] dirs = new int[][]{{-1,0},{1,0},{0,1},{0,-1}}; 4 unionFind uf = new unionFind(m*n); 5 List<Integer> res = new ArrayList<Integer>(); 6 for (int[] pos : positions) { 7 int cur = pos[0]*n + pos[1]; 8 uf.ids[cur] = cur; 9 uf.count++; 10 for (int[] dir : dirs) { 11 int x = dir[0] + pos[0]; 12 int y = dir[1] + pos[1]; 13 int nb = x*n+y; 14 if (x<0 || x>=m || y<0 || y>=n || uf.ids[nb]==-1) continue; 15 if (uf.find(nb) != uf.find(cur)) { 16 uf.union(nb, cur); 17 } 18 } 19 res.add(uf.count); 20 } 21 return res; 22 } 23 24 public class unionFind { 25 int[] ids; 26 int count; 27 public unionFind(int num) { 28 this.ids = new int[num]; 29 Arrays.fill(ids, -1); 30 this.count = 0; 31 } 32 public int find(int num) { 33 return ids[num]; 34 } 35 public boolean union(int n1, int n2) { 36 int id1=ids[n1], id2=ids[n2]; 37 if (id1 != id2) { 38 for (int i=0; i<ids.length; i++) { 39 if (ids[i] == id2) { 40 ids[i] = id1; 41 } 42 } 43 count--; 44 return true; 45 } 46 return false; 47 } 48 } 49 }
Faster Union Find方法2：Union Find Based on Quick Union 參考：https://leetcode.com/discuss/69572/easiest-java-solution-with-explanations
Quick Union is Faster than Quick Find
The idea is simple. To represent a list of islands, we use trees. i.e., a list of roots. This helps us find the identifier of an island faster. If roots[c] = p means the parent of node c is p, we can climb up the parent chain to find out the identifier of an island, i.e., which island this point belongs to:
Do root[root[roots[c]]]... until root[c] == c; To transform the two dimension problem into the classic UF, perform a linear mapping:
int id = n * x + y; Initially assume every cell are in non-island set {-1}. When point A is added, we create a new root, i.e., a new island. Then, check if any of its 4 neighbors belong to the same island. If not,union the neighbor by setting the root to be the same. Remember to skip non-island cells.
我覺得：Union復雜度： O(M*logN), where M is the number of calls of Union, and N is the size of id array, in our case N=m*n
Find復雜度： O(logN)
實際運行28ms
1 public class Solution {
2 public List<Integer> numIslands2(int m, int n, int[][] positions) {
3 int[][] dirs = new int[][]{{-1,0},{1,0},{0,1},{0,-1}};
4 unionFind uf = new unionFind(m*n);
5 List<Integer> res = new ArrayList<Integer>();
6 for (int[] pos : positions) {
7 int cur = pos[0]*n + pos[1];
8 uf.ids[cur] = cur;
9 uf.count++;
10 for (int[] dir : dirs) {
11 int x = dir[0] + pos[0];
12 int y = dir[1] + pos[1];
13 int nb = x*n+y;
14 if (x<0 || x>=m || y<0 || y>=n || uf.ids[nb]==-1) continue;
15 int rootNb = uf.root(nb);
16 int rootCur = uf.root(cur);
17 if (rootCur != rootNb) { //not connect
18 uf.union(rootCur, rootNb);
19 uf.count--;
20 }
21 }
22 res.add(uf.count);
23 }
24 return res;
25 }
26
27 public class unionFind { //ids[]記錄上一跳pos，root記錄最上面的pos,union（i, j）修改i的root的上一跳為j的root
28 int[] ids;
29 int count;
30 public unionFind(int num) {
31 this.ids = new int[num];
32 Arrays.fill(ids, -1);
33 this.count = 0;
34 }
35
36 public int root(int i) { //FIND operation is proportional to the depth of the tree.the average running time is O(logN)
37 while (ids[i] != i) i = ids[i];
38 return i;
39 }
40
41 public boolean isConnected(int i, int j) {
42 return root(i) == root(j);
43 }
44
45 public void union(int i, int j) {
46 int iRoot = root(i);
47 int jRoot = root(j);
48 ids[iRoot] = jRoot;
49 }
50 }
51 }
Summary of Union Find:
Princeton's lecture note on Union Find
Quick Find
Quick Union
Here is a very easy understanding video by Stanford(看3:00開始的例子，非常簡單， 一看就懂)
Compare of Fast Find & Fast Union, though worst case time complexity is almost the same, fast union is faster than fast find
