01 35. 搜索插入位置:
https://leetcode-cn.com/problems/search-insert-position/
给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。如果目标值不存在于数组中,返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
class Solution:
def searchInsert(self, nums: List[int], target: int) -> int:
if not nums:
return None
left = 0
right = len(nums) - 1
if nums[left] == target:
return left
if nums[right] == target:
return right
if nums[left] > target:
return 0
if nums[right] <target:
return len(nums)
while left < right-1:
mid = (left + right) // 2
if nums[mid] == target:
return mid
if nums[mid] < target:
left = mid
else:
right = mid
if nums[left] == target:
return left
else:
return right
利用二分法查找,需要注意边界条件,循环开始前判断左右位置是否是target,或者nums[left] > target,或者nums[right] < target循环之后也需要判断一次
02 202. 快乐数
https://leetcode-cn.com/problems/happy-number
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为:对于一个正整数,每一次将该数替换为它每个位置上的数字的平方和,然后重复这个过程直到这个数变为 1,也可能是 无限循环 但始终变不到 1。如果 可以变为 1,那么这个数就是快乐数。
如果 n 是快乐数就返回 True ;不是,则返回 False 。
class Solution:
def isHappy(self, n: int) -> bool:
past = n
collect = [n]
while True:
nums = list(str(past))
sums = 0
for i in nums:
sums += int(i)**2
if sums == 1:
return True
if sums in collect:
return False
past = sums
collect.append(sums)
需要注意的是跳出循环的条件,当得出的平方和在之前出现过,则说明将无限循环,因此需要用一个列表将之前得出的平方和都保存下来
03 205. 同构字符串
https://leetcode-cn.com/problems/isomorphic-strings
给定两个字符串 s 和 t,判断它们是否是同构的。
如果 s 中的字符可以被替换得到 t ,那么这两个字符串是同构的。所有出现的字符都必须用另一个字符替换,同时保留字符的顺序。两个字符不能映射到同一个字符上,但字符可以映射自己本身。
class Solution:
def isIsomorphic(self, s: str, t: str) -> bool:
def test(s,t):
if len(s) != len(t):
return False
dic = dict()
for i in range(len(s)):
if s[i] not in dic.keys():
dic[s[i]] = t[i]
elif dic[s[i]] != t[i]:
return False
return True
return test(s,t) and test(t,s)
做法是将两单词字母映射关系用字典存储,然后一次看对应单词是否符合条件,因为一开始只考虑了A到B的映射,所以再将其调换位置判断一次
04 242. 有效的字母异位词
https://leetcode-cn.com/problems/valid-anagram/
给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的字母异位词。
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
if len(s)!= len(t):
return False
def create_dic(s):
dic=dict()
for a in s:
if a in dic.keys():
dic[a] = dic[a] + 1
else:
dic[a] = 0
return dic
dic1 = create_dic(s)
dic2 = create_dic(t)
return dic1 == dic2
分别构造字母:个数字典,然后判断两字典是否相同
05 290. 单词规律
https://leetcode-cn.com/problems/word-pattern
给定一种规律 pattern 和一个字符串 str ,判断 str 是否遵循相同的规律。
这里的 遵循 指完全匹配,例如, pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。
class Solution:
def wordPattern(self, pattern: str, str: str) -> bool:
pattern = list(pattern)
str = str.split()
if len(pattern) != len(str):
return False
dic = dict()
words = []
for p,s in zip(pattern,str):
if p not in dic.keys():
if s in words:
return False
dic[p] = s
words.append(s)
elif dic[p] != s:
return False
return True
利用字典存储pattern和str之间的映射关系,通过循环来判断是否匹配对应的规律
06 349. 两个数组的交集
https://leetcode-cn.com/problems/intersection-of-two-arrays/
给定两个数组,编写一个函数来计算它们的交集。
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
return list(set(nums1) & set(nums2))
将两数组先转为集合,然后再求交集
07 350. 两个数组的交集 II
https://leetcode-cn.com/problems/intersection-of-two-arrays-ii
给定两个数组,编写一个函数来计算它们的交集。
说明:
输出结果中每个元素出现的次数,应与元素在两个数组中出现次数的最小值一致。
我们可以不考虑输出结果的顺序。
class Solution:
def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
dic = {num:[0,0] for num in nums1+nums2}
for i in nums1:
dic[i][0] += 1
for i in nums2:
dic[i][1] += 1
res = []
for i in dic:
res += [i]*min([dic[i][0],dic[i][1]])
return res
分别统计两数组元素数量,将二者数量少的提取出来组成新的数组
08 410. 分割数组的最大值
https://leetcode-cn.com/problems/split-array-largest-sum
给定一个非负整数数组和一个整数 m,你需要将这个数组分成 m 个非空的连续子数组。设计一个算法使得这 m 个子数组各自和的最大值最小。
注意:
数组长度 n 满足以下条件:
1 ≤ n ≤ 1000
1 ≤ m ≤ min(50, n)
方法一:动态规划
思路与算法
「将数组分割为 mm 段,求……」是动态规划题目常见的问法。
本题中,我们可以令 f[i][j] 表示将数组的前 i个数分割为 j段所能得到的最大连续子数组和的最小值。在进行状态转移时,我们可以考虑第 j段的具体范围,即我们可以枚举 k,其中前 k个数被分割为 j-1 段,而第 k+1到第 i 个数为第 j段。此时,这 j 段子数组中和的最大值,就等于 f[k][j-1] 与sub(k+1,i) 中的较大值,其中sub(i,j) 表示数组 nums 中下标落在区间 [i,j] 内的数的和。
由于我们要使得子数组中和的最大值最小,因此可以列出如下的状态转移方程:
f[i][j] = \min_{k=0}^{i-1} \Big{ \max(f[k][j-1], \textit{sub}(k+1,i)) \Big}
f[i][j]=
k=0
min
i−1
{max(f[k][j−1],sub(k+1,i))}
对于状态 f[i][j],由于我们不能分出空的子数组,因此合法的状态必须有 i \geq ji≥j。对于不合法(i < ji<j)的状态,由于我们的目标是求出最小值,因此可以将这些状态全部初始化为一个很大的数。在上述的状态转移方程中,一旦我们尝试从不合法的状态 f[k][j-1] 进行转移,那么max(⋯) 将会是一个很大的数,就不会对最外层的 \min{\cdots}min{⋯} 产生任何影响。
此外,我们还需要将 f[0][0] 的值初始化为 00。在上述的状态转移方程中,当 j=1j=1 时,唯一的可能性就是前 ii 个数被分成了一段。如果枚举的 k=0k=0,那么就代表着这种情况;如果 k \neq 0k
=0,对应的状态 f[k][0] 是一个不合法的状态,无法进行转移。因此我们需要令 f[0][0] = 0。
最终的答案即为 f[n][m]。
class Solution:
def splitArray(self, nums: List[int], m: int) -> int:
n = len(nums)
f = [[10**18] * (m + 1) for _ in range(n + 1)]
sub = [0]
for elem in nums:
sub.append(sub[-1] + elem)
f[0][0] = 0
for i in range(1, n + 1):
for j in range(1, min(i, m) + 1):
for k in range(i):
f[i][j] = min(f[i][j], max(f[k][j - 1], sub[i] - sub[k]))
return f[n][m]
复杂度分析
时间复杂度:O(n^2 × m),其中 n是数组的长度,m 是分成的非空的连续子数组的个数。总状态数为 O(n×m),状态转移时间复杂度 O(n),所以总时间复杂度为 O(n^2×m)。
空间复杂度:O(n×m),为动态规划数组的开销。
方法二:二分查找 + 贪心
思路及算法
「使……最大值尽可能小」是二分搜索题目常见的问法。
本题中,我们注意到:当我们选定一个值 xx,我们可以线性地验证是否存在一种分割方案,满足其最大分割子数组和不超过 xx。策略如下:
贪心地模拟分割的过程,从前到后遍历数组,用 sum 表示当前分割子数组的和,cnt 表示已经分割出的子数组的数量(包括当前子数组),那么每当 sum加上当前值超过了 x,我们就把当前取的值作为新的一段分割子数组的开头,并将 cnt 加 1。遍历结束后验证是否cnt 不超过 m。
这样我们可以用二分查找来解决。二分的上界为数组nums 中所有元素的和,下界为数组 nums 中所有元素的最大值。通过二分查找,我们可以得到最小的最大分割子数组和,这样就可以得到最终的答案了。
class Solution:
def splitArray(self, nums: List[int], m: int) -> int:
def check(x: int) -> bool:
total, cnt = 0, 1
for num in nums:
if total + num > x:
cnt += 1
total = num
else:
total += num
return cnt <= m
left = max(nums)
right = sum(nums)
while left < right:
mid = (left + right) // 2
if check(mid):
right = mid
else:
left = mid + 1
return left
复杂度分析
时间复杂度:O(n×log(sum−maxn)),其中 sum 表示数组nums 中所有元素的和,maxn 表示数组所有元素的最大值。每次二分查找时,需要对数组进行一次遍历,时间复杂度为O(n),因此总时间复杂度是 O(n×log(sum−maxn))。
空间复杂度:O(1)。
09 451. 根据字符出现频率排序
https://leetcode-cn.com/problems/sort-characters-by-frequency/
给定一个字符串,请将字符串里的字符按照出现的频率降序排列。
class Solution:
def frequencySort(self, s: str) -> str:
if not s:
return ''
dic = dict()
for i in s:
if i not in dic.keys():
dic[i] = 1
else:
dic[i] += 1
dic = [(k,dic[k]) for k in dic]
dic.sort(key=lambda x:x[1],reverse=True)
res = ''
for i in dic:
res += i[0]*i[1]
return res
利用字典统计词频,然后将字典转换成tuple列表,按照字母次数降序排列并生成最终字符串
10 540. 有序数组中的单一元素
https://leetcode-cn.com/problems/single-element-in-a-sorted-array
给定一个只包含整数的有序数组,每个元素都会出现两次,唯有一个数只会出现一次,找出这个数。
示例 1:
输入: [1,1,2,3,3,4,4,8,8]
输出: 2
示例 2:
输入: [3,3,7,7,10,11,11]
输出: 10
注意: 您的方案应该在 O(log n)时间复杂度和 O(1)空间复杂度中运行。
class Solution:
def singleNonDuplicate(self, nums: List[int]) -> int:
if len(nums) == 1:
return nums[0]
left = 0
right = len(nums) - 2
while left < right - 1:
if nums[left] != nums[left+1]:
return nums[left]
if nums[right] != nums[right+1]:
return nums[right+1]
mid = (left + right) // 2
if nums[mid] != nums[mid+1]:
if nums[mid+1] ==nums[mid+2]:
mid += 1
else:
return nums[mid+1]
if (right - mid) % 2 == 0:
right = mid
else:
left = mid
# print(left,right)
if nums[left] !=nums[left+1]:
return nums[left]
else:
return nums[right+1]
利用二分法进行查找,每次取左右索引的中间值,指向两相同数字的第一个索引,并判断left、mid、right是否为单个数字。当单个数字在后半部分时,这部分长度为奇数,需要将left更新为mid,否则就将right更新为mid