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

454.四数相加II

力扣454

代码随想录题解

这道题由于是直接算有多少种相加的可能，所以不涉及去重的操作，用字典的键值对统计即可。另外为了减少运算复杂度，可以1，2数组求和，再减去3,4数组的求和为0，找到这种情况并记录次数，就可以解题，类似于力扣1题两数之和的思路。代码如下：

class Solution(object):
    def fourSumCount(self, nums1, nums2, nums3, nums4):
        summap = {}
        for i in nums1:
            for j in nums2:
                if i + j in summap:
                    summap[i + j] += 1
                else:
                    summap[i + j] = 1
        result = 0
        for i in nums3:
            for j in nums4:
                if 0 - i - j in summap:
                    result += summap[0 - i - j]
        return result 

383. 赎金信

力扣383

先把被查找的按照字母出现的次数写成字典，然后在查找的时候能查到且该字母数量大于0的减1.直到搜索完成。

class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        mapM = {}
        for alpha in magazine:
            if alpha not in mapM:
                mapM[alpha] = 1
            else:
                mapM[alpha] += 1
        for i in ransomNote:
            if i in mapM and mapM[i] > 0:
                mapM[i] -= 1
            else:
                return False
        return True

15. 三数之和

这道题由于要返回不重复的三元组，使用字典的话去重比较麻烦。双指针法是一种直观的解法，并且比较容易去重。因为在一开始我们对数组进行了排序，我们在遍历的时候，i 可以跳过一些已经大于0的，因为不管怎么加，在i右边的都是大于0的数字。并且和前一个遍历的数字相同的也可以跳过，这样就省去了很多时间和空间：

class Solution(object):
    def threeSum(self, nums):
        result = []
        nums.sort()
        for i in range(len(nums)):
            if nums[i] > 0:#已经大于0就可以不用再做了
                return result
            
            if i > 0 and nums[i] == nums[i - 1]:#i和前一个相等也可以不用再做了
                continue

            left = i + 1
            right = len(nums) - 1
            while left < right:
                sum = nums[i] + nums[left] + nums[right]
                if sum < 0:
                    left += 1
                elif sum > 0:
                    right -= 1
                else:
                    result.append([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

18. 四数之和

力扣18四数之和

思路与三数求和一样，只不过外层再加一个for循环，其中有一些数据处理的细节要注意：

class Solution(object):
    def fourSum(self, nums, target):
        result = []
        l = len(nums)
        nums.sort()
        for i in range(l):##外层循环i
            if nums[i] > target and nums[i] > 0 and target > 0:#如果第一个数大于target就没必要算了，但是在这里，要保证num[i]和target大于0。如果都是负数，还是要继续算的
                break
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            for j in range(i + 1, l):##内层循环j
                if nums[j] > target and nums[j] > 0 and target > 0: 
                    break
                if j > i + 1 and nums[j] == nums[j - 1]:
                    continue
                left = j + 1#双指针移动的思路是一样的
                right = l - 1
                
                while left < right:
                    sums = nums[i] + nums[j] + nums[left] + nums[right]
                    if sums < target:
                        left += 1
                    elif sums > target:
                        right -= 1
                    else:
                        result.append([nums[i], nums[j], 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