leetcode极速复习版-第三章哈希表

哈希表

哈希表理论基础

242.有效的字母异位词

349. 两个数组的交集

202. 快乐数

1. 两数之和

454.四数相加II

383. 赎金信

15. 三数之和

18. 四数之和

哈希表

哈希表理论基础

那么哈希表能解决什么问题呢，一般哈希表都是用来快速判断一个元素是否出现集合里。

例如要查询一个名字是否在这所学校里。

要枚举的话时间复杂度是O(n)，但如果使用哈希表的话，只需要O(1)就可以做到。

242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1: 输入: s = "anagram", t = "nagaram" 输出: true

示例 2: 输入: s = "rat", t = "car" 输出: false

说明: 你可以假设字符串只包含小写字母。

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        record = [0] * 26
        for i in s:
            #并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            record[ord(i) - ord("a")] += 1
        for i in t:
            record[ord(i) - ord("a")] -= 1
        for i in range(26):
            if record[i] != 0:
                #record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return False
        return True

ord()函数是Python中的一个库函数，用于获取ASCII给定字符的值。

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        from collections import defaultdict
        
        s_dict = defaultdict(int)
        t_dict = defaultdict(int)
        for x in s:
            s_dict[x] += 1
        
        for x in t:
            t_dict[x] += 1
        return s_dict == t_dict

class Solution(object):
    def isAnagram(self, s: str, t: str) -> bool:
        from collections import Counter
        a_count = Counter(s)
        b_count = Counter(t)
        return a_count == b_count

349. 两个数组的交集

给定两个数组，编写一个函数来计算它们的交集。

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        # 法一
        return list(set(nums1)&set(nums2))
        # 法二
        hash_dict = {}
        result = []
        for i in range(len(nums1)):
            hash_dict[nums1[i]] = 1
        for i in range(len(nums2)):
            # if hash_dict[nums2[i]] == 1: # 直接这么写会报错，需要先判断nums2[i]存在于字典中
            if nums2[i] in hash_dict.keys() and hash_dict[nums2[i]] == 1:
                result.append(nums2[i])
 
                # 如何处理重复元素？
                # 只需要在append第一次出现的元素之后把原字典内对应value置零即可
                hash_dict[nums2[i]] = 0 # ❗这一行看答案了
        return result

202. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为 1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

输入：19

输出：true

解释：

1^2 + 9^2 = 82

8^2 + 2^2 = 68

6^2 + 8^2 = 100

1^2 + 0^2 + 0^2 = 1

class Solution:
     def isHappy(self, n: int) -> bool:
        def getSum(n):
            summary = 0
            while n: # 从个位开始依次取，平方求和
                summary += (n % 10) * (n % 10)
                # n /= 10 # ❗ 错误
                # 在Python中/表示浮点整除法，返回浮点结果，也就是结果为浮点数;
                # 而//在Python中表示整数除法，返回小于结果的一个最大的整数，意思就是除法结果向下取整。
                # 举例
                # print("6 // 4 = " + str(6 // 4)) 
                # print("6 / 4 =" + str(6 / 4))
                # 结果：　
                # 6 // 4 = 1 
                # 6 / 4 =1.5
                n = n // 10
            return summary
 
        hash_dict = {}
        summary = n
        while 1:
            summary = getSum(summary)
            if summary == 1:
                return True
            if summary in hash_dict.keys():
                return False
            else:
                hash_dict[summary] = 1

class Solution:
    def isHappy(self, n: int) -> bool:
        def calculate_happy(num):
            sum_ = 0
            
            # 从个位开始依次取，平方求和
            while num:
                sum_ += (num % 10) ** 2
                num = num // 10
            return sum_
 
        # 记录中间结果
        record = set()
 
        while True:
            n = calculate_happy(n)
            if n == 1:
                return True
            
            # 如果中间结果重复出现，说明陷入死循环了，该数不是快乐数
            if n in record:
                return False
            else:
                record.add(n) #注意set()的用法

1. 两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。

在遍历数组的时候，只需要向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hash_dict = {}
        for i in range(len(nums)):
            if target - nums[i] in hash_dict.keys():
                return hash_dict[target-nums[i]], i
            else:
                hash_dict[nums[i]] = i
        return 0

454.四数相加II

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

例如:

输入:

A = [ 1, 2]

B = [-2,-1]

C = [-1, 2]

D = [ 0, 2]

输出:

解释:

两个元组如下:

(0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0

(1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

首先定义一个unordered_map，key放a和b两数之和，value 放a和b两数之和出现的次数。
遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中。
定义int变量count，用来统计 a+b+c+d = 0 出现的次数。
在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。
最后返回统计值 count 就可以了

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        hash_dict = {}
        count = 0
        for i in range(len(nums1)):
            for j in range(len(nums2)):
                if nums1[i]+nums2[j] in hash_dict.keys():
                    hash_dict[nums1[i]+nums2[j]] += 1
                else:
                    hash_dict[nums1[i]+nums2[j]] = 1
 
        for i in range(len(nums3)):
            for j in range(len(nums4)):
                if -nums3[i]-nums4[j] in hash_dict.keys():
                    count += hash_dict[-nums3[i]-nums4[j]]
        
        return count

383. 赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct("a", "b") -> false

canConstruct("aa", "ab") -> false

canConstruct("aa", "aab") -> true

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        hash_abc = [0] * 26
        for i in range(len(magazine)):
            hash_abc[ord(magazine[i]) - ord('a')] += 1
        for i in range(len(ransomNote)):
            if hash_abc[ord(ransomNote[i]) - ord('a')] == 0:
                return False
            else:
                hash_abc[ord(ransomNote[i]) - ord('a')] -= 1
        return True

看代码随想录文章后新增知识：

之前在使用字典的时候, 用的比较随意, 只是简单的使用dict.

然而这样在使用不存在的key的时候发生KeyError这样的一个报错, 这时候就该defaultdict登场了.

from collections import defaultdict

d1 = defaultdict(int)

使用defaultdict任何未定义的key都会默认返回一个根据method_factory参数不同的默认值, 而相同情况下dict()会返回KeyError.

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
 
        from collections import defaultdict
 
        hashmap = defaultdict(int)
 
        for x in magazine:
            hashmap[x] += 1
 
        for x in ransomNote:
            value = hashmap.get(x) #读取dict中value #说的就是这里
            if value is None or value == 0:
                return False
            else:
                hashmap[x] -= 1
 
        return True

另外还有counter：

有了这个函数就不用手动的使用 for 循环来手动统计词频啦！

Counter() 是 collections 库中的一个函数，可以用来统计一个 python 列表、字符串、元组等可迭代对象中每个元素出现的次数，并返回一个字典。

nums = [1, 1, 1, 6, 6, 6, 7, 8]

count = Counter(nums)

for k, v in count.items():

print(k, v)

使用 Counter 统计完词频后可以使用 most_common 方法来查找出现频率最高的 k 个数字及其出现次数。

ansdict = count.most_common(2) # 返回出现次数最多的两个数及其出现的次数如[(1, 3), (6, 3)]

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        c1 = collections.Counter(ransomNote)
        c2 = collections.Counter(magazine)
        x = c1 - c2
        #x只保留值大于0的符号，当c1里面的符号个数小于c2时，不会被保留
        #所以x只保留下了magazine不能表达的
        if(len(x)==0):
            return True
        else:
            return False

15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。

依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i]，b = nums[left]，c = nums[right]。

接下来如何移动left 和right呢，如果nums[i] + nums[left] + nums[right] > 0 就说明此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。如果 nums[i] + nums[left] + nums[right] < 0 说明此时三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与right相遇为止。

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums = sorted(nums)
        result = []
        i = 0
        left = 0
        right = len(nums) - 1
        for i in range(len(nums)): #这种或许用for不合适 因为可能会在循环中改i的值 更保险是用while：while i != len(nums) - 1:
 
            if nums[i] > 0: 
                break # 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了 # 这两行是抄答案的
                
            if i > 0 and nums[i] == nums[i - 1]:
                continue # 注意这里不用i+=1了因为for本身自会+1
                #另外，记得这个nums是从小到大排列的
            else:
                left = i + 1
                right = len(nums) - 1
                while left < right:
                    if nums[i] + nums[left] + nums[right] == 0:
                        result.append([nums[i], nums[left], nums[right]])
                        #出大问题。到此结束的话没有让left和right递增/减
                        left += 1
                        right -= 1
                        # while nums[left] == nums[left - 1]: 
                        # #出大问题。没有规定left和right的大小关系
                        while left < right and nums[left] == nums[left - 1]: 
                            left += 1 
                        while left < right and nums[right] == nums[right + 1]:
                            right -= 1
                    elif nums[i] + nums[left] + nums[right] < 0:
                        left += 1
                    else:
                        right -= 1    
                        
                    
        return result

18. 四数之和

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例：给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums = sorted(nums)
        result = []
        left = 0
        right = len(nums)- 1
#❗第一步先开始第一层循环，剪枝+查重后开始正式处理
        for k in range(len(nums)):
            if target > 0 and nums[k] > target:
                # return []
                break
            if k > 0 and nums[k] == nums[k - 1]:
                continue
#❗第二步进入第二层循环，也是剪枝+查重后再正式处理。第二层循环中，left和right分别初始化为i+1和len(nums)-1
            for i in range(k + 1, len(nums)):
                # if target > 0 and nums[i] + nums[k] > target:
                #     return []
                # # 不要这样剪枝。否则如果遇到[-1, 0, 1, 2]然后target=2的话，遍历到k=2 i=3的时候，
                # # 1+2>2直接返回[]了，哪怕此时result是有值的。
                # # 所以应写return result
                # # 更好的写法是这里break然后最后统一return
                # if target > 0 and nums[i] + nums[k] > target:
                #     return result
                # # 这里写return result依旧是不对的。因为这个二级剪枝减去的只是剩余的i可以不参与循环，
                # # 但剩余的k依旧要继续参与循环。所以不能直接return。
                # # 只是说可以结束该for循环回到第一级for循环。
                if target > 0 and nums[i] + nums[k] > target:
                    break
                if i > k + 1 and nums[i] == nums[i - 1]:
                    continue
#❗剪枝+查重后第三步是开始在left
                left = i + 1
                right = len(nums) - 1
                while(left < right):
                    if nums[k]+nums[i]+nums[left]+nums[right] < target:
                        left += 1
                    elif nums[k]+nums[i]+nums[left]+nums[right] > target:
                        right -= 1
                    else:
                        result.append([nums[k], nums[i], nums[left], nums[right]])
#❗第四步，找到符合要求的组合后，继续往下推进，left和right分别自增自减，然后查重
                        left += 1
                        right -= 1
                        while left < right and nums[left] == nums[left - 1]:
                            left += 1
                        while left < right and nums[right] == nums[right + 1]:
                            right -= 1
        return result