260423

Author: aluferraz

src/Main.java

@@ -1,5 +1,7 @@
 import leetcode.editor.en.Q1014.BestSightseeingPair;
 import leetcode.editor.en.Q1051.HeightChecker;
+import leetcode.editor.en.Q115.DistinctSubsequences;
+import leetcode.editor.en.Q1218.LongestArithmeticSubsequenceOfGivenDifference;
 import leetcode.editor.en.Q122.BestTimeToBuyAndSellStockIi;
 import leetcode.editor.en.Q1416.RestoreTheArray;
 import leetcode.editor.en.Q152.MaximumProductSubarray;
@@ -35,7 +37,7 @@
 public class Main {
     public static void main(String[] args) throws IOException {
 
-        System.out.println(new MaximumLengthOfPairChain().findLongestChain(toIntMatrix("[[-6,9],[1,6],[8,10],[-1,4],[-6,-2],[-9,8],[-5,3],[0,3]]")));
+        System.out.println(new LongestArithmeticSubsequenceOfGivenDifference().longestSubsequence(toIntArray("[7,-2,8,10,6,18,9,-8,-5,18,13,-6,-17,-1,-6,-9,9,9]\n"), 1));
 
     }
 

src/leetcode/editor/en/Q115/DistinctSubsequences.java

@@ -0,0 +1,91 @@
+package leetcode.editor.en.Q115;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//Given two strings s and t, return the number of distinct subsequences of s 
+//which equals t. 
+//
+// The test cases are generated so that the answer fits on a 32-bit signed 
+//integer. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: s = "rabbbit", t = "rabbit"
+//Output: 3
+//Explanation:
+//As shown below, there are 3 ways you can generate "rabbit" from s.
+//rabbbit
+//rabbbit
+//rabbbit
+// 
+//
+// Example 2: 
+//
+// 
+//Input: s = "babgbag", t = "bag"
+//Output: 5
+//Explanation:
+//As shown below, there are 5 ways you can generate "bag" from s.
+//babgbag
+//babgbag
+//babgbag
+//babgbag
+//babgbag 
+//
+// 
+// Constraints: 
+//
+// 
+// 1 <= s.length, t.length <= 1000 
+// s and t consist of English letters. 
+// 
+//
+// 👍 5254 👎 200
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    Integer[][] cache;
+
+    public int numDistinct(String s, String t) {
+        int ans = 0;
+        cache = new Integer[s.length() + 1][t.length() + 1];
+        ans += numDistinct(0, 0, s, t);
+
+        return ans;
+    }
+
+    public int numDistinct(int i, int j, String s, String t) {
+        int ans = 0;
+        if (j == t.length()) {
+            return ++ans;
+        }
+        if (i == s.length()) {
+            return ans;
+        }
+        if (cache[i][j] != null) {
+            return cache[i][j];
+        }
+        char c1 = s.charAt(i);
+        char c2 = t.charAt(j);
+
+        if (c1 == c2) {
+            ans += numDistinct(i + 1, j + 1, s, t);
+        }
+        ans += numDistinct(i + 1, j, s, t);
+
+        cache[i][j] = ans;
+        return ans;
+
+
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class DistinctSubsequences extends Solution {
+}

src/leetcode/editor/en/Q1218/LongestArithmeticSubsequenceOfGivenDifference.java

@@ -0,0 +1,104 @@
+package leetcode.editor.en.Q1218;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//Given an integer array arr and an integer difference, return the length of 
+//the longest subsequence in arr which is an arithmetic sequence such that the 
+//difference between adjacent elements in the subsequence equals difference. 
+//
+// A subsequence is a sequence that can be derived from arr by deleting some or 
+//no elements without changing the order of the remaining elements. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: arr = [1,2,3,4], difference = 1
+//Output: 4
+//Explanation: The longest arithmetic subsequence is [1,2,3,4]. 
+//
+// Example 2: 
+//
+// 
+//Input: arr = [1,3,5,7], difference = 1
+//Output: 1
+//Explanation: The longest arithmetic subsequence is any single element.
+// 
+//
+// Example 3: 
+//
+// 
+//Input: arr = [1,5,7,8,5,3,4,2,1], difference = -2
+//Output: 4
+//Explanation: The longest arithmetic subsequence is [7,5,3,1].
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// 1 <= arr.length <= 10⁵ 
+// -10⁴ <= arr[i], difference <= 10⁴ 
+// 
+//
+// 👍 1403 👎 48
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    Integer[] cache;
+    HashMap<Integer, TreeSet<Integer>> numsMap = new HashMap<>();
+
+    public int longestSubsequence(int[] arr, int difference) {
+        int ans = 0;
+        cache = new Integer[arr.length];
+        for (int i = 0; i < arr.length; i++) {
+            numsMap.computeIfAbsent(arr[i], (v) -> new TreeSet<>()).add(i);
+        }
+
+        for (int i = 0; i < arr.length; i++) {
+            ans = Math.max(longestSubsequence(i, arr, difference), ans);
+        }
+        return ans;
+    }
+
+
+    public int longestSubsequence(int i, int[] arr, int difference) {
+        int ans = 1;
+        if (i == arr.length) {
+            return ans;
+        }
+        if (cache[i] != null) {
+            return cache[i];
+        }
+
+        int num = arr[i];
+
+        int target = difference + num;
+
+        if (numsMap.containsKey(target)) {
+            TreeSet<Integer> idxes = numsMap.get(target);
+            Integer higher = idxes.higher(i);
+            if (higher != null) {
+                SortedSet<Integer> next = idxes.subSet(higher, true, idxes.last(), true);
+                for (int j : next) {
+                    if (j > i) {
+                        ans = Math.max(longestSubsequence(j, arr, difference) + 1, ans);
+                    }
+                }
+            }
+        }
+
+        cache[i] = ans;
+        return ans;
+
+
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class LongestArithmeticSubsequenceOfGivenDifference extends Solution {
+}

src/leetcode/editor/en/Q258/AddDigits.java

@@ -0,0 +1,64 @@
+package leetcode.editor.en.Q258;
+
+import java.util.*;
+
+import javafx.util.Pair;
+
+//Given an integer num, repeatedly add all its digits until the result has only 
+//one digit, and return it. 
+//
+// 
+// Example 1: 
+//
+// 
+//Input: num = 38
+//Output: 2
+//Explanation: The process is
+//38 --> 3 + 8 --> 11
+//11 --> 1 + 1 --> 2 
+//Since 2 has only one digit, return it.
+// 
+//
+// Example 2: 
+//
+// 
+//Input: num = 0
+//Output: 0
+// 
+//
+// 
+// Constraints: 
+//
+// 
+// 0 <= num <= 2³¹ - 1 
+// 
+//
+// 
+// Follow up: Could you do it without any loop/recursion in O(1) runtime? 
+//
+// 👍 3619 👎 1816
+
+
+//leetcode submit region begin(Prohibit modification and deletion)
+class Solution {
+    public int addDigits(int num) {
+        return addDigits(String.valueOf(num));
+    }
+
+
+    public int addDigits(String s) {
+        if (s.length() == 1) {
+            return Integer.parseInt(s);
+        }
+        int ans = 0;
+        for (int i = 0; i < s.length(); i++) {
+            ans += Character.getNumericValue(s.charAt(i));
+        }
+        return addDigits(String.valueOf(ans));
+    }
+}
+//leetcode submit region end(Prohibit modification and deletion)
+
+
+public class AddDigits extends Solution {
+}