edit 200

Author: fishercoder1534

README.md

@@ -408,7 +408,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |203|[Remove Linked List Elements](https://leetcode.com/problems/remove-linked-list-elements/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_203.java)| O(n)|O(1) | Easy
 |202|[Happy Number](https://leetcode.com/problems/happy-number/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_202.java)| O(k)|O(k) | Easy
 |201|[Bitwise AND of Numbers Range](https://leetcode.com/problems/bitwise-and-of-numbers-range/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_201.java)| O(min(m,n))|O(1) | Medium | Bit Manipulation
-|200|[Number of Islands](https://leetcode.com/problems/number-of-islands/)|[Union Find](../master/src/main/java/com/fishercoder/solutions/_200UnionFind.java) [DFS](../master/MEDIUM/src/medium/_200DFS.java)| O(m*n)|O(m*n) | Medium| Union Find, DFS
+|200|[Number of Islands](https://leetcode.com/problems/number-of-islands/)|[Solution](../master/MEDIUM/src/medium/_200.java)| O(m*n)|O(m*n) | Medium| Union Find, DFS
 |199|[Binary Tree Right Side View](https://leetcode.com/problems/binary-tree-right-side-view/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_199.java)| O(n)|O(n)| Medium | BFS 
 |198|[House Robber](https://leetcode.com/problems/house-robber/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_198.java)| O(n)|O(n)| Easy | DP
 |191|[Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_191.java)| O(n)|O(1)| Easy | Bit Manipulation

src/main/java/com/fishercoder/solutions/_200.java

@@ -0,0 +1,116 @@
+package com.fishercoder.solutions;
+
+/**
+ * 200. Number of Islands
+ * Given a 2d grid map of '1's (land) and '0's (water),
+ * count the number of islands.
+ * 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 1:
+
+ 11110
+ 11010
+ 11000
+ 00000
+ Answer: 1
+
+ Example 2:
+
+ 11000
+ 11000
+ 00100
+ 00011
+ Answer: 3
+
+ */
+public class _200 {
+
+    public static class DFSSolution {
+
+        public int numIslands(char[][] grid) {
+            if (grid == null || grid.length == 0) return 0;
+            int count = 0;
+            int m = grid.length, n = grid[0].length;
+            for (int i = 0; i < m; i++) {
+                for (int j = 0; j < n; j++) {
+                    if (grid[i][j] == '1') {
+                        count++;
+                        dfs(grid, i, j, m, n);
+                    }
+                }
+            }
+            return count;
+        }
+
+        void dfs(char[][] grid, int i, int j, int m, int n) {
+            if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == '0') return;
+            grid[i][j] = '0';
+            dfs(grid, i + 1, j, m, n);
+            dfs(grid, i, j + 1, m, n);
+            dfs(grid, i - 1, j, m, n);
+            dfs(grid, i, j - 1, m, n);
+        }
+    }
+
+    public static class UnionFindSolution {
+
+        class UnionFind{
+            int count;
+            int m, n;
+            int[] ids;
+
+            public UnionFind(char[][] grid){
+                m = grid.length;
+                n = grid[0].length;
+                ids = new int[m*n];
+                for(int i = 0; i < m; i++){
+                    for(int j = 0; j < n; j++){
+                        if(grid[i][j] == '1') {
+                            count++;
+                            ids[i*n+j] = i*n+j;
+                        }
+                    }
+                }
+            }
+
+            public void union(int i, int j){
+                int x = find(ids, i);
+                int y = find(ids, j);
+                if(x != y) {/**note: this is when x != y,
+                 only in this case, we should union these two nodes, which makes sense naturally.*/
+                    count--;
+                    ids[x] = y;//ids[y] = x; //also works
+                }
+            }
+
+            public int find(int[] ids, int i){
+                if(ids[i] == i) return i;
+                return find(ids, ids[i]);
+            }
+        }
+
+        public int numIslands(char[][] grid) {
+            if(grid == null || grid.length == 0 || grid[0].length == 0) return 0;
+            int[] dirs = new int[]{0,1,0,-1,0};
+            UnionFind uf = new UnionFind(grid);
+            int m = grid.length, n = grid[0].length;
+            for(int i = 0; i < m; i++){
+                for(int j = 0; j < n; j++){
+                    if(grid[i][j] == '1'){
+                        for(int k = 0; k < 4; k++){
+                            int x = i+dirs[k];
+                            int y = j+dirs[k+1];
+                            if(x >= 0 && x < m && y >= 0 && y < n && grid[x][y] == '1'){
+                                int id1 = i*n+j;
+                                int id2 = x*n+y;
+                                uf.union(id1, id2);
+                            }
+                        }
+                    }
+                }
+            }
+            return uf.count;
+        }
+    }
+}

src/main/java/com/fishercoder/solutions/_200DFS.java

@@ -0,0 +1,55 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._200;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _200Test {
+    private static _200.DFSSolution dfsSolution;
+    private static _200.UnionFindSolution unionFindSolution;
+    private static char[][] grid;
+
+    @BeforeClass
+    public static void setup(){
+        dfsSolution = new _200.DFSSolution();
+        unionFindSolution = new _200.UnionFindSolution();
+    }
+
+    @Test
+    public void test1(){
+        grid = new char[][]{
+                {'1','1','1'},
+                {'0','1','0'},
+                {'1','1','1'},
+        };
+        assertEquals(1, dfsSolution.numIslands(grid));
+        assertEquals(1, unionFindSolution.numIslands(grid));
+    }
+
+    @Test
+    public void test2(){
+        grid = new char[][]{
+                {'1','1','1','1','0'},
+                {'1','1','0','1','0'},
+                {'1','1','0','0','0'},
+                {'0','0','0','0','0'},
+        };
+        assertEquals(0, dfsSolution.numIslands(grid));
+        assertEquals(0, unionFindSolution.numIslands(grid));
+    }
+
+    @Test
+    public void test3(){
+        grid = new char[][]{
+                {'1','1','0','0','0'},
+                {'1','1','0','0','0'},
+                {'0','0','1','0','0'},
+                {'0','0','0','1','1'},
+        };
+        assertEquals(3, dfsSolution.numIslands(grid));
+        assertEquals(3, unionFindSolution.numIslands(grid));
+    }
+
+}