刷题第六天 454.四数相加 383.赎金信 15.三数之和 18.四数之和

454. 四数相加

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

哈希映射，需要确定-i出现了多少次，所以用字典来记录，一开始想用数组，但是会忽略重复的情况。

383. 赎金信

class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        hash_r = [0] * 26
        hash_m = [0] * 26
        for i in ransomNote:
            hash_r[ord(i) - ord('a')] += 1
        for j in magazine:
            hash_m[ord(j) - ord('a')] += 1
        for i,val in enumerate(hash_r):
            if val > hash_m[i]:
                return False
        return True

涉及到字母的题目很适合哈希，因为总共字母就26个，要记住字符转asc码的ord函数

15. 三数之和

class Solution(object):
    def threeSum(self, nums):
        nums.sort()
        result = []
        for i,val in enumerate(nums):
            left = i + 1
            right = len(nums) - 1
            if i > 0 and nums[i-1] == val:
                i += 1 
                continue
            while(left < right):
                if (val + nums[left] + nums[right]) > 0:
                    right -= 1
                elif (val + nums[left] + nums[right]) < 0:
                    left += 1
                else:
                    while left < right and nums[left] == nums[left + 1]:
                        left += 1
                    while left < right and nums[right] == nums[right - 1]:
                        right -= 1
                    result.append([val,nums[left],nums[right]])
                    left += 1
                    right -= 1
        return result

题目的关键

1. 双指针的思路去解，非常巧妙

2. 三个数字如何去重，去重的位置： 对于第一个数字来说，因为是最外层的遍历，所以去重放在第一层循环里，比较的是其前一位

3. left和right的去重应该用while，因为如果有多个元素重复，只用if的话 还是会记录进去，比较的是其后一位

18.四数相加

class Solution(object):
    def fourSum(self, nums, target):
        result = []
        nums.sort()
        for i in range(len(nums)):
            if i > 0 and nums[i] == nums[i - 1]:
                i += 1
                continue
            for j in range(i + 1, len(nums)):
                if j > i + 1 and nums[j] == nums[j - 1]:
                    continue
                left = j + 1
                right = len(nums) - 1
                while left < right:
                    val = nums[i] + nums[j] + nums[left] + nums[right]
                    if val > target:
                        right -= 1
                    if val < target:
                        left += 1
                    if val == target:
                        while left < right and nums[right] == nums[right-1]:
                            right -= 1
                        while left < right and nums[left] == nums[left + 1]:
                            left += 1        
                        result.append([nums[i], nums[j], nums[left], nums[right]])
                        left += 1
                        right -= 1
        return result            

和三数之和类似，无非多了一层循环，利用双指针就可以减少一个次数的时间复杂度

第一层循环遍历第一个数，如果和前一个数重复了就前进一位

第二层循环遍历第二个数，第二个数的起始位置是第一个数+1， 从+2的位置开始判断，如果和前一个数重复就前进一位

然后进入双指针的循环，利用while构建 left<right进入循环，判断值是否等于target

等于的话对left和right进行去重之后记录下结果，同时left right一起移动

前两个数去重是和其前一个数比，而left right去重是和后一个数比，因为前两个数的后面的数会和内循环冲突，所以不用比较