代码随想录训练营打卡第七天|454.四数相加II，383. 赎金信，15. 三数之和，18. 四数之和

Losmier

已于 2023-08-16 14:36:08 修改

阅读量101

点赞数

分类专栏：代码随想录一刷文章标签： python 哈希表

于 2023-08-15 23:36:46 首次发布

本文链接：https://blog.csdn.net/m0_45921888/article/details/132300191

版权

代码随想录一刷专栏收录该内容

11 篇文章 0 订阅

订阅专栏

哈希表|454.四数相加II，383. 赎金信，15. 三数之和，18. 四数之和

文档链接：代码随想录
做题感悟：

四数相加：将四个for循环，变成两个for循环，注意同时保存加和的数量，在进行比配。
赎金信：ran所使用的字母少于mag的。先用数组统计每个字母出现的次数，在一一比较。
三数之和：比较复杂，首先遍历num[i]，同时遍历移动num[i]后面的左右指针，直到找到满足条件的元素。但是要考虑去重的问题，相同元素的情况下，得到的解集也相同，不需要放进去。
四数之和：略有不同，target可以是负数，因此剪枝的时候要保证target为正数。在此基础上多加一层k遍历，剪枝和去重的约束也略有变化。直接看代码。

时间复杂度与数据量大小的对应关系

在这里插入图片描述
其中， $log(n^3)$ 对应的数据量大小为200左右

题目一：454.四数相加——46min

题目链接：题目
文档链接：文档
视频讲解：视频

在这里插入图片描述

先分别统计两个数组的和，在对两个数组的和进行匹配，计算出匹配的个数
使用key保存加和的组合，value保留加和出现的次数

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        #先两两统计数组的和，其中key是和，value是数量
        #再将统计好的字典进行遍历，计算满足匹配的数量，予以计数
        dict1 = {}
        dict2 = {}
        count = 0
        for i in nums1:
            for j in nums2:
                dict1[i+j] = dict1.get(i+j,0) + 1
        for i in nums3:
            for j in nums4:
                dict2[i+j] = dict2.get(i+j,0) + 1
        for i in dict1.keys():#也可以放到上面遍历查询
            key=0-i
            if key in dict2:#如果2能找到的匹配的值
                count = count+dict1[i]*dict2[0 - i]
        return count

题目二：383.赎金信——23min

题目链接：题目
文档链接：文档
视频讲解：无

在这里插入图片描述

由于是查找字母，并比较字母是否足够使用，使用数组
数组下标是0-25表示26个字母，数组内元素指字母出现的个数
如果是ran所需字母小于mag的数量，就满足要求，能够写出赎金信。

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        ran = [0] * 26
        mag = [0] * 26
        for i in ransomNote: # 记录字符串中各个字母的数量
            ran[ord(i)-ord('a')] += 1 # 一串整数用str()转换成字符串，但是字符不能用int转换，要用ord转换成ASCLL码
        for i in magazine:
            mag[ord(i)-ord('a')] += 1
        print(ran,mag)
        return all(ran[i]<=mag[i] for i in range(26))

题目三：三数之和——2.5h

题目链接：题目
文档链接：文档
视频讲解：视频

在这里插入图片描述

首先初始化二维数组、将nums排序
先遍历nums，nums去重
左右指针移动，左右指针去重
满足条件的情况下，将答案保存至二维数组中。
注意排除一些特殊情况：
有关nums遍历的去重，由于i和left是紧挨的，因此nums[i]应该和nums[i-1]进行比较，如果和nums[i+1]比较，相当于和nums[left]比较，会导致nums[i]和nums[left]不能相等的局面
left和right去重，其实只要判断前后元素是否一致即可，因为元素一致，最后得到的解集是一样的，但是left需要考虑不影响nums[i]的遍历，nums[i]和nums[left]可以相等，因此去重的时候要注意

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        result=[] # 定义一个二维数组，用于存放三元组
        nums.sort() # 将对应的列表排序
        print(nums)
        # 先遍历列表
        # 移动快慢指针
        left = 0
        right = len(nums) - 1
        for i in range(len(nums)):
            if nums[i] > 0:return result # 如果大于0，直接终止遍历
            if i > 0 and nums[i] == nums[i-1]:continue #去重，i-1对应的子集包含i对应的子集，因此可以直接跳过i

            left = i + 1 #每个循环都重新初始化双指针
            right = len(nums) - 1

            while right > left: # 移动双指针指针    

                # print(nums[i],nums[left],nums[right])           
                if nums[i] + nums[left] + nums[right] > 0:
                    right -= 1

                elif nums[i] + nums[left] + nums[right] < 0:
                    left += 1

                else: # add()是集合添加元素，append是列表推元素
                    result.append([nums[i],nums[left],nums[right]])
            
                     # 注意区分i、right、left的去重，i和前一个数比，是为了避免受到left的影响，left和后一个比较，是为了避免影响i
                     # 当前值和前后值一样的情况下，三个值对应的元组子集也是一样的
                    while right > left  and right < len(nums)-1 and nums[right] == nums[right + 1]:
                        right -= 1
                    while right > left and nums[left] == nums[left + 1]:
                        left += 1
                        
                    right -= 1
                    left += 1
        return result

题目四：四数之和——1.5h

题目链接：题目
文档链接：文档
视频讲解：视频

在这里插入图片描述

先遍历k
再遍历i
再移动左右节点
每一次遍历都应该去重
注意去重的方向k、i都是和i-1、k-1去重（和上一个数比较），left和right则和下一个数比较

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        # 首先先遍历k,i，在遍历和移动left和right
        # 先剪枝，有些一定不满足的情况可以直接break，避免不必要的遍历
        # 去重：由于相同元素下的子集是

        # 初始化和排序
        result=[]
        nums.sort()
        print(nums)
        # 先遍历k
        for k in range(len(nums)):
            if nums[k] > target and nums[k] > 0 and target > 0: break # 剪枝
            if k > 0 and nums[k] == nums[k - 1]: continue # 去重
            # 遍历i
            for i in range(k+1,len(nums)):
                if nums[i] + nums[k] > target and nums[k] + nums[i] > 0 and target > 0: break
                if i > k+1 and nums[i] == nums[i-1]: continue
                left = i + 1
                right = len(nums) - 1
                # 移动左右指针
                while left < right:
                    if nums[left] + nums[right] + nums[i] + nums[k] < target: left += 1
                    elif nums[left] + nums[right] + nums[i] + nums[k] > target: right -= 1
                    else:
                        result.append([nums[k],nums[i],nums[left],nums[right]])
                        print([nums[k],nums[i],nums[left],nums[right]])
                        # 左右节点去重
                        while right > left and nums[right] == nums[right - 1]: right -= 1
                        while right > left and nums[left] == nums[left + 1]: left += 1
                        # 当前结果保存，继续移动左右节点
                        right -= 1
                        left += 1
        return result