【数据结构与算法】之哈希表系列-20240130

这里写目录标题

• 一、383. 赎金信
• 二、387. 字符串中的第一个唯一字符
• 三、389. 找不同
• 四、409. 最长回文串
• 五、448. 找到所有数组中消失的数字
• 六、594. 最长和谐子序列

一、383. 赎金信

简单

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

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

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

示例 1：

输入：ransomNote = “a”, magazine = “b”

输出：false

示例 2：

输入：ransomNote = “aa”, magazine = “ab”

输出：false

示例 3：

输入：ransomNote = “aa”, magazine = “aab”

输出：true

def func383(ransomNote,magazine):
    ransomNote_set=set(ransomNote)
    for i in ransomNote_set:
        if magazine.count(i)>=ransomNote.count(i):
            return True
        return False

ransomNote = "a"
magazine = "b"
print(func383(ransomNote,magazine))

二、387. 字符串中的第一个唯一字符

简单

给定一个字符串 s ，找到 它的第一个不重复的字符，并返回它的索引 。如果不存在，则返回 -1 。

示例 1：

输入: s = “leetcode”

输出: 0

示例 2:

输入: s = “loveleetcode”

输出: 2

示例 3:

输入: s = “aabb”

输出: -1

class S387:
    def func(self,nums):
        cnt=Counter(nums)
        for i,k in enumerate(cnt):
            if cnt[k]==1:
                return i
        return -1

r=S387()
nums="leetcode"
print(r.func(nums))

三、389. 找不同

简单

给定两个字符串 s 和 t ，它们只包含小写字母。

字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。

请找出在 t 中被添加的字母。

示例 1：

输入：s = “abcd”, t = “abcde”

输出：“e”

解释：‘e’ 是那个被添加的字母。

示例 2：

输入：s = “”, t = “y”

输出：“y”

异或小知识

而对于在 t 中被添加的字符，它们与之前的结果进行异或运算后，结果不为 0，这样就找到了被添加的字符。

class Solution389:
    def func(self, s, t):
        result = 0
        for char in s:
            result = result ^ ord(char)
        for char in t:
            result = result ^ ord(char)
        return chr(result)


res = Solution389()

s = "abcd"
t = "abcde"
print(res.func(s, t))

四、409. 最长回文串

简单

给定一个包含大写字母和小写字母的字符串 s ，返回 通过这些字母构造成的 最长的回文串 。

在构造过程中，请注意 区分大小写 。比如 “Aa” 不能当做一个回文字符串。

示例 1:

输入:s = “abccccdd”

输出:7

解释:

我们可以构造的最长的回文串是”dccaccd”, 它的长度是 7。

示例 2:

输入:s = “a”

输出:1

示例 3：

输入:s = “aaaaaccc”

输出:7

class Solution:
    def func409(self,s):
        res=0
        center=0
        ss=Counter(s)
        for i in ss:
            if ss[i]%2==0:
                res+=ss[i]
            else:
                center=1
                res+=ss[i]-1
        return res+center
res=Solution()
s = "aaaaaccc"
print(res.func409(s))

五、448. 找到所有数组中消失的数字

简单

给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。

示例 1：

输入：nums = [4,3,2,7,8,2,3,1]

输出：[5,6]

示例 2：

输入：nums = [1,1]

输出：[2]

nums = [4, 3, 2, 7, 8, 2, 3, 1]
a = list(range(1, len(nums) + 1))
b = list(set(nums))
print(a)            #[1, 2, 3, 4, 5, 6, 7, 8]
print(b)            #[1, 2, 3, 4, 7, 8]
print(list(set(a) - set(b)))

六、594. 最长和谐子序列

简单

和谐数组是指一个数组里元素的最大值和最小值之间的差别 正好是 1 。

现在，给你一个整数数组 nums ，请你在所有可能的子序列中找到最长的和谐子序列的长度。

数组的子序列是一个由数组派生出来的序列，它可以通过删除一些元素或不删除元素、且不改变其余元素的顺序而得到。

示例 1：

输入：nums = [1,3,2,2,5,2,3,7]

输出：5

解释：最长的和谐子序列是 [3,2,2,2,3]

示例 2：

输入：nums = [1,2,3,4]

输出：2

示例 3：

输入：nums = [1,1,1,1]

输出：0

思路：首先将数组排序，得到递增数组

然后进行遍历一次数组，利用双指针实现类似滑动窗口的功能

class Solution:
    def func594(self,nums):
        nums.sort()     #[1,2,2,2,3,3,5,7]
        l=0
        ans=0
        for r in range(len(nums)):
            while nums[r]-nums[l]>1:
                l+=1
            if nums[r] -nums[l] == 1:
                ans=max(ans,r-l+1)
        return ans

nums = [1,2,3,4]
ss=Solution()
print(ss.func594(nums))