fd

Author: dingjikerbo

solution/src/main/java/com/inuker/solution/LongestConsecutiveSequence.java

@@ -4,37 +4,28 @@
 
 /**
  * Created by dingjikerbo on 16/11/22.
+ * https://leetcode.com/articles/longest-consecutive-sequence/
  */
-
 public class LongestConsecutiveSequence {
 
     /**
      * map中保存的是某个点所在的联通块长度，不过要注意的这个连通块两端的点才是准的，中间的点可能不准
      * 所以我们每次新插入一个点时，一定要更新连通块两端的点
      */
     public int longestConsecutive(int[] nums) {
-        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
-
-        int res = 0;
-
-        for (int i = 0; i < nums.length; i++) {
-            int n = nums[i];
-
+        HashMap<Integer, Integer> map = new HashMap<>();
+        int longest = 0;
+        for (int n : nums) {
             if (!map.containsKey(n)) {
-                int left = map.containsKey(n - 1) ? map.get(n - 1) : 0;
-                int right = map.containsKey(n + 1) ? map.get(n + 1) : 0;
+                int left = map.getOrDefault(n - 1, 0);
+                int right = map.getOrDefault(n + 1, 0);
                 int len = left + right + 1;
-
-                // 这句一定不能掉，因为map会查重的，如果这里n没丢到map里，后面再出现重复的n会被覆盖
                 map.put(n, len);
-
-                res = Math.max(res, len);
-
                 map.put(n - left, len);
                 map.put(n + right, len);
+                longest = Math.max(longest, len);
             }
         }
-
-        return res;
+        return longest;
     }
 }

solution/src/main/java/com/inuker/solution/SurroundedRegions.java

@@ -9,61 +9,6 @@
 
 public class SurroundedRegions {
 
-    /**
-     * Union Find法
-     */
-    private int[] mRoot; // union find set
-    private boolean[] mHasEdge; // whether an union has an 'O' which is on the edge of the matrix
-
-    public void solve(char[][] board) {
-        if (board.length == 0) {
-            return;
-        }
-
-        // init, every char itself is an union
-        int row = board.length, col = board[0].length;
-        mRoot = new int[row * col];
-        mHasEdge = new boolean[mRoot.length];
-        for (int i = 0; i < mRoot.length; i++) {
-            mRoot[i] = i;
-        }
-        for (int i = 0; i < mHasEdge.length; i++) {
-            int x = i / col, y = i % col;
-            mHasEdge[i] = (board[x][y] == 'O' && (x == 0 || x == row - 1 || y == 0 || y == col - 1));
-        }
-
-        // iterate the matrix, for each char, union it + its upper char + its right char if they equals to each other
-        for (int i = 0; i < mRoot.length; i++) {
-            int x = i / col, y = i % col, up = x - 1, right = y + 1;
-            if (up >= 0 && board[x][y] == board[up][y]) union(i, i - col);
-            if (right < col && board[x][y] == board[x][right]) union(i, i + 1);
-        }
-
-        // for each char in the matrix, if it is an 'O' and its union doesn't has an 'edge O', the whole union should be setted as 'X'
-        for (int i = 0; i < mRoot.length; i++) {
-            int x = i / col, y = i % col;
-            if (board[x][y] == 'O' && !mHasEdge[find(i)])
-                board[x][y] = 'X';
-        }
-    }
-
-    private void union(int x, int y) {
-        int rootX = find(x);
-        int rootY = find(y);
-        // if there is an union has an 'edge O',the union after merge should be marked too
-        mRoot[rootX] = rootY;
-        mHasEdge[rootY] = mHasEdge[rootX] || mHasEdge[rootY];
-    }
-
-    private int find(int root) {
-        if (mRoot[root] == root) {
-            return root;
-        }
-        // 在找的过程中直接联通到根节点了，这样的好处是加速未来的查找
-        mRoot[root] = find(mRoot[root]);
-        return mRoot[root];
-    }
-
     /**
      * BFS法
      * 给与边界的O相邻的所有O点都标为+，然后剩下的O肯定是不与边界O相邻的，则必然是被X包围的，
@@ -145,7 +90,6 @@ private void dfs(char[][] board, int i, int j) {
         }
 
         board[i][j] = '+';
-
         dfs(board, i - 1, j);
         dfs(board, i + 1, j);
         dfs(board, i, j + 1);

test/src/main/java/com/inuker/test/Test2.java

@@ -20,34 +20,38 @@
 
 public class Test2 {
 
-    public int[] findOrder(int numCourses, int[][] prerequisites) {
-        int[] indegree = new int[numCourses];
-        Set<Integer>[] sets = new HashSet[numCourses];
-        for (int i = 0; i < sets.length; i++) {
-            sets[i] = new HashSet<>();
+    public void solve(char[][] board) {
+        if (board.length == 0) {
+            return;
         }
-        for (int[] pre : prerequisites) {
-            if (sets[pre[1]].add(pre[0])) {
-                indegree[pre[0]]++;
-            }
+        int row = board.length, col = board[0].length;
+        for (int i = 0; i < row; i++) {
+            dfs(board, i, 0);
+            dfs(board, i, board[0].length - 1);
         }
-        Queue<Integer> queue = new LinkedList<>();
-        for (int i = 0; i < numCourses; i++) {
-            if (indegree[i] == 0) {
-                queue.add(i);
-            }
+        for (int i = 0; i < col; i++) {
+            dfs(board, 0, i);
+            dfs(board, row - 1, i);
         }
-        int count = 0;
-        int[] result = new int[numCourses];
-        while (!queue.isEmpty()) {
-            Integer n = queue.poll();
-            result[count++] = n;
-            for (Integer k : sets[n]) {
-                if (--indegree[k] == 0) {
-                    queue.add(k);
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                if (board[i][j] == 'O') {
+                    board[i][j] = 'X';
+                } else if (board[i][j] == '#') {
+                    board[i][j] = 'O';
                 }
             }
         }
-        return count == numCourses ? result : new int[0];
+    }
+
+    void dfs(char[][] board, int i, int j) {
+        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j] != 'O') {
+            return;
+        }
+        board[i][j] = '#';
+        dfs(board, i + 1, j);
+        dfs(board, i - 1, j);
+        dfs(board, i, j + 1);
+        dfs(board, i, j - 1);
     }
 }