Apr-15

Author: geemaple

README.md

@@ -0,0 +1,80 @@
+//  Tag: Array, Queue, Sliding Window, Heap (Priority Queue), Ordered Set, Monotonic Queue
+//  Time: O(N)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+
+//  Given an array of integers nums and an integer limit, return the size of the longest non-empty subarray such that the absolute difference between any two elements of this subarray is less than or equal to limit.
+//   
+//  Example 1:
+//  
+//  Input: nums = [8,2,4,7], limit = 4
+//  Output: 2 
+//  Explanation: All subarrays are: 
+//  [8] with maximum absolute diff |8-8| = 0 <= 4.
+//  [8,2] with maximum absolute diff |8-2| = 6 > 4. 
+//  [8,2,4] with maximum absolute diff |8-2| = 6 > 4.
+//  [8,2,4,7] with maximum absolute diff |8-2| = 6 > 4.
+//  [2] with maximum absolute diff |2-2| = 0 <= 4.
+//  [2,4] with maximum absolute diff |2-4| = 2 <= 4.
+//  [2,4,7] with maximum absolute diff |2-7| = 5 > 4.
+//  [4] with maximum absolute diff |4-4| = 0 <= 4.
+//  [4,7] with maximum absolute diff |4-7| = 3 <= 4.
+//  [7] with maximum absolute diff |7-7| = 0 <= 4. 
+//  Therefore, the size of the longest subarray is 2.
+//  
+//  Example 2:
+//  
+//  Input: nums = [10,1,2,4,7,2], limit = 5
+//  Output: 4 
+//  Explanation: The subarray [2,4,7,2] is the longest since the maximum absolute diff is |2-7| = 5 <= 5.
+//  
+//  Example 3:
+//  
+//  Input: nums = [4,2,2,2,4,4,2,2], limit = 0
+//  Output: 3
+//  
+//   
+//  Constraints:
+//  
+//  1 <= nums.length <= 105
+//  1 <= nums[i] <= 109
+//  0 <= limit <= 109
+//  
+//  
+
+class Solution {
+public:
+    int longestSubarray(vector<int>& nums, int limit) {
+        int n = nums.size();
+        deque<int> smallq;
+        deque<int> bigq;
+        int res = 0;
+        int i = 0;
+        for (int j = 0; j < n; j++) {
+            while (!bigq.empty() && nums[bigq.back()] < nums[j]) {
+                bigq.pop_back();
+            }
+            bigq.push_back(j);
+
+            while (!smallq.empty() && nums[smallq.back()] > nums[j]) {
+                smallq.pop_back();
+            }
+            smallq.push_back(j);
+            while (nums[bigq.front()] - nums[smallq.front()] > limit) {
+                if (i == bigq.front()) {
+                    bigq.pop_front();
+                }
+
+                if (i == smallq.front()) {
+                    smallq.pop_front();
+                }
+                i += 1;
+            }
+    
+            res = max(res, j - i + 1);
+        }
+
+        return res;
+    }
+};

leetcode/1438.longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.cpp

@@ -0,0 +1,74 @@
+#  Tag: Array, Queue, Sliding Window, Heap (Priority Queue), Ordered Set, Monotonic Queue
+#  Time: O(N)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+
+#  Given an array of integers nums and an integer limit, return the size of the longest non-empty subarray such that the absolute difference between any two elements of this subarray is less than or equal to limit.
+#   
+#  Example 1:
+#  
+#  Input: nums = [8,2,4,7], limit = 4
+#  Output: 2 
+#  Explanation: All subarrays are: 
+#  [8] with maximum absolute diff |8-8| = 0 <= 4.
+#  [8,2] with maximum absolute diff |8-2| = 6 > 4. 
+#  [8,2,4] with maximum absolute diff |8-2| = 6 > 4.
+#  [8,2,4,7] with maximum absolute diff |8-2| = 6 > 4.
+#  [2] with maximum absolute diff |2-2| = 0 <= 4.
+#  [2,4] with maximum absolute diff |2-4| = 2 <= 4.
+#  [2,4,7] with maximum absolute diff |2-7| = 5 > 4.
+#  [4] with maximum absolute diff |4-4| = 0 <= 4.
+#  [4,7] with maximum absolute diff |4-7| = 3 <= 4.
+#  [7] with maximum absolute diff |7-7| = 0 <= 4. 
+#  Therefore, the size of the longest subarray is 2.
+#  
+#  Example 2:
+#  
+#  Input: nums = [10,1,2,4,7,2], limit = 5
+#  Output: 4 
+#  Explanation: The subarray [2,4,7,2] is the longest since the maximum absolute diff is |2-7| = 5 <= 5.
+#  
+#  Example 3:
+#  
+#  Input: nums = [4,2,2,2,4,4,2,2], limit = 0
+#  Output: 3
+#  
+#   
+#  Constraints:
+#  
+#  1 <= nums.length <= 105
+#  1 <= nums[i] <= 109
+#  0 <= limit <= 109
+#  
+#  
+
+from collections import deque
+class Solution:
+    def longestSubarray(self, nums: List[int], limit: int) -> int:
+        n = len(nums)
+        res = 0
+        bigq = deque()
+        smallq = deque()
+        i = 0
+        for j in range(n):
+            while len(bigq) > 0 and nums[bigq[-1]] < nums[j]:
+                bigq.pop()
+            bigq.append(j)
+
+            while len(smallq) > 0 and nums[smallq[-1]] > nums[j]:
+                smallq.pop()
+            smallq.append(j)
+
+            while nums[bigq[0]] - nums[smallq[0]] > limit:
+                if i == bigq[0]:
+                    bigq.popleft()
+
+                if i == smallq[0]:
+                    smallq.popleft()
+
+                i += 1
+            
+            res = max(res, j - i + 1)
+
+        return res

leetcode/1438.longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.py

@@ -0,0 +1,84 @@
+//  Tag: Array, Binary Search, Divide and Conquer, Binary Indexed Tree, Segment Tree, Merge Sort, Ordered Set
+//  Time: O(NlogN)
+//  Space: O(N)
+//  Ref: -
+//  Note: -
+//  Video: https://youtu.be/xWhiSWNeLtk
+
+//  You are given two 0-indexed arrays nums1 and nums2 of length n, both of which are permutations of [0, 1, ..., n - 1].
+//  A good triplet is a set of 3 distinct values which are present in increasing order by position both in nums1 and nums2. In other words, if we consider pos1v as the index of the value v in nums1 and pos2v as the index of the value v in nums2, then a good triplet will be a set (x, y, z) where 0 <= x, y, z <= n - 1, such that pos1x < pos1y < pos1z and pos2x < pos2y < pos2z.
+//  Return the total number of good triplets.
+//   
+//  Example 1:
+//  
+//  Input: nums1 = [2,0,1,3], nums2 = [0,1,2,3]
+//  Output: 1
+//  Explanation: 
+//  There are 4 triplets (x,y,z) such that pos1x < pos1y < pos1z. They are (2,0,1), (2,0,3), (2,1,3), and (0,1,3). 
+//  Out of those triplets, only the triplet (0,1,3) satisfies pos2x < pos2y < pos2z. Hence, there is only 1 good triplet.
+//  
+//  Example 2:
+//  
+//  Input: nums1 = [4,0,1,3,2], nums2 = [4,1,0,2,3]
+//  Output: 4
+//  Explanation: The 4 good triplets are (4,0,3), (4,0,2), (4,1,3), and (4,1,2).
+//  
+//   
+//  Constraints:
+//  
+//  n == nums1.length == nums2.length
+//  3 <= n <= 105
+//  0 <= nums1[i], nums2[i] <= n - 1
+//  nums1 and nums2 are permutations of [0, 1, ..., n - 1].
+//  
+//  
+
+class BitTree {
+public:
+    int n;
+    vector<int> arr;
+    BitTree(int size) {
+        n = size;
+        arr.resize(size + 1);
+    }
+
+    void update(int i, int delta) {
+        i = i + 1;
+        while (i <= n) {
+            arr[i] += delta;
+            i += i & -i;
+        }
+    }
+    
+    int query(int i) {
+        int res = 0;
+        i = i + 1;
+        while (i > 0) {
+            res += arr[i];
+            i -= i & -i;
+        }
+        return res;
+    }
+};
+
+class Solution {
+public:
+    long long goodTriplets(vector<int>& nums1, vector<int>& nums2) {
+        int n = nums1.size();
+        vector<int> indexes(n, 0);
+        for (int i = 0; i < n; i++) {
+            indexes[nums2[i]] = i;
+        }
+
+        BitTree bit(n);
+        long long res = 0;
+        for (int i = 0; i < n; i++) {
+            int mid = indexes[nums1[i]];
+            int small = bit.query(mid);
+            int big = n - 1 - mid - (i - small);
+            res += 1LL * big * small;
+            bit.update(mid, 1);
+        }
+        return res;
+    }
+};

leetcode/2179.count-good-triplets-in-an-array.cpp

@@ -0,0 +1,70 @@
+#  Tag: Array, Binary Search, Divide and Conquer, Binary Indexed Tree, Segment Tree, Merge Sort, Ordered Set
+#  Time: O(NlogN)
+#  Space: O(N)
+#  Ref: -
+#  Note: -
+#  Video: https://youtu.be/xWhiSWNeLtk
+
+#  You are given two 0-indexed arrays nums1 and nums2 of length n, both of which are permutations of [0, 1, ..., n - 1].
+#  A good triplet is a set of 3 distinct values which are present in increasing order by position both in nums1 and nums2. In other words, if we consider pos1v as the index of the value v in nums1 and pos2v as the index of the value v in nums2, then a good triplet will be a set (x, y, z) where 0 <= x, y, z <= n - 1, such that pos1x < pos1y < pos1z and pos2x < pos2y < pos2z.
+#  Return the total number of good triplets.
+#   
+#  Example 1:
+#  
+#  Input: nums1 = [2,0,1,3], nums2 = [0,1,2,3]
+#  Output: 1
+#  Explanation: 
+#  There are 4 triplets (x,y,z) such that pos1x < pos1y < pos1z. They are (2,0,1), (2,0,3), (2,1,3), and (0,1,3). 
+#  Out of those triplets, only the triplet (0,1,3) satisfies pos2x < pos2y < pos2z. Hence, there is only 1 good triplet.
+#  
+#  Example 2:
+#  
+#  Input: nums1 = [4,0,1,3,2], nums2 = [4,1,0,2,3]
+#  Output: 4
+#  Explanation: The 4 good triplets are (4,0,3), (4,0,2), (4,1,3), and (4,1,2).
+#  
+#   
+#  Constraints:
+#  
+#  n == nums1.length == nums2.length
+#  3 <= n <= 105
+#  0 <= nums1[i], nums2[i] <= n - 1
+#  nums1 and nums2 are permutations of [0, 1, ..., n - 1].
+#  
+#  
+
+class BitTree:
+    def __init__(self, size):
+        self.n = size
+        self.arr = [0] * (size + 1)
+
+    def update(self, i: int, delta: int):
+        i = i + 1
+        while i <= self.n: 
+            self.arr[i] += delta
+            i += i & -i
+
+    def prefix_sum(self, i: int) -> int:
+        i = i + 1
+        res = 0
+        while i > 0:
+            res += self.arr[i]
+            i -= i & -i
+        return res
+
+class Solution:
+    def goodTriplets(self, nums1: List[int], nums2: List[int]) -> int:
+        n = len(nums1)
+        indexes = [0 for i in range(n)]
+        for i in range(n):
+            indexes[nums2[i]] = i
+
+        bit = BitTree(n)
+        res = 0
+        for i in range(n):
+            mid = indexes[nums1[i]]
+            small = bit.prefix_sum(mid)
+            big = n - 1 - mid - (i - small)
+            res += small * big
+            bit.update(mid, 1)
+        return res

leetcode/2179.count-good-triplets-in-an-array.py

@@ -101,7 +101,7 @@
 86. https://leetcode.com/problems/count-of-substrings-containing-every-vowel-and-k-consonants-ii/ +Mark
 87. https://leetcode.com/problems/subarrays-with-k-different-integers/
 
-- https://leetcode.com/problems/longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit/
+88. https://leetcode.com/problems/longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit/
 - https://leetcode.com/problems/friends-of-appropriate-ages/
 - https://leetcode.com/problems/longest-nice-subarray/
 - https://leetcode.com/problems/swap-for-longest-repeated-character-substring/