Add more solutions

Author: rayworks

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

@@ -2,7 +2,7 @@
 
 import java.util.*;
 
-// LeetCode 904 https://leetcode.com/problems/fruit-into-baskets/
+// 904 Fruit into baskets
 public class FruitCounter {
     public int totalFruit1(int[] fruits) {
         // Sliding Window

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

@@ -0,0 +1,79 @@
+package org.sean.backtracking;
+
+// Rat in a Maze | Backtracking-2
+// https://www.geeksforgeeks.org/rat-in-a-maze-backtracking-2
+//
+// Count number of ways to reach destination in a Maze
+// Given a maze with obstacles, count the number of paths to reach the rightmost-bottommost cell from the
+// topmost-leftmost cell. A cell in the given maze has a value of -1 if it is a blockage or dead-end, else 0.
+//
+// From a given cell, we are allowed to move to cells (i+1, j) and (i, j+1) only.
+//
+// Examples:
+// Input: maze[R][C] =  {{0,  0, 0, 0},
+//                      {0, -1, 0, 0},
+//                      {-1, 0, 0, 0},
+//                      {0,  0, 0, 0}};
+//Output: 4
+
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.Locale;
+
+public class MazePathFinder {
+    // Returns count of possible paths in
+    // a maze[R][C] from (0,0) to (R-1,C-1)
+    int[][] moves = new int[][]{{1, 0}, {0, 1}};
+    int total = 0;
+
+    Deque<int[]> paths = new LinkedList<>();
+
+    void move(int row, int col, int maze[][]) {
+        int maxRow = maze.length - 1;
+        int maxCol = maze[0].length - 1;
+        if (row == maxRow && col == maxCol) {
+
+            for (int[] loc : paths) {
+                System.out.print(String.format(Locale.ENGLISH, "[%d,%d]", loc[0], loc[1]));
+                System.out.print(" ");
+            }
+            System.out.println("");
+
+            ++total;
+            return;
+        }
+
+        for (int[] mv : moves) {
+            int r = row + mv[0];
+            int c = col + mv[1];
+
+            if (r <= maxRow && c <= maxCol && maze[r][c] != -1) {
+                paths.add(new int[]{r, c});
+                move(r, c, maze);
+                paths.removeLast();
+            }
+        }
+    }
+
+    int countPaths(int[][] maze) {
+        paths.clear();
+        paths.add(new int[]{0, 0});
+
+        move(0, 0, maze);
+        return total;
+    }
+
+    public static void main(String[] args) {
+        int[][] input = {
+                {0, 0, 0, 0},
+                {0, -1, 0, 0},
+                {-1, 0, 0, 0},
+                {0, 0, 0, 0}
+        };
+        MazePathFinder finder = new MazePathFinder();
+        int count = finder.countPaths(input);
+
+        System.out.println(">>> total paths : " + count);
+    }
+
+}

src/main/java/org/sean/dynamicpro/CombinationSum3.java

@@ -0,0 +1,74 @@
+package org.sean.dynamicpro;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 216. Combination Sum III
+ */
+public class CombinationSum3 {
+    List<Set<List<Integer>>> caches;
+
+    // k numbers that add up to a number n
+    public List<List<Integer>> combinationSum3(int k, int n) {
+        int[] candidates = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
+        int maxSum = 0;
+        for (int i : candidates) {
+            maxSum += i;
+        }
+        if (n > maxSum || n < 1) {
+            return Collections.emptyList();
+        }
+
+        caches = new ArrayList<>(n + 1);
+        caches.add(Collections.emptySet()); // 0
+
+        int length = candidates.length;
+        for (int i = 1; i <= n; i++) {
+            Set<List<Integer>> listResult = new HashSet<>();
+            for (int j = 0; j < length; j++) {
+                int w = candidates[j];
+                if (i == w) {
+                    listResult.add(Arrays.asList(w));
+                } else if (i > w) {
+                    int diff = i - w;
+                    reduceSet(listResult, w, diff);
+                } else {
+                    break;
+                }
+            }
+            caches.add(listResult);
+        }
+        Set<List<Integer>> result = caches.get(n);
+        return result.stream().filter(integers -> integers.size() == k).collect(Collectors.toList());
+    }
+
+    private void reduceSet(Set<List<Integer>> dpOut, int candidate, int rest) {
+        if (rest > 0) { // skip <= 0
+            Set<List<Integer>> sets = caches.get(rest);
+            if (sets != null) {
+                for (List<Integer> set : sets) {
+                    // without duplicate elem
+                    Set<Integer> existedSet = new HashSet<>(set);
+                    if (existedSet.contains(candidate)) {
+                        continue;
+                    }
+
+                    List<Integer> matchedOut = new ArrayList<>(set);
+                    matchedOut.add(candidate);
+
+                    // !!n*lg(n)
+                    Collections.sort(matchedOut);
+
+                    dpOut.add(matchedOut);
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        CombinationSum3 sum3 = new CombinationSum3();
+        List<List<Integer>> lists = sum3.combinationSum3(3, 7);
+        System.out.println(Arrays.toString(lists.toArray()));
+    }
+}

src/main/java/org/sean/recursive/UniquePaths2.java

@@ -2,15 +2,17 @@
 
 import java.util.Arrays;
 
-/** * 63. Unique Paths II */
+/**
+ * 63. Unique Paths II
+ */
 public class UniquePaths2 {
     private int[][] cache;
 
     /**
      * * Counts the unique path for an obstacle Grid
      *
-     * @param m width of grid
-     * @param n height of grid
+     * @param m            width of grid
+     * @param n            height of grid
      * @param obstacleGrid two-dimensional array
      * @return number of unique path from [0, 0] -> [m-1, n-1]
      */
@@ -50,6 +52,47 @@ private int uniquePaths(int m, int n, int[][] obstacleGrid) {
         return up + left;
     }
 
+    /// solution II
+    private int[][] dp;
+
+    public int uniquePaths2(int m, int n, int[][] obstacleGrid) {
+        int row = m;
+        int col = n;
+
+        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1)
+            return 0;
+
+        dp = new int[m + 1][n + 1];
+        dp[1][1] = 1;
+
+        for (int j = 1; j <= row; j++) {
+            for (int i = 1; i <= col; i++) {
+                if (obstacleGrid[j - 1][i - 1] == 1) {
+                    dp[j][i] = 0;
+                    continue;
+                }
+
+                if (j == 1 && i == 1)
+                    continue;
+
+                if (j == 1 || i == 1) {
+                    if (j == 1) {
+                        dp[j][i] = dp[j][i - 1] != 0 ? 1 : 0;
+                    } else {
+                        dp[j][i] = dp[j - 1][i] != 0 ? 1 : 0;
+                    }
+                } else {
+                    dp[j][i] = getCnt(j, i - 1, obstacleGrid) + getCnt(j - 1, i, obstacleGrid);
+                }
+            }
+        }
+        return dp[m][n];
+    }
+
+    private int getCnt(int r, int c, int[][] array) {
+        return array[r - 1][c - 1] == 1 ? 0 : dp[r][c];
+    }
+
     public int uniquePathsWithObstacles(int[][] obstacleGrid) {
         if (obstacleGrid == null || obstacleGrid.length == 0) return 0;
 

src/main/java/org/sean/tree/TreeSerializer.java

@@ -6,10 +6,6 @@
 
 /**
  * * 297. Serialize and Deserialize Binary Tree
- *
- * <p>Note: The first solution (BFS) based on the sequence of the node is flawed if depth of the
- * tree is larger than 31. In that case, the sequence number will be at least 2 ^ 32 which is out of
- * range for an Integer.
  */
 public class TreeSerializer {