【训练营day7｜哈希表｜ 454. 四数相加II、383. 赎金信、15.三数之和、18.四数之和】

454. 四数相加II

要点

1. 题目要求元素可以重复，即不需要去重。
2. 用dict保存两个数组遍历的求和结果及和数出现的次数
3. 遍历剩余两个数组，看符合求和为0的数在dict的key中是否出现过及相应次数
4. 时间复杂度O(N²)，空间复杂度O(N²)

代码：

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

383. 赎金信

要点

1. 题目简单，由于只会出现小写字母，所以只需要定义大小为26的数组记录每个字符出现的次数
2. 时间复杂度O(N)；空间复杂度O(S)，本题S为26.

代码

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

15.三数之和

要点

1. 区别于454计算四数之和，最后元组不可以重复，即需要去重，采用哈希法不好去重，所以采用双指针法，但使用双指针法的前提是排序，所以不适用于要求返回下标的题目
2. 排序后对a即第一个元素进行遍历：
   1）如a大于0，直接break
   2）去重：如a等于前一下标的值，跳过该元素
3. 引入双指针，left = i + 1，right = n - 1
4. 当left小于right时循环判断三个下标所在数相加和0的关系，如果大于0，则right左移，小于0则left右移，等于0，则记录该元组，并且对left和right进行去重，循环条件为如果left和right没有相遇且下一个left或者左移的right的值与原先的left或right相同，left继续右移，right继续左移。
5. 时间复杂度O(N²)

代码

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res = []
        n = len(nums)
        for i in range(n):
            if nums[i] > 0:
                break
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            left = i + 1
            right  = n - 1
            while right > left:
                if nums[i] + nums[left] + nums[right] > 0:
                    right -= 1
                elif nums[i] + nums[left] + nums[right] < 0:
                    left += 1
                else:
                    res.append([nums[i], nums[left], nums[right]])
                    while left != right and nums[left+1] == nums[left]:
                        left += 1
                    while left != right and  nums[right - 1] == nums[right]:
                        right -= 1
                    left += 1
                    right -= 1
        return res

18.四数之和

要点

1. 相比于三数之和，外面再加一层循环，即两层for循环确定一个值，再利用双指针确定另外半边值
2. 由于target是任意值，即可以为负数，所以剪枝的逻辑变了，需要考虑target是不是负数的不同情况。
3. 易错点在于对第二个层循环（j）去重时，考虑的是j>i+1后面的去重，而不能把j=i+1时和i相等的元素去重了
4. 时间复杂度O(N³)

代码

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        res = []
        n = len(nums)
        nums.sort()
        for i in range(n):
            if (nums[i] > target) and (nums[i] >= 0 or target >= 0):
                break
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            for j in range(i + 1, n):
                if j > i + 1 and nums[j] == nums[j - 1]:
                    continue
                l = j + 1
                r = n - 1
                while l < r:
                    if nums[i] + nums[j] + nums[l] + nums[r] > target:
                        r -= 1
                    elif nums[i] + nums[j] + nums[l] + nums[r] < target:
                        l += 1
                    else:
                        res.append([nums[i], nums[j], nums[l], nums[r]])
                        while l != r and nums[l] == nums[l + 1]:
                            l += 1
                        while l != r and nums[r] == nums[r - 1]:
                            r -= 1
                        l += 1
                        r -=

1
return res