目录
哈希表
242. 有效的字母异位词
题目
给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的字母异位词。
注意: 若 s 和 t 中每个字符出现的次数都相同,则称 s 和 t 互为字母异位词。
示例 1:
输入: s = "anagram", t = "nagaram"
输出: true
示例 2:
输入: s = "rat", t = "car"
输出: false
提示:
- 1 < = s . l e n g t h , t . l e n g t h < = 5 ∗ 1 0 4 1 <= s.length, t.length <= 5 * 10^4 1<=s.length,t.length<=5∗104
- s 和 t 仅包含小写字母
进阶: 如果输入字符串包含 unicode 字符怎么办?你能否调整你的解法来应对这种情况?
代码
- 哈希表
时间复杂度 O(n+m)
空间复杂度 O(1)字母种类有限
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
# 单哈希表
hash_s = {}
for item in s:
if item in hash_s:
hash_s[item] += 1
else:
hash_s[item] = 1
for item in t:
if item in hash_s:
hash_s[item] -= 1
else:
hash_s[item] = 1
return all(hash_s[key] == 0 for key in hash_s)
# 双哈希表
hash_s, hash_t = {}, {}
for item in s:
if item in hash_s:
hash_s[item] += 1
else:
hash_s[item] = 1
for item in t:
if item in hash_t:
hash_t[item] += 1
else:
hash_t[item] = 1
return hash_s == hash_t
349. 两个数组的交集
题目
给定两个数组 nums1 和 nums2 ,返回 它们的交集。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
示例 1:
输入:nums1 = [1,2,2,1], nums2 = [2,2]
输出:[2]
示例 2:
输入:nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出:[9,4]
解释:[4,9] 也是可通过的
提示:
- 1 <= nums1.length, nums2.length <= 1000
- 0 <= nums1[i], nums2[i] <= 1000
代码
- 哈希表
时间复杂度 O(n+m)
空间复杂度 O(m+n)
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
# 单哈希表
hash1 = {}
for item in nums1:
if item not in hash1:
hash1[item] = 1
res = []
for item in nums2:
if item in hash1 and hash1[item]:
res.append(item)
hash1[item] = 0
return res
# set
# set1, set2, res = set(nums1), set(nums2), []
# for num in set1:
# if num in set2:
# res.append(num)
# return res
202. 快乐数
题目
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为:
- 对于一个正整数,每一次将该数替换为它每个位置上的数字的平方和。
- 然后重复这个过程直到这个数变为 1,也可能是 无限循环 但始终变不到 1。
- 如果这个过程 结果为 1,那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ;不是,则返回 false 。
示例 1:
输入:n = 19
输出:true
解释:
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
12^ + 0^2 + 0^2 = 1
示例 2:
输入:n = 2
输出:false
提示:
- 1 < = n < = 2 31 − 1 1 <= n <= 2^{31} - 1 1<=n<=231−1
代码
- 哈希表
时间复杂度: O(logn)
空间复杂度: O(logn)
class Solution:
def get_sum(self,n: int) -> int:
new_num = 0
while n:
n, r = divmod(n, 10)
new_num += r ** 2
return new_num
def isHappy(self, n: int) -> bool:
hash_n = {}
while True:
n = self.get_sum(n)
if n == 1:
return True
if n in hash_n:
return False
else:
hash_n[n] = 1
1. 两数之和
题目
给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1:
输入:nums = [2,7,11,15], target = 9
输出:[0,1]
解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。
示例 2:
输入:nums = [3,2,4], target = 6
输出:[1,2]
示例 3:
输入:nums = [3,3], target = 6
输出:[0,1]
提示:
- 2 < = n u m s . l e n g t h < = 1 0 4 2 <= nums.length <= 10^4 2<=nums.length<=104
- − 1 0 9 < = n u m s [ i ] < = 1 0 9 -10^9 <= nums[i] <= 10^9 −109<=nums[i]<=109
- − 1 0 9 < = t a r g e t < = 1 0 9 -10^9 <= target <= 10^9 −109<=target<=109
- 只会存在一个有效答案
进阶: 你可以想出一个时间复杂度小于 O(n2) 的算法吗?
代码
- 哈希表
时间复杂度: O(n)
空间复杂度: O(n)
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
hash1 = {}
for i, num in enumerate(nums):
if (target - num) in hash1:
return [i,hash1[target - num]]
else:
hash1[num] = i
454. 四数相加 II
题目
给你四个整数数组 nums1、nums2、nums3 和 nums4 ,数组长度都是 n ,请你计算有多少个元组 (i, j, k, l) 能满足:
- 0 <= i, j, k, l < n
- nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0
示例 1:
输入:nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出:2
解释:
两个元组如下:
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0
示例 2:
输入:nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出:1
提示:
- n == nums1.length
- n == nums2.length
- n == nums3.length
- n == nums4.length
- 1 <= n <= 200
- − 2 28 < = n u m s 1 [ i ] , n u m s 2 [ i ] , n u m s 3 [ i ] , n u m s 4 [ i ] < = 2 28 -2^{28} <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2^{28} −228<=nums1[i],nums2[i],nums3[i],nums4[i]<=228
代码
- 哈希表
时间复杂度: O ( n 2 ) O(n^2) O(n2)
空间复杂度: O ( n 2 ) O(n^2) O(n2)
class Solution:
def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
# 使用字典存储nums1和nums2中的元素及其和
hashmap = dict()
for n1 in nums1:
for n2 in nums2:
if n1 + n2 in hashmap:
hashmap[n1 + n2] += 1
else:
hashmap[n1 + n2] = 1
# 如果 -(n1+n2) 存在于nums3和nums4, 存入结果
count = 0
for n3 in nums3:
for n4 in nums4:
key = -(n3 + n4)
if key in hashmap:
count += hashmap[key]
return count
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
提示:
- 1 < = r a n s o m N o t e . l e n g t h , m a g a z i n e . l e n g t h < = 1 0 5 1 <= ransomNote.length, magazine.length <= 10^5 1<=ransomNote.length,magazine.length<=105
- ransomNote 和 magazine 由小写英文字母组成
代码
- 哈希表
时间复杂度: O ( n + m ) O(n+m) O(n+m)
空间复杂度: O ( 26 ) O ( 1 ) O(26) O(1) O(26)O(1)
class Solution:
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
# 哈希表加一次遍历
cnt = Counter(magazine)
for item in ransomNote:
cnt[item] -= 1
if cnt[item] < 0:
return False
return True
# 是否ransomNote每个字符的个数小于等于magazine里对应字符的个数
# return all(ransomNote.count(i)<=magazine.count(i) for i in set(ransomNote))
15. 三数之和
题目
给你一个整数数组 nums ,判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ,同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意: 答案中不可以包含重复的三元组。
示例 1:
输入:nums = [-1,0,1,2,-1,-4]
输出:[[-1,-1,2],[-1,0,1]]
解释:
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意,输出的顺序和三元组的顺序并不重要。
示例 2:
输入:nums = [0,1,1]
输出:[]
解释:唯一可能的三元组和不为 0 。
示例 3:
输入:nums = [0,0,0]
输出:[[0,0,0]]
解释:唯一可能的三元组和为 0 。
提示:
- 3 <= nums.length <= 3000
- − 1 0 5 < = n u m s [ i ] < = 1 0 5 -10^5 <= nums[i] <= 10^5 −105<=nums[i]<=105
代码
- 排序 + 双指针 + 去重 + 剪枝
时间复杂度: O ( n 2 ) O(n^2) O(n2)
空间复杂度: O ( l o g N ) O(logN) O(logN)
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
nums.sort()
ans = []
for i in range(len(nums) - 2):
if nums[i] > 0: break
if i > 0 and nums[i] == nums[i-1]: continue
if nums[i] + nums[-2] + nums[-1] < 0: continue
j, k = i + 1, len(nums) - 1
while j < k:
s = nums[i] + nums[j] + nums[k]
if s > 0:
k -= 1
while j < k and nums[k] == nums[k+1]:k -= 1
elif s < 0:
j += 1
while j < k and nums[j] == nums[j-1]:j += 1
else:
ans.append([nums[i], nums[j], nums[k]])
j += 1
k -= 1
while j < k and nums[j] == nums[j-1]:j += 1
while j < k and nums[k] == nums[k+1]:k -= 1
return ans
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
你可以按 任意顺序 返回答案 。
示例 1:
输入:nums = [1,0,-1,0,-2,2], target = 0
输出:[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
示例 2:
输入:nums = [2,2,2,2,2], target = 8
输出:[[2,2,2,2]]
提示:
- 1 <= nums.length <= 200
- − 1 0 9 < = n u m s [ i ] < = 1 0 9 -10^9 <= nums[i] <= 10^9 −109<=nums[i]<=109
- − 1 0 9 < = t a r g e t < = 1 0 9 -10^9 <= target <= 10^9 −109<=target<=109
代码
- 排序 + 双指针 + 去重 + 剪枝
时间复杂度: O ( n 3 ) O(n^3) O(n3)
空间复杂度: O ( l o g N ) O(logN) O(logN)
class Solution:
def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
nums.sort()
ans = []
for a in range(len(nums) - 3):
if nums[a] + nums[a+1] + nums[a+2] + nums[a+3] > target: break
if a > 0 and nums[a] == nums[a-1]: continue
if nums[a] + nums[-3] + nums[-2] + nums[-1] < target: continue
for b in range(a + 1, len(nums) - 2):
if nums[a] + nums[b] + nums[b+1] + nums[b+2] > target: break
if b > a + 1 and nums[b] == nums[b-1]: continue
if nums[a] + nums[b] + nums[-2] + nums[-1] < target: continue
j, k = b + 1, len(nums) - 1
while j < k:
s = nums[b] + nums[j] + nums[k]
if s > target - nums[a]:
k -= 1
while j < k and nums[k] == nums[k+1]:k -= 1
elif s < target - nums[a]:
j += 1
while j < k and nums[j] == nums[j-1]:j += 1
else:
ans.append([nums[a], nums[b], nums[j], nums[k]])
j += 1
k -= 1
while j < k and nums[j] == nums[j-1]:j += 1
while j < k and nums[k] == nums[k+1]:k -= 1
return ans