代码随想录｜Day06｜哈希表02｜454. 四数相加II、383. 赎金信、15. 三数之和、18. 四数之和

454.四数相加II

本题和 1. 两数之和 类似，区别不过是本题需要两列表为一组遍历。

首先我们两个for循环遍历出列表 nums1 和 nums2 所有的和，并在字典 sum_count 中存储出现次数。再以相同的方法遍历 nums3 和 num4，计算补数，并在 sum_count 中寻找补数的出现次数。

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:

        sum_count = {}
        count = 0

        for num1 in nums1:
            for num2 in nums2:
                if num1 + num2 in sum_count:
                    sum_count[num1 + num2] += 1
                else:
                    sum_count[num1 + num2] = 1
        
        for num3 in nums3:
            for num4 in nums4:
                target = 0 - (num3 + num4)
                if target in sum_count:
                    count += sum_count[target]

        return count
# 时间复杂度：
# O(n²)
# 空间复杂度：
# 在最糟的情况下，如果 num1 和 num2 的和各不相同，sum_count 需要存储 n² 个键值对
# O(n²)

383. 赎金信

本题和上一篇博客​​​​​​​中的 242. 有效的字母异位词 类似，区别在于 magazine 中出现的字母并不一定全部在 ransomNote 中出现，因此判断条件有所区别。

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:

        count = {}

        for char in magazine:
            if char in count:
                count[char] += 1
            else:
                count[char] = 1
        
        for char in ransomNote:
            # 如果 ransomNote 中的字母不在 magazine 中，
            # 或者 magazine 中的字母已经被用完。
            if char not in count or count[char] == 0:
                return False
            else:
                count[char] -= 1

        return True
# 时间复杂度：
# O(n)
# 空间复杂度：
# O(n)

15. 三数之和​​​​​​

 本题需要注意去重，因此使用哈希法的时候，剪枝比较困难。

因此，本题采用双指针对排序数组进行操作，因此剪枝会更加直接。

思路：我们遍历列表，对于每个元素，我们通过使用双指针在其之后的元素中寻找符合条件的三元组。

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:

        nums.sort()
        res = []

        for i in range(len(nums)):
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            
            left, right = i + 1, len(nums) - 1

            while left < right:
                cur_sum = nums[i] + nums[left] + nums[right]
                # 由于排过序，此时需要 left 右移，获取更大的数值
                if cur_sum < 0:
                    left += 1
                # 此时需要 right 左移，获取更小的数值    
                elif cur_sum > 0:
                    right -= 1
                else:
                    res.append([nums[i], nums[left], nums[right]])
                    # 当我们获得符合条件的三元组
                    # 需要移动 left 和 right，以防止重复的三元组
                    while left < right and nums[left] == nums[left + 1]:
                        left += 1
                    while left < right and nums[right] == nums[right - 1]:
                        right -= 1
                    # 经过上述操作，left 和 right 会停留在最后一个重复的元素上
                    left += 1
                    right -= 1

        return res
# 时间复杂度：
# O(nlogn) + O(n²) = O(n²)

18. 四数之和 

在理解 15. 三数之和 后，本题的思路其实是一样的，只是我们现在需要先确定两个元素，然后使用双指针在后面的元素中寻找符合条件的四元组。

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:

        nums.sort()
        res = []

        for a in range(len(nums)):
            # 避免 a 重复
            if a > 0 and nums[a] == nums[a - 1]:
                continue

            for b in range(a + 1, len(nums)):
                # 避免 b 重复
                if b > a + 1 and nums[b] == nums[b - 1]:
                    continue

                left, right = b + 1, len(nums) - 1
                while left < right:
                    cur_sum = nums[a] + nums[b] + nums[left] + nums[right]
                    
                    if cur_sum < target:
                        left += 1
                    elif cur_sum > target:
                        right -= 1
                    else:
                        res.append([nums[a], nums[b], nums[left], nums[right]])

                        while left < right and nums[left] == nums[left + 1]:
                            left += 1
                        while left < right and nums[right] == nums[right - 1]:
                            right -= 1
                        
                        left += 1
                        right -= 1
        return res
# 时间复杂度：
# O(n³)