454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和

454.四数相加II

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

比四数之和容易的是不用去重 （四数之和四数之和四数之和并不合适使用哈希法）

1. 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中
2. 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        hash_table = dict()
        count = 0
        for i in nums1:
            for j in nums2:
                if i + j in hash_table:   
                    hash_table[i + j] += 1
                else:
                    hash_table[i + j] = 1
        for i in nums3:
            for j in nums4:
                if 0 - (i + j) in hash_table:
                    count += hash_table[0 - (i + j)]
        
        return count

383. 赎金信

在本题的情况下，使用map的空间消耗要比数组大一些的，因为map要维护红黑树或者哈希表，而且还要做哈希函数，是费时的！数据量大的话就能体现出来差别了。 所以数组更加简单直接有效

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        hash_table = [0] * 26
        for i in magazine:
            hash_table[ord(i) - ord('a')] += 1
        
        for i in ransomNote:
            hash_table[ord(i) - ord('a')] -= 1
            if hash_table[ord(i) - ord('a')] < 0:
                return False
        return True

15. 三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

难度在去重，如果用哈希法， 很难去重， 应该用双指针法

首先将数组排序，有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。

时间复杂度：O(n^2)

注意如何给三个数去重， 边界条件

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        n = len(nums)
        if n < 3:
            return []
        result = []
        for i in range(n - 2):
            left = i + 1
            right  = n - 1
            if nums[i] > 0:
                return result
            # 给第一个数去重：
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            while left < right:
                if nums[i] + nums[left] + nums[right] < 0:
                    left += 1
                elif nums[i] + nums[left] + nums[right] > 0:
                    right -= 1
                else:
                    result.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 += 1
                    right -= 1
        return result

18. 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

注意如何剪枝 (数组内可能有正负， 不一定越加越大), 在三数之和的基础上再套一层for循环，时间复杂度是O(n^3)

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums.sort()
        n = len(nums)
        if n < 4:
            return []
        result = []
        for k in range(n - 3):
            if nums[k] > target and (target > 0 or nums[k] > 0):
                break
            # 对nums[k]去重
            if k > 0 and nums[k] == nums[k - 1]:
                continue
            for i in range(k + 1, n - 2):
                if nums[k] + nums[i] > target and (target > 0 or nums[k] + nums[i] > 0):
                    break
                if i > k + 1 and nums[i] == nums[i - 1]:
                    continue
                left = i + 1
                right = n - 1
                while left < right:
                    total = nums[k] + nums[i] + nums[left] + nums[right]
                    if total > target:
                        right -= 1
                    elif total < target:
                        left += 1
                    else:
                        result.append([nums[k], nums[i], 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 result