代码随想录算法训练营第六天（py）| 454.四数相加II、383. 赎金信、15. 三数之和、18. 四数之和

454. 四数相加 II（normal）

力扣链接
给你四个整数数组 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. 建立一个字典，key为两数和，val为出现的次数
2. 先对nums1和nums2中逐元素求和，求和的结果和次数放入dict中
3. 定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
4. 对nums3和nums4中逐元素求和，在dict中寻找是否有等于0-c-d的key，有的话统计val

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        seen = dict() # key=和 val=出现的次数
        for i in nums1:
            for j in nums2:
                if i+j in seen:
                    seen[i+j] += 1
                else:
                    seen[i+j] = 1
        count = 0
        for i in nums3:
            for j in nums4:
                if 0-i-j in seen:
                    count += seen[0-i-j]  
        return count

383.赎金信（easy）

力扣链接
给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。
如果可以，返回 true ；否则返回 false 。
magazine 中的每个字符只能在 ransomNote 中使用一次。

思路 哈希表

1. 建立一个字典，存放magazine中的信息，key为字符，val为出现的次数
2. 对tansomNote遍历，查找每个字符是否在dict中存在，如果不存在返回false，如果存在令val-1
3. 检查dict，看是否出现负数

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        seen = dict()
        for char in magazine:
            if char in seen:
                seen[char]+=1
            else:
                seen[char]=1
        
        for char in ransomNote:
            if char in seen:
                if seen[char]<=0:
                    return False
                else:
                    seen[char]-=1
            else:
                return False
        return True

另外，由于字母只有26位，其实可以用数组做哈希解法，而不是用字典，因为数组所耗费的空间要小得多。

15. 三数之和（normal）

力扣链接
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

思路

用三个指针i,left,right，其中left在i后一位，right在数组末尾，每个循环中left和right往中间夹

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

但这样会有一个问题，就是没有进行去重。题目要求不能包含重复的三元组。去重的思路为：

1. 对于i，当i与前一项重复时，跳过这次循环
2. 对于left，当其与右边一项重复时，往右走一步
3. 对于right，当其与左边一项重复时，往左走一步

增加去重的函数为：

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

18. 四数之和（normal）

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

思路

其实就是上一题多加一个for循环

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