apr-19

Author: geemaple

README.md

@@ -0,0 +1,97 @@
+//  Tag: Hash Table, String, Sliding Window
+//  Time: O(N)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+
+//  You are given a string text. You can swap two of the characters in the text.
+//  Return the length of the longest substring with repeated characters.
+//   
+//  Example 1:
+//  
+//  Input: text = "ababa"
+//  Output: 3
+//  Explanation: We can swap the first 'b' with the last 'a', or the last 'b' with the first 'a'. Then, the longest repeated character substring is "aaa" with length 3.
+//  
+//  Example 2:
+//  
+//  Input: text = "aaabaaa"
+//  Output: 6
+//  Explanation: Swap 'b' with the last 'a' (or the first 'a'), and we get longest repeated character substring "aaaaaa" with length 6.
+//  
+//  Example 3:
+//  
+//  Input: text = "aaaaa"
+//  Output: 5
+//  Explanation: No need to swap, longest repeated character substring is "aaaaa" with length is 5.
+//  
+//   
+//  Constraints:
+//  
+//  1 <= text.length <= 2 * 104
+//  text consist of lowercase English characters only.
+//  
+//  
+
+class Solution {
+public:
+    int maxRepOpt1(string text) {
+        unordered_map<char, int> counter;
+        for (auto &ch: text) {
+            counter[ch] += 1;
+        } 
+        int res = 0;
+        for (auto &[k, c]: counter) {
+            int tmp = min(c, count(text, k));
+            res = max(res, tmp);
+        }
+        return res;
+    }
+
+    int count(string &text, char target) {
+        int n = text.size();
+        int i = 0;
+        int res = 0;
+        int count = 0;
+        for (int j = 0; j < n; j++) {
+            count += text[j] != target;
+            while (count > 1) {
+                count -= text[i] != target;
+                i += 1;
+            }
+            res = max(res, j - i + 1);
+        }
+        return res;
+    }
+};
+
+class Solution {
+public:
+    int maxRepOpt1(string text) {
+        int n = text.size();
+        vector<pair<int, int>> group;
+        vector<int> counter(26, 0);
+        int count = 1;
+        for (int i = 0; i < n; i++) {
+            counter[text[i] - 'a'] += 1;
+            if (i == n - 1 || text[i] != text[i + 1]) {
+                group.emplace_back(text[i] - 'a', count);
+                count = 1;
+            } else {
+                count += 1;
+            }
+        }
+
+        int res = 0;
+        for (auto &[x, count]: group) {
+            res = max(res, min(count + 1, counter[x]));
+        }
+
+        for (int i = 1; i < group.size() - 1; i++) {
+            if (group[i - 1].first == group[i + 1].first && group[i].second == 1) {
+                res = max(res, min(group[i - 1].second + group[i + 1].second + 1, counter[group[i - 1].first]));
+            }
+        }
+        return res;
+    }
+};

leetcode/1156.swap-for-longest-repeated-character-substring.cpp

@@ -0,0 +1,83 @@
+#  Tag: Hash Table, String, Sliding Window
+#  Time: O(N)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+
+#  You are given a string text. You can swap two of the characters in the text.
+#  Return the length of the longest substring with repeated characters.
+#   
+#  Example 1:
+#  
+#  Input: text = "ababa"
+#  Output: 3
+#  Explanation: We can swap the first 'b' with the last 'a', or the last 'b' with the first 'a'. Then, the longest repeated character substring is "aaa" with length 3.
+#  
+#  Example 2:
+#  
+#  Input: text = "aaabaaa"
+#  Output: 6
+#  Explanation: Swap 'b' with the last 'a' (or the first 'a'), and we get longest repeated character substring "aaaaaa" with length 6.
+#  
+#  Example 3:
+#  
+#  Input: text = "aaaaa"
+#  Output: 5
+#  Explanation: No need to swap, longest repeated character substring is "aaaaa" with length is 5.
+#  
+#   
+#  Constraints:
+#  
+#  1 <= text.length <= 2 * 104
+#  text consist of lowercase English characters only.
+#  
+#  
+
+from collections import Counter
+class Solution:
+    def maxRepOpt1(self, text: str) -> int:
+        res = 0
+        counter = Counter(text)
+        for k in counter:
+            count = min(counter[k], self.count(text, k))
+            res = max(res, count)
+        return res
+
+    def count(self, text: str, target: str) -> int:
+        n = len(text)
+        res = 0
+        i = 0
+        count = 0
+        for j in range(n):
+            count += text[j] != target
+            while count > 1:
+                count -= text[i] != target
+                i += 1
+
+            res = max(res, j - i + 1)
+        return res
+
+from collections import defaultdict
+class Solution:
+    def maxRepOpt1(self, text: str) -> int:
+        n = len(text)
+        group = []
+        counter = defaultdict(int)
+        count = 1
+        for i in range(n):
+            counter[text[i]] += 1
+            if i == n - 1 or text[i] != text[i + 1]:
+                group.append([text[i], count])
+                count = 1
+            else:
+                count += 1
+
+        res = 0
+        for x, count in group:
+            res = max(res, min(count + 1, counter[x]))
+
+        for i in range(1, len(group) - 1):
+            if group[i - 1][0] == group[i + 1][0] and group[i][1] == 1:
+                res = max(res, min(group[i - 1][1] + group[i + 1][1] + 1, counter[group[i - 1][0]]))
+
+        return res

leetcode/1156.swap-for-longest-repeated-character-substring.py

@@ -0,0 +1,72 @@
+//  Tag: Array
+//  Time: O(N^2)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+//  Video: https://youtu.be/OiRTe8BDOR0
+
+//  Given a 0-indexed integer array nums of length n and an integer k, return the number of pairs (i, j) where 0 <= i < j < n, such that nums[i] == nums[j] and (i * j) is divisible by k.
+//   
+//  Example 1:
+//  
+//  Input: nums = [3,1,2,2,2,1,3], k = 2
+//  Output: 4
+//  Explanation:
+//  There are 4 pairs that meet all the requirements:
+//  - nums[0] == nums[6], and 0 * 6 == 0, which is divisible by 2.
+//  - nums[2] == nums[3], and 2 * 3 == 6, which is divisible by 2.
+//  - nums[2] == nums[4], and 2 * 4 == 8, which is divisible by 2.
+//  - nums[3] == nums[4], and 3 * 4 == 12, which is divisible by 2.
+//  
+//  Example 2:
+//  
+//  Input: nums = [1,2,3,4], k = 1
+//  Output: 0
+//  Explanation: Since no value in nums is repeated, there are no pairs (i,j) that meet all the requirements.
+//  
+//   
+//  Constraints:
+//  
+//  1 <= nums.length <= 100
+//  1 <= nums[i], k <= 100
+//  
+//  
+
+class Solution {
+public:
+    int countPairs(vector<int>& nums, int k) {
+        int n = nums.size();
+        int res = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                if (nums[i] == nums[j] && i * j % k == 0) {
+                    res += 1;
+                }
+            }
+        }
+
+        return res;
+    }
+};
+
+class Solution {
+public:
+    int countPairs(vector<int>& nums, int k) {
+        int n = nums.size();
+        int res = 0;
+        unordered_map<int, vector<int>> m;
+        for (int i = 0;  i < n; ++i)
+            m[nums[i]].push_back(i);
+
+        for (auto &[x, ids] : m) {
+            unordered_map<int, int> gcds;
+            for (auto i : ids) {
+                auto gcd_i = gcd(i, k);
+                for (auto &[gcd_j, cnt] : gcds)
+                    res += gcd_i * gcd_j % k ? 0 : cnt;
+                gcds[gcd_i] += 1;
+            }
+        }
+        return res;
+    }
+};

leetcode/2176.count-equal-and-divisible-pairs-in-an-array.cpp

@@ -0,0 +1,63 @@
+#  Tag: Array
+#  Time: O(N^2)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
+#  Video: https://youtu.be/OiRTe8BDOR0
+
+#  Given a 0-indexed integer array nums of length n and an integer k, return the number of pairs (i, j) where 0 <= i < j < n, such that nums[i] == nums[j] and (i * j) is divisible by k.
+#   
+#  Example 1:
+#  
+#  Input: nums = [3,1,2,2,2,1,3], k = 2
+#  Output: 4
+#  Explanation:
+#  There are 4 pairs that meet all the requirements:
+#  - nums[0] == nums[6], and 0 * 6 == 0, which is divisible by 2.
+#  - nums[2] == nums[3], and 2 * 3 == 6, which is divisible by 2.
+#  - nums[2] == nums[4], and 2 * 4 == 8, which is divisible by 2.
+#  - nums[3] == nums[4], and 3 * 4 == 12, which is divisible by 2.
+#  
+#  Example 2:
+#  
+#  Input: nums = [1,2,3,4], k = 1
+#  Output: 0
+#  Explanation: Since no value in nums is repeated, there are no pairs (i,j) that meet all the requirements.
+#  
+#   
+#  Constraints:
+#  
+#  1 <= nums.length <= 100
+#  1 <= nums[i], k <= 100
+#  
+#  
+
+class Solution:
+    def countPairs(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        res = 0
+        for i in range(n):
+            for j in range(i + 1, n):
+                if nums[i] == nums[j] and i * j % k == 0:
+                    res += 1
+
+        return res
+    
+from collections import defaultdict
+import math
+class Solution:
+    def countPairs(self, nums: List[int], k: int) -> int:
+        n = len(nums)
+        indexes = defaultdict(list)
+        for i in range(n):
+            indexes[nums[i]].append(i)
+
+        res = 0
+        for x, ids in indexes.items():
+            gcds = defaultdict(int)
+            for i in ids:
+                gcd_i = math.gcd(i, k)
+                for gcd_j, count in gcds.items():
+                    res += count if gcd_i * gcd_j % k == 0 else 0
+                gcds[gcd_i] += 1
+        return res

leetcode/2176.count-equal-and-divisible-pairs-in-an-array.py

@@ -3,6 +3,7 @@
 //  Space: O(N)
 //  Ref: -
 //  Note: -
+//  Video: https://youtu.be/WUVFxJR_EB8
 
 //  Given an integer array nums and an integer k, return the number of good subarrays of nums.
 //  A subarray arr is good if there are at least k pairs of indices (i, j) such that i < j and arr[i] == arr[j].

leetcode/2537.count-the-number-of-good-subarrays.cpp

@@ -3,6 +3,7 @@
 #  Space: O(N)
 #  Ref: -
 #  Note: -
+#  Video: https://youtu.be/WUVFxJR_EB8
 
 #  Given an integer array nums and an integer k, return the number of good subarrays of nums.
 #  A subarray arr is good if there are at least k pairs of indices (i, j) such that i < j and arr[i] == arr[j].