Added DP questions

Author: devangi2000

Design/IteratorForCombination1286.cpp

@@ -0,0 +1,55 @@
+// There are n points on a road you are driving your taxi on. The n points on the road are labeled from 1 to n in the direction you are going, and you want to drive from point 1 to point n to make money by picking up passengers. You cannot change the direction of the taxi.
+
+// The passengers are represented by a 0-indexed 2D integer array rides, where rides[i] = [starti, endi, tipi] denotes the ith passenger requesting a ride from point starti to point endi who is willing to give a tipi dollar tip.
+
+// For each passenger i you pick up, you earn endi - starti + tipi dollars. You may only drive at most one passenger at a time.
+
+// Given n and rides, return the maximum number of dollars you can earn by picking up the passengers optimally.
+
+// Note: You may drop off a passenger and pick up a different passenger at the same point.
+
+ 
+
+// Example 1:
+
+// Input: n = 5, rides = [[2,5,4],[1,5,1]]
+// Output: 7
+// Explanation: We can pick up passenger 0 to earn 5 - 2 + 4 = 7 dollars.
+// Example 2:
+
+// Input: n = 20, rides = [[1,6,1],[3,10,2],[10,12,3],[11,12,2],[12,15,2],[13,18,1]]
+// Output: 20
+// Explanation: We will pick up the following passengers:
+// - Drive passenger 1 from point 3 to point 10 for a profit of 10 - 3 + 2 = 9 dollars.
+// - Drive passenger 2 from point 10 to point 12 for a profit of 12 - 10 + 3 = 5 dollars.
+// - Drive passenger 5 from point 13 to point 18 for a profit of 18 - 13 + 1 = 6 dollars.
+// We earn 9 + 5 + 6 = 20 dollars in total.
+ 
+
+// Constraints:
+
+// 1 <= n <= 105
+// 1 <= rides.length <= 3 * 104
+// rides[i].length == 3
+// 1 <= starti < endi <= n
+// 1 <= tipi <= 105
+
+#define pii pair<int, int>
+
+class Solution {
+public:
+    long long maxTaxiEarnings(int n, vector<vector<int>>& rides) {
+        vector<vector<pii>> earn(n);
+        for(auto &ride : rides){
+            int start = ride[0], end = ride[1], tip = ride[2];
+            earn[start].push_back({end, end - start + tip});            
+        }
+        vector<long long> dp(n+1);
+        for(int i = n-1; i >= 1; i--){
+            for(auto& [end, tip] : earn[i])
+                dp[i] = max(dp[i], dp[end] + tip);
+            dp[i] = max(dp[i], dp[i+1]);
+        }        
+        return dp[1];
+    }
+};

Design/IteratorForCombination1286.java

@@ -0,0 +1,52 @@
+// There are n points on a road you are driving your taxi on. The n points on the road are labeled from 1 to n in the direction you are going, and you want to drive from point 1 to point n to make money by picking up passengers. You cannot change the direction of the taxi.
+
+// The passengers are represented by a 0-indexed 2D integer array rides, where rides[i] = [starti, endi, tipi] denotes the ith passenger requesting a ride from point starti to point endi who is willing to give a tipi dollar tip.
+
+// For each passenger i you pick up, you earn endi - starti + tipi dollars. You may only drive at most one passenger at a time.
+
+// Given n and rides, return the maximum number of dollars you can earn by picking up the passengers optimally.
+
+// Note: You may drop off a passenger and pick up a different passenger at the same point.
+
+ 
+
+// Example 1:
+
+// Input: n = 5, rides = [[2,5,4],[1,5,1]]
+// Output: 7
+// Explanation: We can pick up passenger 0 to earn 5 - 2 + 4 = 7 dollars.
+// Example 2:
+
+// Input: n = 20, rides = [[1,6,1],[3,10,2],[10,12,3],[11,12,2],[12,15,2],[13,18,1]]
+// Output: 20
+// Explanation: We will pick up the following passengers:
+// - Drive passenger 1 from point 3 to point 10 for a profit of 10 - 3 + 2 = 9 dollars.
+// - Drive passenger 2 from point 10 to point 12 for a profit of 12 - 10 + 3 = 5 dollars.
+// - Drive passenger 5 from point 13 to point 18 for a profit of 18 - 13 + 1 = 6 dollars.
+// We earn 9 + 5 + 6 = 20 dollars in total.
+ 
+
+// Constraints:
+
+// 1 <= n <= 105
+// 1 <= rides.length <= 3 * 104
+// rides[i].length == 3
+// 1 <= starti < endi <= n
+// 1 <= tipi <= 105
+
+class Solution {
+    public long maxTaxiEarnings(int n, int[][] rides) {
+        List<int[]>[] arr = new List[n+1];
+        for(int i = 1; i <= n; i++)
+            arr[i] = new ArrayList<>();
+        for(int[] ride : rides)
+            arr[ride[0]].add(new int[]{ride[1], ride[1] - ride[0] + ride[2]});
+        long[] dp = new long[n+1];
+        for(int i = n-1; i >= 1; i--){
+            for(int[] t : arr[i])
+                dp[i] = Math.max(dp[i], dp[t[0]] + t[1]);
+            dp[i] = Math.max(dp[i], dp[i+1]);
+        }
+        return dp[1];
+    }
+}

Dynamic Programming/DP or Greedy :?/MaximumEarningsFromTaxi2008.cpp

@@ -0,0 +1,50 @@
+// Given a set of distinct positive integers nums, return the largest subset answer such that every pair 
+// (answer[i], answer[j]) of elements in this subset satisfies:
+// answer[i] % answer[j] == 0, or
+// answer[j] % answer[i] == 0
+// If there are multiple solutions, return any of them.
+
+
+// Example 1:
+// Input: nums = [1,2,3]
+// Output: [1,2]
+// Explanation: [1,3] is also accepted.
+// Example 2:
+// Input: nums = [1,2,4,8]
+// Output: [1,2,4,8]
+ 
+// Constraints:
+// 1 <= nums.length <= 1000
+// 1 <= nums[i] <= 2 * 109
+// All the integers in nums are unique.
+
+class Solution {
+public:
+    vector<int> largestDivisibleSubset(vector<int>& nums) {
+        int n = nums.size(), maxlen = 0, maxind = -1;
+        if(n == 1) return nums;
+        vector<int> dp(n), pre(n);
+        sort(nums.begin(), nums.end());
+        for(int i = 0; i < n; i++){
+            dp[i] = 1; pre[i] = -1;
+            for(int j = i-1; j >= 0; j--){
+                if(nums[i] % nums[j] == 0){
+                    if(dp[i] < 1 + dp[j]){
+                        dp[i] = 1 + dp[j];
+                        pre[i] = j;
+                    }
+                }
+            }
+            if(dp[i] > maxlen){
+                maxlen = dp[i];
+                maxind = i;
+            }
+        }
+        vector<int> res;
+        while(maxind != -1){
+            res.push_back(nums[maxind]);
+            maxind = pre[maxind];
+        }
+        return res;
+    }
+};

Dynamic Programming/DP or Greedy :?/MaximumEarningsFromTaxi2008.java

@@ -0,0 +1,57 @@
+// Given a set of distinct positive integers nums, return the largest subset answer such that every pair (answer[i], answer[j]) of elements in this subset satisfies:
+
+// answer[i] % answer[j] == 0, or
+// answer[j] % answer[i] == 0
+// If there are multiple solutions, return any of them.
+
+ 
+
+// Example 1:
+
+// Input: nums = [1,2,3]
+// Output: [1,2]
+// Explanation: [1,3] is also accepted.
+// Example 2:
+
+// Input: nums = [1,2,4,8]
+// Output: [1,2,4,8]
+ 
+
+// Constraints:
+
+// 1 <= nums.length <= 1000
+// 1 <= nums[i] <= 2 * 109
+// All the integers in nums are unique.
+
+class Solution {
+    public List<Integer> largestDivisibleSubset(int[] nums) {
+        int n = nums.length, maxlen = 0, maxind = -1;
+        int[] dp = new int[n];
+        int[] pre = new int[n];
+        Arrays.sort(nums);
+        for(int i = 0; i < n; i++){
+            dp[i] = 1;
+            pre[i] = -1;
+            for(int j = i-1; j >= 0; j--){
+                if(nums[i] % nums[j] == 0){
+                    if(dp[i] < 1 + dp[j]){
+                        dp[i] = 1 + dp[j];
+                        pre[i] = j;
+                    }
+                }
+            }            
+            if(maxlen < dp[i]){
+                maxlen = dp[i];
+                maxind = i;
+            }
+        }
+        
+        List<Integer> res = new ArrayList<>();
+        while(maxind != -1){
+            res.add(nums[maxind]);
+            maxind = pre[maxind];
+        }
+        
+        return res;
+    }
+}

Dynamic Programming/Longest Increasing Subsequence/LargestDivisibleSubset368.cpp

@@ -0,0 +1,45 @@
+// The beauty of a string is the difference in frequencies between the most frequent and least frequent characters.
+
+// For example, the beauty of "abaacc" is 3 - 1 = 2.
+// Given a string s, return the sum of beauty of all of its substrings.
+
+ 
+
+// Example 1:
+
+// Input: s = "aabcb"
+// Output: 5
+// Explanation: The substrings with non-zero beauty are ["aab","aabc","aabcb","abcb","bcb"], each with beauty equal to 1.
+// Example 2:
+
+// Input: s = "aabcbaa"
+// Output: 17
+ 
+
+// Constraints:
+
+// 1 <= s.length <= 500
+// s consists of only lowercase English letters.
+
+class Solution {
+public:
+    int beautySum(string s) {
+    int res = 0;
+    for (auto i = 0; i < s.size(); ++i) {
+        int cnt[26] = {}, max_f = 0, min_f = 0;
+        for (auto j = i; j < s.size(); ++j) {
+            int idx = s[j] - 'a';
+            max_f = max(max_f, ++cnt[idx]);
+            if (min_f >= cnt[idx] - 1) {
+                min_f = cnt[idx];
+                for (int k = 0; k < 26; ++k)
+                    min_f = min(min_f, cnt[k] == 0 ? INT_MAX : cnt[k]);
+            }
+            res += max_f - min_f;
+        }
+    }
+    return res;
+}
+};
+
+

Dynamic Programming/Longest Increasing Subsequence/LargestDivisibleSubset368.java

@@ -0,0 +1,43 @@
+// The beauty of a string is the difference in frequencies between the most frequent and least frequent characters.
+
+// For example, the beauty of "abaacc" is 3 - 1 = 2.
+// Given a string s, return the sum of beauty of all of its substrings.
+
+ 
+
+// Example 1:
+
+// Input: s = "aabcb"
+// Output: 5
+// Explanation: The substrings with non-zero beauty are ["aab","aabc","aabcb","abcb","bcb"], each with beauty equal to 1.
+// Example 2:
+
+// Input: s = "aabcbaa"
+// Output: 17
+ 
+
+// Constraints:
+
+// 1 <= s.length <= 500
+// s consists of only lowercase English letters.
+
+class Solution {
+    public int beautySum(String s) {
+        int n = s.length(), ans = 0;
+        for(int i = 0; i < n; i++){
+            int[] count = new int[26];
+            int maxi = 0, mini = 0;
+            for(int j = i; j < n; j++){
+                int idx = s.charAt(j) - 'a';
+                maxi = Math.max(maxi, ++count[idx]);
+                if(mini >= count[idx] - 1){
+                    mini = count[idx];
+                    for(int k = 0; k < 26; k++)
+                        mini = Math.min(mini, count[k] == 0 ? Integer.MAX_VALUE : count[k]);
+                }
+                ans += maxi - mini;
+            }
+        }
+        return ans;
+    }
+}

Hashing/SumOfBeautyOfAllSubstrings1781.cpp

@@ -0,0 +1,51 @@
+// A digit string is good if the digits (0-indexed) at even indices are even and the digits at odd indices are prime (2, 3, 5, or 7).
+
+// For example, "2582" is good because the digits (2 and 8) at even positions are even and the digits (5 and 2) at odd positions are prime. However, "3245" is not good because 3 is at an even index but is not even.
+// Given an integer n, return the total number of good digit strings of length n. Since the answer may be large, return it modulo 109 + 7.
+
+// A digit string is a string consisting of digits 0 through 9 that may contain leading zeros.
+
+ 
+
+// Example 1:
+
+// Input: n = 1
+// Output: 5
+// Explanation: The good numbers of length 1 are "0", "2", "4", "6", "8".
+// Example 2:
+
+// Input: n = 4
+// Output: 400
+// Example 3:
+
+// Input: n = 50
+// Output: 564908303
+ 
+
+// Constraints:
+
+// 1 <= n <= 1015
+
+#define ll long long
+int p = 1e9 + 7;
+class Solution {
+public:
+    ll power(long long x, long long y){
+        long long res = 1;
+        x %= p;
+        if(x == 0) return 0;
+        while(y > 0){
+            if(y & 1) res = (res*x) % p;
+            y >>= 1;
+            x = (x*x) % p;
+        }
+        return res;
+    }
+    
+    int countGoodNumbers(long long n) {
+        ll count4s = n/2;
+        ll count5s = n - (n/2);
+        ll ans = ((power(4, count4s) % p * power(5, count5s)) % p);
+        return (int) ans;
+    }
+};