【Leetcode】刷题之路2（python）——哈希映射_leetcode 设计哈希映射 python-CSDN博客

本文链接：https://blog.csdn.net/qq_42368281/article/details/121390707

哈希映射类题目（简单题小试牛刀啦）

242.有效的字母异位词
349.两个数组的交集
1002.查找常用字符
202.快乐数
383.赎金信

242. 有效的字母异位词

用python的Counter类太绝了！！！
一行代码解决问题，这道题实际上就是比较两个字符串的每个字母数是不是一样。

在刷题之路1的最后我列出了collections模块的几个字典的子类

Counter：字典的子类，提供了哈希对象的计数功能

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        return Counter(s)==Counter(t)

349. 两个数组的交集

思路：
1.先把nums1和nums2转为集合
2.两集合求交集
3.再把交集转化为list

class Solution(object):
    def intersection(self, nums1, nums2):
        return list(set(nums1) & set(nums2))

1002. 查找常用字符

给你一个字符串数组 words ，请你找出所有在 words 的每个字符串中都出现的共用字符（包括重复字符），并以数组形式返回。你可以按任意顺序返回答案。

题解

利用python内置模块一行代码解决问题：求每个计数器的交集即可

解释：

Counter类
Counter类基于dict字典类，可使用dict的方法，其实例可以进行 与或非异或 运算。
map
map(function, iterable, …)：会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
reduce
reduce(function, iterable[, initializer])：对迭代器内进行两个元素操作并传递。
求每个计数器的交集即可，而这个交集必须与其后的交集传递下去，因此 reduce 函数满足。即这里求两个 Counter 计数器的交集操作，然后作为参数 x 传递到下一个去和 iterable 下一个计数器取交集。由于 reduce 最后运算得到的是 Counter 对象，因此取出元素 Counter.elements() 是迭代器，因而 list 创建列表。

class Solution:
    def commonChars(self, A: List[str]) -> List[str]:
        return reduce(lambda x, y: x&y, map(Counter, A)).elements()
        # 使用 lambda 匿名函数

代码详细展开如下：

class Solution:
    def commonChars(self, A: List[str]) -> List[str]:
        from collections import Counter
        ans = Counter(A[0])
        for i in A[1:]:
            ans &= Counter(i)
        return list(ans.elements())

202. 快乐数

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

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

题解

方法一：哈希集合检测循环

我们可以先举几个例子，找出快乐数的规律，发现有三种可能性：

最终会得到 1。
最终会进入一个循环。
值会越来越大，最后接近无穷大。（但经过验证不存在）

所以要么是快乐数，要么会进入一个循环。

思路：
算法分为两部分，我们需要设计和编写代码。

给一个数字 nn，它的下一个数字是什么？
按照一系列的数字来判断我们是否进入了一个循环。

实现：
第 1 部分我们按照题目的要求做数位分离，求平方和。
第 2 部分可以使用哈希集合完成。每次生成链中的下一个数字时，我们都会检查它是否已经在哈希集合中。

如果它不在哈希集合中，我们应该添加它。
如果它在哈希集合中，这意味着我们处于一个循环中，因此直接返回 false。

（注！我们使用哈希集合而不是向量、列表或数组的原因是因为我们反复检查其中是否存在某数字。检查数字是否在哈希集合中需要 O(1) 的时间，而对于其他数据结构，则需要 O(n) 的时间。选择正确的数据结构是解决这些问题的关键部分。）

函数divmod(dividend, divisor)是Python的内置函数，它可以把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a / b, a % b)。

def isHappy(self, n: int) -> bool:

    def get_next(n):
        total_sum = 0
        while n > 0:
            n, digit = divmod(n, 10)
            total_sum += digit ** 2
        return total_sum

    seen = set()
    while n != 1 and n not in seen:
        seen.add(n)
        n = get_next(n)
    return n == 1

复杂度分析

时间复杂度：时间复杂度：O(243⋅3+logn+loglogn+logloglogn)… = O(logn)。
空间复杂度：O(\log n)O(logn)。

方法二：快慢指针法

通过反复调用 getNext(n) 得到的链是一个隐式的链表。隐式意味着我们没有实际的链表节点和指针，但数据仍然形成链表结构。起始数字是链表的头 “节点”，链中的所有其他数字都是节点。next 指针是通过调用 getNext(n) 函数获得。

意识到我们实际有个链表，那么这个问题就可以转换为检测一个链表是否有环。因此我们在这里可以使用弗洛伊德循环查找算法。

这个算法是两个奔跑选手，一个跑的快，一个跑得慢。在龟兔赛跑的寓言中，跑的慢的称为 “乌龟”，跑得快的称为 “兔子”。如果有环的话，不管乌龟和兔子在循环中从哪里开始，它们最终都会相遇。这是因为兔子每走一步就向乌龟靠近一个节点（在它们的移动方向上）。

算法
我们不是只跟踪链表中的一个值，而是跟踪两个值，称为快跑者和慢跑者。在算法的每一步中，慢速在链表中前进 1 个节点，快跑者前进 2 个节点（对 getNext(n) 函数的嵌套调用）。

如果 n 是一个快乐数，即没有循环，那么快跑者最终会比慢跑者先到达数字 1。
如果 n 不是一个快乐的数字，那么最终快跑者和慢跑者将在同一个数字上相遇。

def isHappy(self, n: int) -> bool:  
    def get_next(number):
        total_sum = 0
        while number > 0:
            number, digit = divmod(number, 10)
            total_sum += digit ** 2
        return total_sum

    slow_runner = n
    fast_runner = get_next(n)
    while fast_runner != 1 and slow_runner != fast_runner:
        slow_runner = get_next(slow_runner)
        fast_runner = get_next(get_next(fast_runner))
    return fast_runner == 1

时间复杂度：O(logn)
空间复杂度：O(1)，对于这种方法，我们不需要哈希集来检测循环。

383. 赎金信

为了不在赎金信中暴露字迹，从杂志上搜索各个需要的字母，组成单词来表达意思。

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

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

题解

使用Counter类的交集操作，获得交集，判断两者交集是否等于ransomNote，是则满足，否则不满足。（Counter yyds！）

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        a = Counter(ransomNote) 
        b = Counter(magazine)
        return (a & b) == a