LC : add #31, #1608, #2812 and refine #140, #463, #827

Author: rayworks

src/main/java/org/sean/array/NextPermutation.java

@@ -0,0 +1,49 @@
+package org.sean.array;
+
+/***
+ * 31. Next Permutation
+ */
+public class NextPermutation {
+    public void nextPermutation(int[] nums) {
+        // [] 4 3 2 1
+        //    1 [2] 3
+        //    xxx [4] 7 5 3
+
+        int len = nums.length;
+        int i;
+        for (i = len - 1; i >= 1; i--) {
+            if (nums[i] > nums[i - 1]) {
+                break;
+            }
+        }
+        if (i == 0) { // already sorted in DESC
+            reverse(nums, 0, len - 1);
+            return;
+        }
+
+        i--; // the one to be swapped
+        for (int j = len - 1; j > i; j--) {
+            if (nums[j] > nums[i]) {
+                swap(nums, i, j);
+                break;
+            }
+        }
+
+        // reorder the [i+1, len) part as they're already sorted in reverse order
+        reverse(nums, i + 1, len - 1);
+    }
+
+    private void reverse(int[] nums, int l, int r) {
+        while (l < r) {
+            swap(nums, l, r);
+            l++;
+            r--;
+        }
+    }
+
+    private static void swap(int[] nums, int l, int r) {
+        int tmp = nums[l];
+        nums[l] = nums[r];
+        nums[r] = tmp;
+    }
+}

src/main/java/org/sean/array/NumInSpecialArray.java

@@ -0,0 +1,62 @@
+package org.sean.array;
+
+/***
+ * 1608. Special Array With X Elements Greater Than or Equal X
+ */
+public class NumInSpecialArray {
+    // #region BinSearch, time complexity O(N*lgN)
+    public int specialArray0(int[] nums) {
+        // 0 <= nums[i] <= 1000
+        // 1 <= nums.length <= 100
+
+        // left : 0
+        // right : 1000
+        // binSearch
+        int left = 0;
+        int right = nums.length;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            int cnt = numOfNonSmaller(nums, mid);
+            if (cnt == mid) {
+                return mid;
+            } else if (cnt < mid) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return -1;
+    }
+    // #endregion
+
+    private int numOfNonSmaller(int[] nums, int x) {
+        int cnt = 0;
+        for (int i : nums) {
+            if (i >= x)
+                cnt++;
+        }
+        return cnt;
+    }
+
+
+    // #region Counting sort + prefix sum, time complexity O(N)
+    public int specialArray(int[] nums) {
+        int len = nums.length;
+        int[] counters = new int[len + 1];
+        for (int i = 0; i < len; i++) {
+            if(nums[i] >= len)
+                counters[len] += 1;
+            else
+                counters[nums[i]] += 1;
+
+        }
+        int count = 0;
+        for (int i = len; i >= 1; i--) {
+            count += counters[i];
+            if(i == count)
+                return i;
+        }
+        return -1;
+    }
+    // #endregion
+}

src/main/java/org/sean/backtracking/WordBreakII.java

@@ -6,43 +6,39 @@
  * 140. Word Break II
  */
 public class WordBreakII {
-    private List<String> outputs = new ArrayList<>();
-
-    private void lookupWords(
-            String s, List<String> wordDict, int currIndex, LinkedList<String> words) {
-        int len = s.length();
-        if (currIndex >= len) {
-            int totalLen = words.stream().mapToInt(String::length).sum();
-            if (totalLen == len) {
-                StringBuilder builder = new StringBuilder();
-                for (int i = 0; i < words.size(); i++) {
-                    builder.append(words.get(i));
-                    if (i != words.size() - 1) builder.append(' ');
-                }
-                outputs.add(builder.toString());
+    List<String> out = new ArrayList<>();
+
+    private void lookupWords(String s, int pos, List<String> parts, int size, Set<String> set) {
+        if (pos >= s.length()) {
+            //int len = parts.stream().mapToInt(value -> value.length()).sum();
+            if (size == s.length()) {
+                out.add(String.join(" ", parts));
             }
             return;
         }
-        for (int j = currIndex + 1; j <= len; j++) {
-            String sub = s.substring(currIndex, j);
-            if (wordDict.contains(sub)) {
-                words.add(sub);
-                lookupWords(s, wordDict, j, words);
-                words.removeLast();
+
+        for (int i = pos; i < s.length(); i++) {
+            String word = s.substring(pos, i + 1);
+            if (set.contains(word)) {
+                parts.add(word);
+                lookupWords(s, i + 1, parts, size + word.length(), set);
+                parts.remove(parts.size() - 1);
             }
         }
     }
 
     public List<String> wordBreak(String s, List<String> wordDict) {
         if (s == null || s.length() == 0) return Collections.emptyList();
 
-        if (s.length() == 1) {
-            if (wordDict.contains(s)) return Collections.singletonList(s);
-            else return Collections.emptyList();
-        }
+        //  all such possible sentences in any order.
+        HashSet<String> dict = new HashSet<>(wordDict);
+        //  catsanddog
+        // cat{sanddog}
+        // cats{anddog}
+        // ...
 
-        lookupWords(s, wordDict, 0, new LinkedList<>());
+        lookupWords(s, 0, new ArrayList<>(), 0, dict);
 
-        return outputs;
+        return out;
     }
 }

src/main/java/org/sean/backtracking/IslandPerimeterCalculator.java renamed to src/main/java/org/sean/graph/IslandPerimeterCalculator.java

@@ -1,8 +1,33 @@
-package org.sean.backtracking;
+package org.sean.graph;
 
 // 463. Island Perimeter
 public class IslandPerimeterCalculator {
+
     public int islandPerimeter(int[][] grid) {
+        int rowCnt = grid.length;
+        int colCnt = grid[0].length;
+
+        int res = 0;
+        for (int i = 0; i < rowCnt; i++) {
+            for (int j = 0; j < colCnt; j++) {
+                int cell = grid[i][j];
+
+                if (cell == 1) {
+                    for (int[] mv : offsets) {
+                        int nR = i + mv[0];
+                        int nC = j + mv[1];
+
+                        if (isInvalidPos(nR, nC, grid) || grid[nR][nC] == 0) {
+                            res++;
+                        }
+                    }
+                }
+            }
+        }
+        return res;
+    }
+
+    public int islandPerimeter0(int[][] grid) {
         int row = grid.length;
         int col = grid[0].length;
 

src/main/java/org/sean/array/LargeIsland.java renamed to src/main/java/org/sean/graph/LargeIsland.java

@@ -1,78 +1,56 @@
-package org.sean.array;
+package org.sean.graph;
 
 import java.util.*;
 
 /***
  * 827. Making A Large Island
  */
 public class LargeIsland {
-    private boolean[][] visited;
-    private final int[][] moves = new int[][]{{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
-    private final List<int[]> targetCoordination = new ArrayList<>();
+    private final int[][] moves = new int[][]{{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
 
-    private int maxSize = 0;
+    private int dfs(int[][] grid, int i, int j, int order, int cnt) {
 
-    // <areaNum,  maxArea>
-    Map<Integer, Integer> map = new HashMap<>();
+        int n = grid.length;
+        grid[i][j] = order;
 
-    // color and count
-    private int traverse(int[][] grid, int r, int c, int curr, int order) {
-        if (!isValidPos(grid, r, c) || visited[r][c]) return curr;
-
-        visited[r][c] = true;
-
-        if (grid[r][c] == 1) {
-            curr++;
-
-            // color the area
-            grid[r][c] = order;
-
-            for (int[] move : moves) {
-                curr += traverse(grid, r + move[0], c + move[1], curr, order) - curr;
+        for (int[] move : moves) {
+            int nR = i + move[0];
+            int nC = j + move[1];
+            if (nR >= 0 && nR < n && nC >= 0 && nC < n && grid[nR][nC] == 1) {
+                grid[nR][nC] = order;
+                cnt += dfs(grid, nR, nC, order, 1);
             }
         }
-
-        return curr;
+        return cnt;
     }
 
-    private boolean isValidPos(int[][] grid, int r, int c) {
-        int length = grid.length;
-        if (r >= length || r < 0 || c >= grid[0].length || c < 0)
-            return false;
-        return true;
-    }
+    // <order, size>
+    private Map<Integer, Integer> map = new HashMap<>();
 
+    // Large Island
     public int largestIsland(int[][] grid) {
-        if (grid.length == 1)
-            return 1;
+        // dfs find all the SCCs
+        // mark it and cnt the area
+        // for each 0, check the max
 
-        int len = grid.length;
-        for (int i = 0; i < len; i++) {
-            for (int j = 0; j < len; j++) {
+        int order = 2;
+        int n = grid.length;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
                 if (grid[i][j] == 1) {
-                    targetCoordination.add(new int[]{i, j});
+                    int sum = dfs(grid, i, j, order, 1);
+                    map.put(order, sum);
+
+                    //System.out.printf("[%d:%d] - %d\n", i, j, sum);
+                    order++;
                 }
             }
         }
-        if (targetCoordination.isEmpty()) // all zeros!
-            return 1;
-        if (targetCoordination.size() == len * len)
-            return len * len;
-
-        visited = new boolean[len][len];
-
-        int order = 2;
-        for (int[] pair : targetCoordination) {
 
-            int r = pair[0];
-            int c = pair[1];
-            int islandSize = traverse(grid, r, c, 0, order);
-            if (islandSize > 0)
-                map.put(order, islandSize);
-
-            order++;
-        }
+        if (map.isEmpty())
+            return 1;
 
+        int maxSize = 0, len = n;
         for (int i = 0; i < len; i++) {
             for (int j = 0; j < len; j++) {
                 if (grid[i][j] == 0) {
@@ -102,7 +80,8 @@ public int largestIsland(int[][] grid) {
             }
         }
 
-        return maxSize;
+
+        return maxSize == 0 ? n * n : maxSize;
     }
 
     public static void main(String[] args) {