Apr-29

Author: geemaple

README.md

@@ -0,0 +1,97 @@
+//  Tag: Array, Hash Table, Math, Two Pointers
+//  Time: O(NM)
+//  Space: O(N + M)
+//  Ref: -
+//  Note: -
+
+//  Given two arrays of integers nums1 and nums2, return the number of triplets formed (type 1 and type 2) under the following rules:
+//  
+//  Type 1: Triplet (i, j, k) if nums1[i]2 == nums2[j] * nums2[k] where 0 <= i < nums1.length and 0 <= j < k < nums2.length.
+//  Type 2: Triplet (i, j, k) if nums2[i]2 == nums1[j] * nums1[k] where 0 <= i < nums2.length and 0 <= j < k < nums1.length.
+//  
+//   
+//  Example 1:
+//  
+//  Input: nums1 = [7,4], nums2 = [5,2,8,9]
+//  Output: 1
+//  Explanation: Type 1: (1, 1, 2), nums1[1]2 = nums2[1] * nums2[2]. (42 = 2 * 8). 
+//  
+//  Example 2:
+//  
+//  Input: nums1 = [1,1], nums2 = [1,1,1]
+//  Output: 9
+//  Explanation: All Triplets are valid, because 12 = 1 * 1.
+//  Type 1: (0,0,1), (0,0,2), (0,1,2), (1,0,1), (1,0,2), (1,1,2).  nums1[i]2 = nums2[j] * nums2[k].
+//  Type 2: (0,0,1), (1,0,1), (2,0,1). nums2[i]2 = nums1[j] * nums1[k].
+//  
+//  Example 3:
+//  
+//  Input: nums1 = [7,7,8,3], nums2 = [1,2,9,7]
+//  Output: 2
+//  Explanation: There are 2 valid triplets.
+//  Type 1: (3,0,2).  nums1[3]2 = nums2[0] * nums2[2].
+//  Type 2: (3,0,1).  nums2[3]2 = nums1[0] * nums1[1].
+//  
+//   
+//  Constraints:
+//  
+//  1 <= nums1.length, nums2.length <= 1000
+//  1 <= nums1[i], nums2[i] <= 105
+//  
+//  
+
+class Solution {
+public:
+    int numTriplets(vector<int>& nums1, vector<int>& nums2) {
+        sort(nums1.begin(), nums1.end());
+        sort(nums2.begin(), nums2.end());
+
+        unordered_map<int, int> counter1;
+        unordered_map<int, int> counter2;
+        for (auto &x : nums1) {
+            counter1[x] += 1;
+        }
+
+        for (auto &x: nums2) {
+            counter2[x] += 1;
+        }
+
+        int res = 0;
+        for (auto &[x, c]: counter1) {
+            res += count(nums2, counter2, 1LL * x * x) * c;
+        }
+
+        for (auto &[x, c]: counter2) {
+            res += count(nums1, counter1, 1LL * x * x) * c;
+        }
+
+        return res;
+    }
+
+    int count(vector<int>& nums, unordered_map<int, int> &counter, long long target) {
+        int l = 0;
+        int r = nums.size() - 1;
+        int res = 0;
+        while (l < r) {
+            long long tmp = 1LL * nums[l] * nums[r];
+            int left = counter[nums[l]];
+            int right = counter[nums[r]];
+            if (tmp == target) {
+                if (nums[l] == nums[r]) {
+                    res += left * (left - 1) / 2;
+                    break;
+                } else {
+                    res += left * right;
+                    l += left;
+                    r -= right;
+                }
+            } else if (tmp > target) {
+                r -= right;
+            } else {
+                l += left;
+            }
+        }
+
+        return res;
+    }
+};

leetcode/1577.number-of-ways-where-square-of-number-is-equal-to-product-of-two-numbers.cpp

@@ -0,0 +1,81 @@
+#  Tag: Array, Hash Table, Math, Two Pointers
+#  Time: O(NM)
+#  Space: O(N + M)
+#  Ref: -
+#  Note: -
+
+#  Given two arrays of integers nums1 and nums2, return the number of triplets formed (type 1 and type 2) under the following rules:
+#  
+#  Type 1: Triplet (i, j, k) if nums1[i]2 == nums2[j] * nums2[k] where 0 <= i < nums1.length and 0 <= j < k < nums2.length.
+#  Type 2: Triplet (i, j, k) if nums2[i]2 == nums1[j] * nums1[k] where 0 <= i < nums2.length and 0 <= j < k < nums1.length.
+#  
+#   
+#  Example 1:
+#  
+#  Input: nums1 = [7,4], nums2 = [5,2,8,9]
+#  Output: 1
+#  Explanation: Type 1: (1, 1, 2), nums1[1]2 = nums2[1] * nums2[2]. (42 = 2 * 8). 
+#  
+#  Example 2:
+#  
+#  Input: nums1 = [1,1], nums2 = [1,1,1]
+#  Output: 9
+#  Explanation: All Triplets are valid, because 12 = 1 * 1.
+#  Type 1: (0,0,1), (0,0,2), (0,1,2), (1,0,1), (1,0,2), (1,1,2).  nums1[i]2 = nums2[j] * nums2[k].
+#  Type 2: (0,0,1), (1,0,1), (2,0,1). nums2[i]2 = nums1[j] * nums1[k].
+#  
+#  Example 3:
+#  
+#  Input: nums1 = [7,7,8,3], nums2 = [1,2,9,7]
+#  Output: 2
+#  Explanation: There are 2 valid triplets.
+#  Type 1: (3,0,2).  nums1[3]2 = nums2[0] * nums2[2].
+#  Type 2: (3,0,1).  nums2[3]2 = nums1[0] * nums1[1].
+#  
+#   
+#  Constraints:
+#  
+#  1 <= nums1.length, nums2.length <= 1000
+#  1 <= nums1[i], nums2[i] <= 105
+#  
+#  
+
+from collections import Counter
+class Solution:
+    def numTriplets(self, nums1: List[int], nums2: List[int]) -> int:
+        res = 0
+        nums1.sort()
+        nums2.sort()
+        counter1 = Counter(nums1)
+        counter2 = Counter(nums2)
+        for x in counter1:
+            res += self.count(nums2, counter2, x * x) * counter1[x]
+
+        for x in counter2:
+            res += self.count(nums1, counter1, x * x) * counter2[x]
+
+        return res
+
+    def count(self, nums: list, counter: dict, target: int) -> int:
+        l = 0
+        r = len(nums) - 1
+        res = 0
+        while l < r:
+            tmp = nums[l] * nums[r]
+            left = counter[nums[l]]
+            right = counter[nums[r]]
+
+            if tmp == target:
+                if nums[l] == nums[r]:
+                    res += left * (left - 1) // 2
+                    break
+                else:
+                    res += left * right
+                    l += left
+                    r -= right
+            elif tmp > target:
+                r -= right
+            else:
+                l += left
+
+        return res

leetcode/1577.number-of-ways-where-square-of-number-is-equal-to-product-of-two-numbers.py

@@ -1,37 +1,59 @@
+//  Tag: Array, Two Pointers, Sorting
+//  Time: O(N^2)
+//  Space: O(1)
+//  Ref: -
+//  Note: -
+
+//  Given an integer array nums of length n and an integer target, find three integers in nums such that the sum is closest to target.
+//  Return the sum of the three integers.
+//  You may assume that each input would have exactly one solution.
+//   
+//  Example 1:
+//  
+//  Input: nums = [-1,2,1,-4], target = 1
+//  Output: 2
+//  Explanation: The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+//  
+//  Example 2:
+//  
+//  Input: nums = [0,0,0], target = 1
+//  Output: 0
+//  Explanation: The sum that is closest to the target is 0. (0 + 0 + 0 = 0).
+//  
+//   
+//  Constraints:
+//  
+//  3 <= nums.length <= 500
+//  -1000 <= nums[i] <= 1000
+//  -104 <= target <= 104
+//  
+//  
+
 class Solution {
 public:
     int threeSumClosest(vector<int>& nums, int target) {
-        
-        int result = nums[0] + nums[1] + nums[3];
+        int n = nums.size();
+        int result = nums[0] + nums[1] + nums[2];
         sort(nums.begin(), nums.end());
 
-        for (auto i = 0; i < nums.size(); ++i)
-        {
-            int left = i + 1;
-            int right = nums.size() - 1;
-            while (left < right)
-            {
-                int tmp = nums[i] + nums[left] + nums[right];
-                if (abs(target - result) > abs(target - tmp))
-                {
+        for (int k = 2; k < n; k++) {
+            int l = 0;
+            int r = k - 1;
+            while (l < r) {
+                int tmp = nums[l] + nums[r] + nums[k];
+                if (abs(target - result) > abs(target - tmp)) {
                     result = tmp;
                 }
 
-                if (tmp < target)
-                {
-                    left ++;
-                }
-                else if(tmp > target)
-                {
-                    right --;
-                }
-                else
-                {
+                if (tmp == target) {
                     break;
+                } else if(tmp > target){
+                    r -= 1;
+                } else {
+                    l += 1;
                 }
             }
         }
-        
         return result;
     }
 };

leetcode/16.3sum-closest.cpp

@@ -1,58 +1,51 @@
-class Solution:
-    def threeSumClosest(self, nums: List[int], target: int) -> int:
-        res = float('inf')
-        nums.sort()
-
-        for i in range(len(nums) - 2):            
-            a = nums[i]
-            left = i + 1
-            right = len(nums) - 1
-            
-            while left < right:
-                threeSum = a + nums[left] + nums[right]
-                if abs(threeSum - target) < abs(res - target):
-                    res = threeSum
-                    
-                if threeSum == target:
-                    break
-                elif threeSum > target:
-                    right -= 1
-                else:
-                    left += 1
-                    
-        return res
+#  Tag: Array, Two Pointers, Sorting
+#  Time: O(N^2)
+#  Space: O(1)
+#  Ref: -
+#  Note: -
 
+#  Given an integer array nums of length n and an integer target, find three integers in nums such that the sum is closest to target.
+#  Return the sum of the three integers.
+#  You may assume that each input would have exactly one solution.
+#   
+#  Example 1:
+#  
+#  Input: nums = [-1,2,1,-4], target = 1
+#  Output: 2
+#  Explanation: The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+#  
+#  Example 2:
+#  
+#  Input: nums = [0,0,0], target = 1
+#  Output: 0
+#  Explanation: The sum that is closest to the target is 0. (0 + 0 + 0 = 0).
+#  
+#   
+#  Constraints:
+#  
+#  3 <= nums.length <= 500
+#  -1000 <= nums[i] <= 1000
+#  -104 <= target <= 104
+#  
+#  
 
-class Solution2:
+class Solution:
     def threeSumClosest(self, nums: List[int], target: int) -> int:
-        closest = float('inf')
+        n = len(nums)
         nums.sort()
+        res = float('inf')
+        for k in range(2, n):
+            l = 0
+            r = k - 1
+            while l < r:
+                tmp = nums[l] + nums[r] + nums[k]
+                if abs(res - target) > abs(tmp - target):
+                    res = tmp
 
-        for i in range(len(nums) - 2):
-            
-            if i > 0 and nums[i] == nums[i - 1]:
-                continue
-            
-            a = nums[i]
-            left = i + 1
-            right = len(nums) - 1
-            
-            while left < right:
-
-                threeSum = a + nums[left] + nums[right]
-                
-                if abs(threeSum - target) < abs(closest - target):
-                    closest = threeSum
-                    
-                if threeSum == target:
+                if tmp == target:
                     break
-                elif threeSum > target:
-                    while (left < right and nums[right] == nums[right - 1]): #remove duplicate
-                      right -= 1
-                    right -= 1
+                elif tmp > target:
+                    r -= 1
                 else:
-                    while (left < right and nums[left] == nums[left + 1]): #remove duplicate
-                      left += 1
-                    left += 1
-                    
-        return closest
+                    l += 1
+        return res

leetcode/16.3sum-closest.py

@@ -3,6 +3,7 @@
 //  Space: O(1)
 //  Ref: -
 //  Note: -
+//  Video: https://youtu.be/Ck_lb4dp6R4
 
 //  You are given an integer array nums and a positive integer k.
 //  Return the number of subarrays where the maximum element of nums appears at least k times in that subarray.

leetcode/2962.count-subarrays-where-max-element-appears-at-least-k-times.cpp

@@ -3,6 +3,7 @@
 #  Space: O(1)
 #  Ref: -
 #  Note: -
+#  Video: https://youtu.be/Ck_lb4dp6R4
 
 #  You are given an integer array nums and a positive integer k.
 #  Return the number of subarrays where the maximum element of nums appears at least k times in that subarray.