代码随想录算法训练营第七天 | Python | LeetCode454.四数相加 II、LeetCode383.赎金信、LeetCode15.三数之和、LeetCode18.四数之和

LeetCode 454. 四数相加 II

题目：https://leetcode.cn/problems/4sum-ii/description/
解析：https://programmercarl.com/0454.%E5%9B%9B%E6%95%B0%E7%9B%B8%E5%8A%A0II.html

和之前的两两数之和很相似，我们先找出nums1/nums2的所有和，再找出nums3/nums4的所有和。这就和两数之和题目一致了。

但需要注意一个地方：res += dic[-(p+q)]。不是+1

class Solution(object):
    def fourSumCount(self, nums1, nums2, nums3, nums4):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :type nums3: List[int]
        :type nums4: List[int]
        :rtype: int
        """
        dic = collections.defaultdict(int)
        res = 0
        for i in nums1:
            for j in nums2:
                dic[i+j] += 1
        for p in nums3:
            for q in nums4:
                if -(p+q) in dic:
                    res += dic[-(p+q)]
        return res

LeetCode 383. 赎金信

题目：https://leetcode.cn/problems/ransom-note/description/
解析：https://programmercarl.com/0383.%E8%B5%8E%E9%87%91%E4%BF%A1.html

LeetCode 15. 三数之和

题目：https://leetcode.cn/problems/3sum/description/
解析：https://programmercarl.com/0015.%E4%B8%89%E6%95%B0%E4%B9%8B%E5%92%8C.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE

用双指针法的思路比较简单，但去重困难。如果不去重，最后用set会超出时间限制。

双指针：首先对nums排序，以下标 i 遍历nums，作为第一个数。第二个数和第三个数下标分别为left和right，用双指针方法确定和为0的三个数。

去重思路：

1. i 如何去重？比较nums[i] == nums[i-1]还是nums[i] == nums[i+1]？
   nums[i+1]一般是nums[left]，也就是说比较 nums[i] == nums[i+1]相当于比较nums[i] == nums[left]，也就是比较三数之和中两个数是否相同，但三数是不需要去重的，所以不能用nums[i] == nums[i+1]。
   另外，i 如果选择相同数字的最后一个，会忽略三数中第一二个数相等的形式。
2. left 和 right 如何去重？拿left举例子，如果此时已经计算完三数之和，但left 右侧还有几个相同的数，那我们吧 left 挪到最接近的不同数上。

class Solution(object):
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        nums = sorted(nums)
        res = []
        i = 0
        for i in range(len(nums)-2):
        	if nums[i] > 0: ##剪枝
        		return res
            if i != 0 and nums[i] == nums[i-1]:
                continue
            left = i + 1
            right = len(nums) - 1
            while left < right:
                sum_n = nums[i] + nums[left] + nums[right]
                if sum_n > 0:
                    while left < right and nums[right] == nums[right-1]:
                        right -= 1
                    right -= 1
                elif sum_n < 0:
                    while left < right and nums[left] == nums[left+1]:
                        left += 1
                    left += 1
                else:
                    res.append([nums[i], nums[left], nums[right]])
                    while left < right and nums[right] == nums[right-1]:
                        right -= 1
                    right -= 1
                    while left < right and nums[left] == nums[left+1]:
                        left += 1
                    left += 1
        return res
            

不愧是梦破碎的地方，碎了好几天……

LeetCode 18. 四数之和

题目：https://leetcode.cn/problems/4sum/description/
解析：https://programmercarl.com/0018.%E5%9B%9B%E6%95%B0%E4%B9%8B%E5%92%8C.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE

在三数之和外面套一层for循环就可以了

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums = sorted(nums)
        res = []
        for j in range(len(nums)-3):
            if (nums[0] > target > 0 and nums[0] > 0): #剪枝
                break
            if j != 0 and nums[j] == nums[j-1]:
                continue
            for i in range(j+1, len(nums)-2):
                if (nums[i] + nums[j] > target and nums[i] + nums[j] > 0): #2级剪枝
                    break
                if i != j+1 and nums[i] == nums[i-1]:
                    continue
                left = i + 1
                right = len(nums) - 1
                while left < right:
                    sum_n = nums[j] + nums[i] + nums[left] + nums[right]
                    if sum_n > target:
                        while left < right and nums[right] == nums[right-1]:
                            right -= 1
                        right -= 1
                    elif sum_n < target:
                        while left < right and nums[left] == nums[left+1]:
                            left += 1
                        left += 1
                    else:
                        res.append([nums[j], nums[i], nums[left], nums[right]])
                        while left < right and nums[right] == nums[right-1]:
                            right -= 1
                        right -= 1
                        while left < right and nums[left] == nums[left+1]:
                            left += 1
                        left += 1
        return res

这里需要注意剪枝的问题，剪枝不可以直接写成if nums[i] > target: return res，这里要考虑nums[i] 的符号问题：nums[1] > nums[0] > target且nums[1] > nums[0] > 0，可以推出nums[1] + nums[0] > target。同理：nums[len-2] < nums[len-1] < target且nums[len-2] < nums[len-1] < 0，可以推出nums[len-2] + nums[len-1] < target.

总结

1. res思想
2. 处理两个字符串中的字母，可以用Counter或对26个字母计数的数组。