Feb-16

Author: geemaple

README.md

@@ -0,0 +1,62 @@
+//  Tag: Hash Table, String, Sliding Window
+//  Time: O(N)
+//  Space: O(N^2)
+//  Ref: -
+//  Note: -
+
+//  Given a string s, return the maximum number of occurrences of any substring under the following rules:
+//  
+//  The number of unique characters in the substring must be less than or equal to maxLetters.
+//  The substring size must be between minSize and maxSize inclusive.
+//  
+//   
+//  Example 1:
+//  
+//  Input: s = "aababcaab", maxLetters = 2, minSize = 3, maxSize = 4
+//  Output: 2
+//  Explanation: Substring "aab" has 2 occurrences in the original string.
+//  It satisfies the conditions, 2 unique letters and size 3 (between minSize and maxSize).
+//  
+//  Example 2:
+//  
+//  Input: s = "aaaa", maxLetters = 1, minSize = 3, maxSize = 3
+//  Output: 2
+//  Explanation: Substring "aaa" occur 2 times in the string. It can overlap.
+//  
+//   
+//  Constraints:
+//  
+//  1 <= s.length <= 105
+//  1 <= maxLetters <= 26
+//  1 <= minSize <= maxSize <= min(26, s.length)
+//  s consists of only lowercase English letters.
+//  
+//  
+
+class Solution {
+public:
+    int maxFreq(string s, int maxLetters, int minSize, int maxSize) {
+        int n = s.size();
+        unordered_map<char, int> counter;
+        unordered_map<string, int> res_counter;
+        int res = 0;
+        int i = 0;
+        for (int j = 0; j < n; j++) {
+            counter[s[j]] += 1;
+            while (j - i + 1 >= minSize) {
+                if (j - i + 1 <= maxSize && counter.size() <= maxLetters) {
+                    string sub = s.substr(i, j - i + 1);
+                    res_counter[sub] += 1;
+                    res = max(res, res_counter[sub]);
+                }
+                counter[s[i]] -= 1;
+                if (counter[s[i]] == 0) {
+                    counter.erase(s[i]);
+                }
+                i += 1;
+            }
+        }
+
+        return res;
+    }   
+};

leetcode/1297.maximum-number-of-occurrences-of-a-substring.cpp

@@ -0,0 +1,57 @@
+#  Tag: Hash Table, String, Sliding Window
+#  Time: O(N)
+#  Space: O(N^2)
+#  Ref: -
+#  Note: -
+
+#  Given a string s, return the maximum number of occurrences of any substring under the following rules:
+#  
+#  The number of unique characters in the substring must be less than or equal to maxLetters.
+#  The substring size must be between minSize and maxSize inclusive.
+#  
+#   
+#  Example 1:
+#  
+#  Input: s = "aababcaab", maxLetters = 2, minSize = 3, maxSize = 4
+#  Output: 2
+#  Explanation: Substring "aab" has 2 occurrences in the original string.
+#  It satisfies the conditions, 2 unique letters and size 3 (between minSize and maxSize).
+#  
+#  Example 2:
+#  
+#  Input: s = "aaaa", maxLetters = 1, minSize = 3, maxSize = 3
+#  Output: 2
+#  Explanation: Substring "aaa" occur 2 times in the string. It can overlap.
+#  
+#   
+#  Constraints:
+#  
+#  1 <= s.length <= 105
+#  1 <= maxLetters <= 26
+#  1 <= minSize <= maxSize <= min(26, s.length)
+#  s consists of only lowercase English letters.
+#  
+#  
+
+from collections import defaultdict
+class Solution:
+    def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:
+        n = len(s)
+        counter = defaultdict(int)
+        i = 0
+        res = 0
+        res_count = defaultdict(int)
+        for j in range(n):
+            counter[s[j]] += 1
+ 
+            while (j - i + 1 >= minSize):
+                if j - i + 1 <= maxSize and len(counter) <= maxLetters:
+                    sub = s[i: j + 1]
+                    res_count[sub] += 1
+                    res = max(res, res_count[sub])
+                counter[s[i]] -= 1
+                if counter[s[i]] == 0:
+                    del counter[s[i]]
+                i += 1
+
+        return res

leetcode/1297.maximum-number-of-occurrences-of-a-substring.py

@@ -0,0 +1,72 @@
+//  Tag: Array, Backtracking
+//  Time: O(N!)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+//  Video: https://youtu.be/3Z75z9sojwg
+
+//  Given an integer n, find a sequence that satisfies all of the following:
+//  
+//  The integer 1 occurs once in the sequence.
+//  Each integer between 2 and n occurs twice in the sequence.
+//  For every integer i between 2 and n, the distance between the two occurrences of i is exactly i.
+//  
+//  The distance between two numbers on the sequence, a[i] and a[j], is the absolute difference of their indices, |j - i|.
+//  Return the lexicographically largest sequence. It is guaranteed that under the given constraints, there is always a solution. 
+//  A sequence a is lexicographically larger than a sequence b (of the same length) if in the first position where a and b differ, sequence a has a number greater than the corresponding number in b. For example, [0,1,9,0] is lexicographically larger than [0,1,5,6] because the first position they differ is at the third number, and 9 is greater than 5.
+//   
+//  Example 1:
+//  
+//  Input: n = 3
+//  Output: [3,1,2,3,2]
+//  Explanation: [2,3,2,1,3] is also a valid sequence, but [3,1,2,3,2] is the lexicographically largest valid sequence.
+//  
+//  Example 2:
+//  
+//  Input: n = 5
+//  Output: [5,3,1,4,3,5,2,4,2]
+//  
+//   
+//  Constraints:
+//  
+//  1 <= n <= 20
+//  
+//  
+
+class Solution {
+public:
+    vector<int> constructDistancedSequence(int n) {
+        vector<int> res(2 * n - 1, 0);
+        vector<bool> used(n + 1, false);
+        helper(0, res, used, n);
+        return res;
+    }
+
+    bool helper(int i, vector<int> &res, vector<bool> &used, int n) {
+        if (i == res.size()) {
+            return true;
+        }
+
+        if (res[i] != 0) {
+            return helper(i + 1, res, used, n);
+        }
+
+        for (int num = n; num >= 1; num--) {
+            if (used[num]) {
+                continue;
+            }
+            int j = num == 1 ? i : i + num;
+            if (j < res.size() && res[j] == 0) {
+                used[num] = true; 
+                res[i] = res[j] = num;
+                if (helper(i + 1, res, used, n)) {
+                    return true;
+                }
+                res[i] = res[j] = 0;
+                used[num] = false;
+            }
+        }
+
+        return false;
+    }
+};

leetcode/1718.construct-the-lexicographically-largest-valid-sequence.cpp

@@ -0,0 +1,63 @@
+#  Tag: Array, Backtracking
+#  Time: O(N!)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+#  Video: https://youtu.be/3Z75z9sojwg
+
+#  Given an integer n, find a sequence that satisfies all of the following:
+#  
+#  The integer 1 occurs once in the sequence.
+#  Each integer between 2 and n occurs twice in the sequence.
+#  For every integer i between 2 and n, the distance between the two occurrences of i is exactly i.
+#  
+#  The distance between two numbers on the sequence, a[i] and a[j], is the absolute difference of their indices, |j - i|.
+#  Return the lexicographically largest sequence. It is guaranteed that under the given constraints, there is always a solution. 
+#  A sequence a is lexicographically larger than a sequence b (of the same length) if in the first position where a and b differ, sequence a has a number greater than the corresponding number in b. For example, [0,1,9,0] is lexicographically larger than [0,1,5,6] because the first position they differ is at the third number, and 9 is greater than 5.
+#   
+#  Example 1:
+#  
+#  Input: n = 3
+#  Output: [3,1,2,3,2]
+#  Explanation: [2,3,2,1,3] is also a valid sequence, but [3,1,2,3,2] is the lexicographically largest valid sequence.
+#  
+#  Example 2:
+#  
+#  Input: n = 5
+#  Output: [5,3,1,4,3,5,2,4,2]
+#  
+#   
+#  Constraints:
+#  
+#  1 <= n <= 20
+#  
+#  
+
+class Solution:
+    def constructDistancedSequence(self, n: int) -> List[int]:
+        res = [0 for i in range(2 * n - 1)]
+        used = [False for i in range(n + 1)]
+        self.helper(0, res, n, used)
+        return res
+
+    def helper(self, i: int, res: list, n: int, used: list) -> bool:
+        if i == len(res):
+            return True
+
+        if res[i] != 0:
+            return self.helper(i + 1, res, n, used)
+
+        for num in range(n, 0, -1):
+            if used[num]:
+                continue
+
+            j = i + num if num > 1 else i
+            if j < len(res) and res[j] == 0:
+                used[num] = True
+                res[i] = res[j] = num
+                if self.helper(i + 1, res, n, used):
+                    return True
+                res[i] = res[j] = 0
+                used[num] = False
+
+        return False

leetcode/1718.construct-the-lexicographically-largest-valid-sequence.py

@@ -0,0 +1,114 @@
+//  Tag: Array, Hash Table, Sliding Window
+//  Time: O(N)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+
+//  Given an integer array nums containing n integers, find the beauty of each subarray of size k.
+//  The beauty of a subarray is the xth smallest integer in the subarray if it is negative, or 0 if there are fewer than x negative integers.
+//  Return an integer array containing n - k + 1 integers, which denote the beauty of the subarrays in order from the first index in the array.
+//  
+//  
+//  A subarray is a contiguous non-empty sequence of elements within an array.
+//  
+//  
+//   
+//  Example 1:
+//  
+//  Input: nums = [1,-1,-3,-2,3], k = 3, x = 2
+//  Output: [-1,-2,-2]
+//  Explanation: There are 3 subarrays with size k = 3. 
+//  The first subarray is [1, -1, -3] and the 2nd smallest negative integer is -1. 
+//  The second subarray is [-1, -3, -2] and the 2nd smallest negative integer is -2. 
+//  The third subarray is [-3, -2, 3] and the 2nd smallest negative integer is -2.
+//  Example 2:
+//  
+//  Input: nums = [-1,-2,-3,-4,-5], k = 2, x = 2
+//  Output: [-1,-2,-3,-4]
+//  Explanation: There are 4 subarrays with size k = 2.
+//  For [-1, -2], the 2nd smallest negative integer is -1.
+//  For [-2, -3], the 2nd smallest negative integer is -2.
+//  For [-3, -4], the 2nd smallest negative integer is -3.
+//  For [-4, -5], the 2nd smallest negative integer is -4. 
+//  Example 3:
+//  
+//  Input: nums = [-3,1,2,-3,0,-3], k = 2, x = 1
+//  Output: [-3,0,-3,-3,-3]
+//  Explanation: There are 5 subarrays with size k = 2.
+//  For [-3, 1], the 1st smallest negative integer is -3.
+//  For [1, 2], there is no negative integer so the beauty is 0.
+//  For [2, -3], the 1st smallest negative integer is -3.
+//  For [-3, 0], the 1st smallest negative integer is -3.
+//  For [0, -3], the 1st smallest negative integer is -3.
+//   
+//  Constraints:
+//  
+//  n == nums.length 
+//  1 <= n <= 105
+//  1 <= k <= n
+//  1 <= x <= k 
+//  -50 <= nums[i] <= 50 
+//  
+//  
+
+class Solution {
+public:
+    vector<int> getSubarrayBeauty(vector<int>& nums, int k, int x) {
+        int n = nums.size();
+        unordered_map<int, int> counter;
+        vector<int> res(n - k + 1, 0);
+        for (int i = 0; i < n; i++) {
+            if (nums[i] < 0) {
+                counter[nums[i]] += 1;
+            }
+
+            if (i >= k - 1) {
+                int count = 0;
+                for (int num = -59; num < 0; num++) {
+                    count += counter[num];
+                    if (count >= x) {
+                        res[i - k + 1] = num;
+                        break;
+                    }
+                }
+                if (nums[i - k + 1] < 0) {
+                    counter[nums[i - k + 1]] -= 1;
+                    if (counter[nums[i - k + 1]] == 0) {
+                        counter.erase(nums[i - k + 1]);
+                    }
+
+                }
+            }
+        }
+        return res;
+    }
+};
+
+class Solution {
+public:
+    vector<int> getSubarrayBeauty(vector<int>& nums, int k, int x) {
+        int n = nums.size();
+        vector<int> counter(50, 0);
+        vector<int> res(n - k + 1, 0);
+        for (int i = 0; i < n; i++) {
+            if (nums[i] < 0) {
+                counter[nums[i] + 50] += 1;
+            }
+
+            if (i >= k - 1) {
+                int count = 0;
+                for (int num = 0; num < 50; num++) {
+                    count += counter[num];
+                    if (count >= x) {
+                        res[i - k + 1] = num - 50;
+                        break;
+                    }
+                }
+                if (nums[i - k + 1] < 0) {
+                    counter[nums[i - k + 1] + 50] -= 1;
+                }
+            }
+        }
+        return res;
+    }
+};