740. Delete and Earn

3297. Count Substrings That Can Be Rearranged to Contain a String I.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    long long validSubstringCount(string word1, string word2) {
+        int count = 0;
+        long long ans = 0;
+        int l = 0, r = 0;
+        vector<int> map2(27, 0), map1(27, 0);
+        for (int i = 0; i < word2.size(); i++) {
+            map2[word2[i] - 'a']++;
+        }
+        while (r < word1.size()) {
+            map1[word1[r] - 'a']++;
+            if (map1[word1[r] - 'a'] == map2[word1[r] - 'a'])
+                count += map2[word1[r] - 'a'];
+            while (count == word2.size()) {
+                ans += (word1.size() - r);
+                map1[word1[l] - 'a']--;
+                if (map1[word1[l] - 'a'] < map2[word1[l] - 'a'])
+                    count -= map2[word1[l] - 'a'];
+                l++;
+            }
+            r++;
+        }
+        return ans;
+    }
+};

3298. Count Substrings That Can Be Rearranged to Contain a String II.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    long long validSubstringCount(string word1, string word2) {
+        int count = 0;
+        long long ans = 0;
+        int l = 0, r = 0;
+        vector<int> map2(27, 0), map1(27, 0);
+        for (int i = 0; i < word2.size(); i++) {
+            map2[word2[i] - 'a']++;
+        }
+        while (r < word1.size()) {
+            map1[word1[r] - 'a']++;
+            if (map1[word1[r] - 'a'] == map2[word1[r] - 'a'])
+                count += map2[word1[r] - 'a'];
+            while (count == word2.size()) {
+                ans += (word1.size() - r);
+                map1[word1[l] - 'a']--;
+                if (map1[word1[l] - 'a'] < map2[word1[l] - 'a'])
+                    count -= map2[word1[l] - 'a'];
+                l++;
+            }
+            r++;
+        }
+        return ans;
+    }
+};

740. Delete and Earn.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    int deleteAndEarn(vector<int>& nums) {
+        int m = 10001;
+        int n = nums.size();
+        int maxVal = 0;
+        vector<int> f(m, 0);
+        vector<int> dp(m + 1, 0);
+
+        for (int i = 0; i < n; i++) {
+            f[nums[i]]++;
+            maxVal = max(maxVal, nums[i]);
+        }
+
+        dp[1] = f[1];
+        for (int i = 2; i <= maxVal; i++) {
+            dp[i] = max(dp[i - 1], dp[i - 2] + f[i] * i);
+        }
+
+        return dp[maxVal];
+    }
+};