Leetcode刷题:热题HOT100-EASY篇-Python多算法实现(完结-共21题)
Leetcode刷题:热题HOT100-Medium篇-Python多算法实现(完结-1~10题)
Leetcode刷题:热题HOT100-Medium篇-Python多算法实现(完结-11~20题)
记录LeetCode 热题 HOT 100的Medium题目题解,采用python实现。
给你一个整数数组 nums ,判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ,同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意:答案中不可以包含重复的三元组。
输入: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] 。
注意,输出的顺序和三元组的顺序并不重要。
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
if len(nums)<3:return []
nums.sort()
result=[]
for i in range(len(nums)):
if nums[i]>0:break
if i>0 and nums[i]==nums[i-1]:continue
L,R=i+1,len(nums)-1
while L<R:
if nums[i]+nums[L]+nums[R]==0:
if L>i+1 and nums[L]==nums[L-1]:
L,R=L+1,R-1
continue
result.append([nums[i],nums[L],nums[R]])
L,R=L+1,R-1
elif nums[i]+nums[L]+nums[R]>0:
R-=1
elif nums[i]+nums[L]+nums[R]<0:
L+=1
return result
题目地址:31.下一个排列
整数数组的一个 排列 就是将其所有成员以序列或线性顺序排列。
例如,arr = [1,2,3] ,以下这些都可以视作 arr 的排列:[1,2,3]、[1,3,2]、[3,1,2]、[2,3,1] 。
整数数组的 下一个排列 是指其整数的下一个字典序更大的排列。更正式地,如果数组的所有排列根据其字典顺序从小到大排列在一个容器中,那么数组的 下一个排列 就是在这个有序容器中排在它后面的那个排列。如果不存在下一个更大的排列,那么这个数组必须重排为字典序最小的排列(即,其元素按升序排列)。
例如,arr = [1,2,3] 的下一个排列是 [1,3,2] 。
类似地,arr = [2,3,1] 的下一个排列是 [3,1,2] 。
而 arr = [3,2,1] 的下一个排列是 [1,2,3] ,因为 [3,2,1] 不存在一个字典序更大的排列。
给你一个整数数组 nums ,找出 nums 的下一个排列。
必须 原地 修改,只允许使用额外常数空间。
输入:nums = [1,2,3]
输出:[1,3,2]
参考了官方题解。
其核心思路如下:
1、在nums数组中寻找左边较小的数left和右边较大的数right,将其进行交换。
2、对于交换后的nums数组,对于right之后的所有子数组中的元素,对其进行升序排序。【理由:交换了left和right后的nums数组已经实现比原nums数组大,为了前后nums的差距减小,对right元素之后的数组进行升序排序,实现减小更新后nums排列的作用】
【举例: [4,5,2,6,3,1]】
对于算法实现主要分为两个部分:查找较大数和较小数;升序排序。
查找较大数和较小数:首先设置start,end分别存储左边较小数和右边较大数下标。初始化start=end=len(nums)-1。分析左边较小数的特性可以得到,左边较小数nums[start]满足nums[start]
升序排序:已经查找到start和end下标,交换nums[start]和nums[end]元素,然后对nums[start+1:]的元素进行升序排序即可。
【若start和end无法找到满足要求的下标,那么说明nums为降序排序,不存在可以交换的两个数,最终返回的下一个排列为nums的升序排序】
升序排序:
class Solution:
def nextPermutation(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
if len(nums)==1:return nums
#查找左边的较小数和右边的较大数
n=len(nums)
end,start=n-1,n-1
for i in range(1,n):
if nums[n-i-1]<nums[n-i]:
end=n-i-1
break
while start>end:
if nums[start]>nums[end]:
break
start-=1
#将较小数和较大数交换位置,然后将较大数后面的子数组升序排序
if start!=end:
nums[start],nums[end]=nums[end],nums[start]
nums[end+1:]=sorted(nums[end+1:])
else:#nums为降序排序,无下一个排列
nums=nums.reverse()
return nums
题目链接:33.搜索旋转排序数组
整数数组 nums 按升序排列,数组中的值 互不相同 。
在传递给函数之前,nums 在预先未知的某个下标 k(0 <= k < nums.length)上进行了 旋转,使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]](下标 从 0 开始 计数)。例如, [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
给你 旋转后 的数组 nums 和一个整数 target ,如果 nums 中存在这个目标值 target ,则返回它的下标,否则返回 -1 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
输入:nums = [4,5,6,7,0,1,2], target = 0
输出:4
由于时间复杂度为O(log n) ,很容易想到采用二分法。
初始化:low=0,high=len(nums)-1
二分循环:mid=(low+high)/2
class Solution:
def search(self, nums: List[int], target: int) -> int:
if len(nums)==1:return 0 if nums[0]==target else -1
n=len(nums)
low,high=0,n-1
while low<=high:
mid=int((low+high)/2)
if nums[mid]==target:
return mid
#[0,mid]间无旋转
if nums[0]<=nums[mid]:
#若target在[low,mid]之间
if target>=nums[low] and target<nums[mid]:
high=mid-1
else:
low=mid+1
#[0,mid]间旋转
else:
if target>nums[mid] and target<=nums[high]:
low=mid+1
else:
high=mid-1
return -1
题目地址:在排序数组中查找元素的第一个和最后一个位置
给你一个按照非递减顺序排列的整数数组 nums,和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target,返回 [-1, -1]。
你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
通过二分法实现。核心思想为:查找第一个target的下标以及第一个大于target的数的下标。
【查找第一个target的下标】
采用正常的二分法,当nums[mid]==target 并且 nums[mid-1]
在正常二分法模板上进行改进,当num[mid-1]==target 并且 nums[mid]>target时,返回mid
class Solution:
def searchRange(self, nums: List[int], target: int) -> List[int]:
#寻找第一个大于等于target的下标;寻找第一个大于target的下标
def searchNum(nums,target,flag):#flag=True表示查找大于等于target下标
low,high=0,len(nums)-1
while low<=high:
mid=(low+high)//2
if (nums[mid]==target) and flag:
if mid==0 or nums[mid-1]<target :return mid
high=mid-1
elif nums[mid]>target:
if mid>=1 and nums[mid-1]==target and not flag:return mid
high=mid-1
else:low=mid+1
return -1 if flag else high+1
if len(nums)==0:return [-1,-1]
leftNum,rightNum=searchNum(nums,target,True),searchNum(nums,target,False)
if leftNum==-1 or rightNum==-1:return [-1,-1]
return [leftNum,rightNum-1]
对于此题,将矩阵的旋转主要分为两个部分:
【旋转位置公式】
通过观察可以发现,对于以下的矩阵来说,n=3
(0,0)->(0,2)
(0,1)->(1,2)
(0,2)->(2,2)
(1,0)->(0,1)
(1,1)->(1,1)
(1,2)->(2,1)
(2,0)->(0,0)
(2,1)->(1,0)
(2,2)->(2,0)
通过观察规律,可以得到matrix[i][j]将移动到matrix[j][n-1-i]
记录被覆盖元素的值到temp中,然后依次循环覆盖,可以得到上图。可以看出,顺时针旋转90°时4个元素一组循环覆盖,因此只需要temp记录其中一个元素,就可以实现原地旋转。
【遍历矩阵顺序】
如果初始元素为蓝色区域的元素,那么只需要将蓝色区域的元素全部移动到绿色区域,然后绿色区域移动到红色区域,红色区域移动到黄色区域,这样便可以得到最终结果。(图来自官方题解)。分为两种情况:
可以得到height=n//2+n%2;width=n//2
class Solution:
def rotate(self, matrix: List[List[int]]) -> None:
"""
Do not return anything, modify matrix in-place instead.
"""
n=len(matrix)
blockL,blockW=n//2+n%2,n//2
for i in range(blockL):
for j in range(blockW):
temp=matrix[i][j]
matrix[i][j]=matrix[n-1-j][i]
matrix[n-1-j][i]=matrix[n-1-i][n-1-j]
matrix[n-1-i][n-1-j]=matrix[j][n-1-i]
matrix[j][n-1-i]=temp
题目地址:字母异位词分组
给你一个字符串数组,请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
字母异位词 是由重新排列源单词的字母得到的一个新单词,所有源单词中的字母通常恰好只用一次。
输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
通过哈希表存储相同字母组成的单词列表。对于strs中的每一个单词,首先将其按照字典序排序。
class Solution:
def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
hashmap={}
for word in strs:
sortedWord="".join(sorted(word))
if sortedWord not in hashmap:
hashmap[sortedWord]=[word]
else:
hashmap[sortedWord].append(word)
result=[]
for key,value in hashmap.items():
result.append(value)
return result
题目地址:最大子数组和
给你一个整数数组 nums ,请你找出一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
子数组 是数组中的一个连续部分。
输入:nums = [-2,1,-3,4,-1,2,1,-5,4]
输出:6
解释:连续子数组 [4,-1,2,1] 的和最大,为 6 。
采用动态规划的思想,若通过dp[i]表示以nums[i]结尾的最大连续子数组和,那么可以得到:
dp[i]=max(dp[i-1]+nums[i],nums[i])
由此可以得到,dp[i-1]<0时,dp[i-1]+nums[i] 由于dp[i]仅和dp[i-1]以及nums[i]有关,因此为降低空间复杂度,可以将dp[i-1],dp[i]简化为两个局部变量来进行计算。 题目地址:跳跃游戏 数组中的每个元素代表你在该位置可以跳跃的最大长度。 判断你是否能够到达最后一个下标。 采用贪心的思想,采用maxTrueIndex维护当前最远可到达的距离。 题目连接:合并区间 设置merge存储最终结果,算法流程如下: 题目地址:不同路径 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为 “Finish” )。 问总共有多少条不同的路径? 采用动态规划的思想,设置dp[i][j]表示机器人从起点走到(i,j)时的路径总数。由于机器人总是向下或者向右行走,因此,dp[i][j]的路径数目等于机器人从起点到达(i-1,j)的路径总数【向下走一步到达(i,j)】加上从起点到达(i,j-1)的路径总数【向右走一步到达(i,j)】
7.3 代码
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
n=len(nums)
formerSum,LastSum,maxSum=nums[0],0,nums[0]
for i in range(1,n):
LastSum=nums[i] if formerSum<=0 else nums[i]+formerSum
formerSum=LastSum
maxSum=max(maxSum,LastSum)
return maxSum
8.跳跃游戏(贪心)
8.1 题目描述
给定一个非负整数数组 nums ,你最初位于数组的 第一个下标 。输入:nums = [2,3,1,1,4]
输出:true
解释:可以先跳 1 步,从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
8.2 核心思路
8.3 代码
class Solution:
def canJump(self, nums: List[int]) -> bool:
maxTrueIndex=0
for i in range(len(nums)):
if i<=maxTrueIndex:
maxTrueIndex=max(maxTrueIndex,i+nums[i])
if maxTrueIndex>=len(nums)-1:return True
return False
9.合并区间(排序)
9.1 题目描述
以数组 intervals 表示若干个区间的集合,其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间,并返回 一个不重叠的区间数组,该数组需恰好覆盖输入中的所有区间 。输入:intervals = [[1,3],[2,6],[8,10],[15,18]]
输出:[[1,6],[8,10],[15,18]]
解释:区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
9.2 核心思路
9.3 代码
class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
if len(intervals)==1:return intervals
intervals.sort(key=(lambda x:x[0]))
merge=[]
for i in range(len(intervals)):
if len(merge)==0 or merge[-1][1]<intervals[i][0]:
merge.append(intervals[i])
else:
merge[-1]=[min(merge[-1][0],intervals[i][0]),max(merge[-1][1],intervals[i][1])]
return merge
10.不同路径(动态规划)
10.1 题目描述
一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为 “Start” )。10.2 核心思路
dp[i][j]=dp[i-1][j]+dp[i][j-1]
10.3 代码
class Solution:
def uniquePaths(self, m: int, n: int) -> int:
dp=[[1]*n]*m
for i in range(1,m):
for j in range(1,n):
dp[i][j]=dp[i-1][j]+dp[i][j-1]
return dp[m-1][n-1]