「代码随想录」Python刷题笔记Day7-哈希表

454.四数相加II

链接
leetcode-454

题目
给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：
0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        # dic1:key为num1+num2的值，values为出现的次数
        dic1 = {}
        # 存放次数
        res = 0

        for num1 in nums1:
            for num2 in nums2:
                sums = num1 + num2
                if sums in dic1:
                    dic1[sums] += 1
                else:
                    dic1[sums] = 1

        for num3 in nums3:
            for num4 in nums4:
                if 0-(num3+num4) in dic1:
                    res += dic1[0-(num3+num4)]
        return res

时间复杂度为O(2n^2)
空间复杂度最坏情况为nums1和nums2相加产生的数字个数为 n^2

383. 赎金信

链接
leetcode-383

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

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        dic = {}
        for i in ransomNote:
            if i in dic:
                dic[i] += 1
            else:
                dic[i] = 1
        
        dic_1 = {}
        for j in magazine:
            if j in dic_1:
                dic_1[j] += 1
            else:
                dic_1[j] = 1
        
        for k, v in dic.items():
            if k not in dic_1.keys():
                return False
            elif k in dic_1.keys() and dic[k]>dic_1[k]:
                return False
            else:
                pass
        return True

再简化一点

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        dic = {}
        for i in magazine:
            dic[i] = dic.get(i, 0) + 1
        
        for j in ransomNote:
            if j not in dic or dic[j] == 0:
                return False
            dic[j] -= 1

        return True

时间复杂度O(n), 空间复杂度O(1)
或者采用昨天的Counter可以这么写：

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
		if len(ransomNote) > len(magazine):
		    return False
		return not collections.Counter(ransomNote) - collections.Counter(magazine)
		# 如果相减全为0，则返回true；否则返回false

15. 三数之和

巧妙的双指针法。
链接
leetcode-15

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

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res = []

        for i in range(len(nums)):
            if nums[i] > 0:
                return res
            
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            
            left = i + 1
            right = len(nums) - 1
            
            while right > left:
                sum_ = nums[i] + nums[left] + nums[right]
                
                if sum_ < 0:
                    left += 1
                elif sum_ > 0:
                    right -= 1
                else:
                    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
                    
        return res

18. 四数之和

链接
leetcode-18

题目
给你一个由 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
你可以按 任意顺序 返回答案 。

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