250423

Author: aluferraz

src/Main.java

@@ -13,6 +13,8 @@
 import leetcode.editor.en.Q459.RepeatedSubstringPattern;
 import leetcode.editor.en.Q461.HammingDistance;
 import leetcode.editor.en.Q516.LongestPalindromicSubsequence;
+import leetcode.editor.en.Q63.UniquePathsIi;
+import leetcode.editor.en.Q646.MaximumLengthOfPairChain;
 import leetcode.editor.en.Q673.NumberOfLongestIncreasingSubsequence;
 import leetcode.editor.en.Q71.SimplifyPath;
 import leetcode.editor.en.Q727.MinimumWindowSubsequence;
@@ -33,7 +35,7 @@
 public class Main {
     public static void main(String[] args) throws IOException {
 
-        System.out.println(new NumberOfLongestIncreasingSubsequence().findNumberOfLIS(toIntArrayFromFile("testcase.txt")));
+        System.out.println(new MaximumLengthOfPairChain().findLongestChain(toIntMatrix("[[-6,9],[1,6],[8,10],[-1,4],[-6,-2],[-9,8],[-5,3],[0,3]]")));
 
     }
 

src/leetcode/editor/en/Q2336/SmallestNumberInInfiniteSet.java

@@ -0,0 +1,102 @@
+package leetcode.editor.en.Q2336;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//You have a set which contains all positive integers [1, 2, 3, 4, 5, ...]. 
+//
+// Implement the SmallestInfiniteSet class: 
+//
+// 
+// SmallestInfiniteSet() Initializes the SmallestInfiniteSet object to contain 
+//all positive integers. 
+// int popSmallest() Removes and returns the smallest integer contained in the 
+//infinite set. 
+// void addBack(int num) Adds a positive integer num back into the infinite set,
+// if it is not already in the infinite set. 
+// 
+//
+// 
+// Example 1: 
+//
+// 
+//Input
+//["SmallestInfiniteSet", "addBack", "popSmallest", "popSmallest", 
+//"popSmallest", "addBack", "popSmallest", "popSmallest", "popSmallest"]
+//[[], [2], [], [], [], [1], [], [], []]
+//Output
+//[null, null, 1, 2, 3, null, 1, 4, 5]
+//
+//Explanation
+//SmallestInfiniteSet smallestInfiniteSet = new SmallestInfiniteSet();
+//smallestInfiniteSet.addBack(2);    // 2 is already in the set, so no change 
+//is made.
+//smallestInfiniteSet.popSmallest(); // return 1, since 1 is the smallest 
+//number, and remove it from the set.
+//smallestInfiniteSet.popSmallest(); // return 2, and remove it from the set.
+//smallestInfiniteSet.popSmallest(); // return 3, and remove it from the set.
+//smallestInfiniteSet.addBack(1);    // 1 is added back to the set.
+//smallestInfiniteSet.popSmallest(); // return 1, since 1 was added back to the 
+//set and
+//                                   // is the smallest number, and remove it 
+//from the set.
+//smallestInfiniteSet.popSmallest(); // return 4, and remove it from the set.
+//smallestInfiniteSet.popSmallest(); // return 5, and remove it from the set.
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// 1 <= num <= 1000 
+// At most 1000 calls will be made in total to popSmallest and addBack. 
+// 
+//
+// 👍 759 👎 76
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class SmallestInfiniteSet {
+    TreeSet<Integer> numbers;
+    HashSet<Integer> removed;
+    int pos;
+
+    public SmallestInfiniteSet() {
+        this.numbers = new TreeSet<>();
+        this.removed = new HashSet<>();
+        this.pos = 1;
+    }
+
+    public int popSmallest() {
+        int ans = pos;
+        if (!numbers.isEmpty() && numbers.first() <= pos) {
+            ans = numbers.first();
+            numbers.remove(ans);
+        }
+        if (ans == pos) {
+            pos++;
+        }
+        removed.add(ans);
+        return ans;
+
+    }
+
+    public void addBack(int num) {
+        if (removed.contains(num)) {
+            numbers.add(num);
+        }
+    }
+}
+
+/**
+ * Your SmallestInfiniteSet object will be instantiated and called as such:
+ * SmallestInfiniteSet obj = new SmallestInfiniteSet();
+ * int param_1 = obj.popSmallest();
+ * obj.addBack(num);
+ */
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class SmallestNumberInInfiniteSet extends SmallestInfiniteSet {
+}

src/leetcode/editor/en/Q63/UniquePathsIi.java

@@ -0,0 +1,96 @@
+package leetcode.editor.en.Q63;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//You are given an m x n integer array grid. There is a robot initially located 
+//at the top-left corner (i.e., grid[0][0]). The robot tries to move to the 
+//bottom-right corner (i.e., grid[m - 1][n - 1]). The robot can only move either down 
+//or right at any point in time. 
+//
+// An obstacle and space are marked as 1 or 0 respectively in grid. A path that 
+//the robot takes cannot include any square that is an obstacle. 
+//
+// Return the number of possible unique paths that the robot can take to reach 
+//the bottom-right corner. 
+//
+// The testcases are generated so that the answer will be less than or equal to 
+//2 * 10⁹. 
+//
+// 
+// Example 1: 
+// 
+// 
+//Input: obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
+//Output: 2
+//Explanation: There is one obstacle in the middle of the 3x3 grid above.
+//There are two ways to reach the bottom-right corner:
+//1. Right -> Right -> Down -> Down
+//2. Down -> Down -> Right -> Right
+// 
+//
+// Example 2: 
+// 
+// 
+//Input: obstacleGrid = [[0,1],[0,0]]
+//Output: 1
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// m == obstacleGrid.length 
+// n == obstacleGrid[i].length 
+// 1 <= m, n <= 100 
+// obstacleGrid[i][j] is 0 or 1. 
+// 
+//
+// 👍 6881 👎 434
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    Integer[][] visited;
+    int VISITING = -1;
+    int STONE = 1;
+
+    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+        visited = new Integer[obstacleGrid.length][obstacleGrid[0].length];
+        return uniquePathsWithObstacles(0, 0, obstacleGrid);
+    }
+
+    private int uniquePathsWithObstacles(int row, int col, int[][] obstacleGrid) {
+        if (!isValidIdx(row, col, obstacleGrid)) return 0;
+        if (row == obstacleGrid.length - 1 && col == obstacleGrid[row].length - 1) {
+            return 1;
+        }
+        if (visited[row][col] != null && visited[row][col] >= 0) {
+            return visited[row][col];
+        }
+        visited[row][col] = VISITING;
+        int ans = 0;
+        if (isValidIdx(row + 1, col, obstacleGrid) && (visited[row + 1][col] == null || visited[row + 1][col] != VISITING)) {
+            ans += uniquePathsWithObstacles(row + 1, col, obstacleGrid);
+        }
+        if (isValidIdx(row, col + 1, obstacleGrid) && (visited[row][col + 1] == null || visited[row][col + 1] != VISITING)) {
+            ans += uniquePathsWithObstacles(row, col + 1, obstacleGrid);
+        }
+
+        visited[row][col] = ans;
+        return ans;
+
+    }
+
+    private boolean isValidIdx(int row, int col, int[][] grid) {
+        return row >= 0 && row < grid.length && col >= 0 && col < grid[row].length && grid[row][col] != STONE;
+    }
+
+
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class UniquePathsIi extends Solution {
+}

src/leetcode/editor/en/Q646/MaximumLengthOfPairChain.java

@@ -0,0 +1,83 @@
+package leetcode.editor.en.Q646;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//You are given an array of n pairs pairs where pairs[i] = [lefti, righti] and 
+//lefti < righti. 
+//
+// A pair p2 = [c, d] follows a pair p1 = [a, b] if b < c. A chain of pairs can 
+//be formed in this fashion. 
+//
+// Return the length longest chain which can be formed. 
+//
+// You do not need to use up all the given intervals. You can select pairs in 
+//any order. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: pairs = [[1,2],[2,3],[3,4]]
+//Output: 2
+//Explanation: The longest chain is [1,2] -> [3,4].
+// 
+//
+// Example 2: 
+//
+// 
+//Input: pairs = [[1,2],[7,8],[4,5]]
+//Output: 3
+//Explanation: The longest chain is [1,2] -> [4,5] -> [7,8].
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// n == pairs.length 
+// 1 <= n <= 1000 
+// -1000 <= lefti < righti <= 1000 
+// 
+//
+// 👍 2943 👎 113
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    Integer cache[];
+    public int findLongestChain(int[][] pairs) {
+        Arrays.sort(pairs, Arrays::compare);
+        cache = new Integer[pairs.length];
+        int ans = 0;
+        for (int i = 0; i < pairs.length; i++) {
+            ans = Math.max(ans, findLongestChain(i, pairs));
+        }
+        return ans;
+    }
+
+    public int findLongestChain(int i, int[][] pairs) {
+        if (i == pairs.length) {
+            return 0;
+        }
+        if(cache[i] != null){
+            return cache[i];
+        }
+        int bound = pairs[i][1];
+        int ans = 1;
+        for (int j = i + 1; j < pairs.length; j++) {
+            if (pairs[j][0] > bound) {
+                ans = Math.max(ans, 1 + findLongestChain(j, pairs));
+            }
+        }
+        cache[i] = ans;
+        return ans;
+
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class MaximumLengthOfPairChain extends Solution {
+}