哈希表（刷题）

最新推荐文章于 2024-07-25 20:26:57 发布

geriezmann

最新推荐文章于 2024-07-25 20:26:57 发布

阅读量195

点赞数

分类专栏：刷题文章标签：散列表 leetcode 算法

本文链接：https://blog.csdn.net/adhkcnbk/article/details/126566552

版权

刷题专栏收录该内容

10 篇文章 0 订阅

订阅专栏

哈希表

1、有效的字母异位词

242. 有效的字母异位词 - 力扣（LeetCode）

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

示例1：

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

class Solution:
    def isAnagram(self, s, t):
        sdict, tdict = collections.defaultdict(int), collections.defaultdict(int)
        for i in s:
            sdict[i] += 1
        for i in t:
            tdict[i] += 1
        return sdict == tdict

383. 赎金信 - 力扣（LeetCode）

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

class Solution:
    def canConstruct(self, rasomNote, magazine):
        rdict = collections.defaultdict(int)
        mdict = collections.defaultdict(int)
        for s in ransomNote:
            rdict[s] += 1
        for s in magazine:
            mdict[s] += 1
        for i in rdict.keys():
            if rdict[i] > mdict[i]:
                return False
        return True

49. 字母异位词分组 - 力扣（LeetCode）

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。

输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]

class Solution:
    def groupAnagrams(self, strs):
        ch = collections.defaultdict(list)
        for str in strs:
            count = [0] * 26
            for s in str:
                count[ord(s)-ord('a')] += 1
            ch[tuple(count)].append(str)
        return list(ch.values())

438. 找到字符串中所有字母异位词 - 力扣（LeetCode）

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

class Solution:
    def findAnagrams(self, s, p):
        result = []
        sdict = [0] * 26
        pdict = [0] * 26
        lenp, lens = len(p), len(s)
        if lens < lenp:
            return result
        for i in range(lenp):
            pdict[ord(p[i] - ord('a'))] += 1
            sdict[ord(s[i] - ord('a'))] += 1
        if pdict == sdict:
            result.append(0)
        for i in range(lens - lenp):
            sdict[ord(s[i]) - ord('a')] -= 1
            sdict[ord(s[i+lenp]) - ord('a')] += 1
            if sdict == pdict:
                result.append(i+1)
        return result

2、两个数组的交集

349. 两个数组的交集 - 力扣（LeetCode）

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是唯一的。我们可以 不考虑输出结果的顺序 。

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

class Solution:
    def intersection(self, nums1, nums2):
        result = []
        for num in nums1:
            if num in nums2 and num not in result:
                result.append(num)
        return result

350. 两个数组的交集 II - 力扣（LeetCode）

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序

class Solution:
    def intersect(self, nums1, nums2):
        nums1.sort()
        nums2.sort()
        result = []
        i, j = 0, 0
        while i < len(nums1) and j < len(nums2):
            if nums1[i] > nums2[j]:
                j += 1
            elif nums1[i] < nums2[j]:
                i += 1
            else:
                result.append(nums1[i])
                i += 1
                j += 1
        return result

3、快乐数

202. 快乐数 - 力扣（LeetCode）

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

「快乐数」 定义为：

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

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

class Solution:
    def isHappy(self, n):
        record = set()
        while True:
            n = self.sum(n)
            if n == 1:
                return True
            elif n in record:
                return False
            else:
                record.add(n)
     def sum(self, n):
        sum = 0
        while n:
            sum += (n % 10) ** 2
            n = n // 10
        return sum

4、两数之和

1. 两数之和 - 力扣（LeetCode）

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

你可以假设每种输入只会对应一个答案，但是，数组中同一元素在答案中里不能重复出现，你可以按任意顺序返回答案。

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

class Solution:
    def twoSum(self, nums, target):
        dict = {}
        for i in range(len(nums)):
            temp = target - nums[i]
            if dict.get(temp, None) is not None:
                return [i, dict[temp]]
            else:
                dict[nums[i]] = i

5、四数之和II

454. 四数相加 II - 力扣（LeetCode）

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

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2

class Solution:
    def fourSum(self, num1, num2, num3, num4):
        dict = {}
        result = 0
        for i in nums1:
            for j in nums2:
                sum = i + j
                if sum in dict:
                    dict[sum] += 1
                else:
                    dict[sum] = 1
        for m in nums3:
            for n in nums4:
                sum = - m - n
                if sum in dict:
                    result += dict[sum]
        return result

6、三数之和

15. 三数之和 - 力扣（LeetCode）

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

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

示例：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]

class Solution:
    def threeSum(self, nums):
        result = []
        for i in range(len(nums)-2):
            left, right = i + 1, len(nums) - 1
            if i > 0 and nums[i] == nums[i-1]:
                continue
            while left < right:
                if nums[i] +nums[left]+nums[right] > 0:
                    right -= 1
                elif nums[i]+nums[left]+nums[right] < 0:
                    left += 1
                else:
                    result.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 result

7、四数之和

18. 四数之和 - 力扣（LeetCode）

给你一个由 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

你可以按 任意顺序 返回答案。

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

class Solution:
    def fourSum(self, nums):
        nums.sort()
        result = []
        for i in range(len(nums)-3):
            if i > 0 and nums[i] == nums[i-1]:
                continue
            for j in range(i+1, len(nums)-2):
                if j > i+1 and nums[j] ==nums[j-1]:
                    continue
                left, right = j + 1, len(nums)-1
                while left < right:
                    if nums[i] +nums[j]+nums[left]+nums[right] >target:
                        right -= 1
                    elif nums[i]+nums[j]+nums[left]+nums[right]<target:
                        left += 1
                    else:
                        result.append([nums[i], nums[j], 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 result