Leetcode刷题:热题HOT100-Medium篇-Python多算法实现（完结-11~20题）

已于 2022-11-18 20:12:19 修改
阅读量308 收藏
点赞数
分类专栏： Leetcode 文章标签： python leetcode 算法
于 2022-11-18 20:08:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oax_knud/article/details/127911929
版权

系列文章目录

Leetcode刷题:热题HOT100-EASY篇-Python多算法实现（完结-共21题）
Leetcode刷题:热题HOT100-Medium篇-Python多算法实现（完结-1~10题）
Leetcode刷题:热题HOT100-Medium篇-Python多算法实现（完结-11~20题）

文章目录

前言

记录LeetCode 热题 HOT 100的Medium题目题解，采用python实现。

1.三数之和（双指针）*

1.1 题目描述

给你一个整数数组 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] 。
注意，输出的顺序和三元组的顺序并不重要。

1.2 核心思路

参考了Leetcode题解思路：排序+双指针
在这里插入图片描述

1.3 代码

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

2.下一个排列（双指针）*

2.1 题目描述

题目地址：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]

2.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]<nums[start+1]。即在[start+1,n]的子数组为降序数组。分析右边较大的数可以得到，右边较大的数是自右向左遍历nums时，第一个满足nums[end]>nums[start]的数。

  • 升序排序：已经查找到start和end下标，交换nums[start]和nums[end]元素，然后对nums[start+1:]的元素进行升序排序即可。

【若start和end无法找到满足要求的下标，那么说明nums为降序排序，不存在可以交换的两个数，最终返回的下一个排列为nums的升序排序】
升序排序：

2.3 代码

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

在这里插入图片描述

3.搜索旋转排序数组（二分法）*

3.1 题目描述

题目链接：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

3.2 核心思路

由于时间复杂度为O(log n) ，很容易想到采用二分法。
初始化：low=0,high=len(nums)-1
二分循环：mid=(low+high)/2

  • 若nums[mid]==target，则返回mid
  • 若nums[mid]>nums[low]，在[low,mid]之间没有旋转排序，为升序数组。如果target处于[nums[low],num[mid]）中，那么high=mid-1；反之low=mid+1
  • 若nums[mid]>nums[low]，则在[low,mid]之间存在旋转排序，[mid+1,high]之间为升序数组。如果target处于(nums[mid],num[high]]中，那么low=mid+1；反之high=mid-1

3.3 代码

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

在这里插入图片描述

4.在排序数组中查找元素的第一个和最后一个位置（二分法）*

4.1 题目描述

题目地址：在排序数组中查找元素的第一个和最后一个位置

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

4.2 核心思路

通过二分法实现。核心思想为：查找第一个target的下标以及第一个大于target的数的下标。
【查找第一个target的下标】
采用正常的二分法，当nums[mid]==target 并且 nums[mid-1]<target时，返回mid
【查找第一个大于target的下标】
在正常二分法模板上进行改进，当num[mid-1]==target 并且 nums[mid]>target时，返回mid

4.3 代码

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]

在这里插入图片描述

5.旋转图像（矩阵，数组）

5.1 题目描述

5.2 核心思路

对于此题，将矩阵的旋转主要分为两个部分：

  1. 对于matrix[i][j]来说，在经过90°顺时针旋转后，他将移动到哪个位置？
  2. 对于原地旋转矩阵来说，以哪个顺序遍历矩阵中的元素，才能保证被覆盖的元素在之后还可以继续被找到？

【旋转位置公式】
通过观察可以发现，对于以下的矩阵来说，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记录其中一个元素，就可以实现原地旋转。

【遍历矩阵顺序】
如果初始元素为蓝色区域的元素，那么只需要将蓝色区域的元素全部移动到绿色区域，然后绿色区域移动到红色区域，红色区域移动到黄色区域，这样便可以得到最终结果。（图来自官方题解）。分为两种情况：

  • 当n为偶数时，中间不存在需要移动的元素，此时遍历的块的长度和宽度为n/2
  • 当n为奇数时，中间存在需要移动的元素，此时遍历的块的长度和宽度为n//2+1，n//2

可以得到height=n//2+n%2;width=n//2

在这里插入图片描述

5.3 代码

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

在这里插入图片描述

6.字母异位词分组（哈希表）

6.1 题目描述

题目地址：字母异位词分组
给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。

输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]

6.2 核心思路

通过哈希表存储相同字母组成的单词列表。对于strs中的每一个单词，首先将其按照字典序排序。

  • 若排序后的单词不在哈希表中，则将排序后的单词作为key加入哈希表，value为列表，在列表中加入未排序的单词即可
  • 若排序后的单词在哈希表中，只需要将哈希表中的value列表中增加未排序的单词即可。
    哈希表示例如下：
    在这里插入图片描述

6.3 代码

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

在这里插入图片描述

7.最大子数组和（动态规划）

7.1 题目描述

题目地址：最大子数组和
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

7.2 核心思路

采用动态规划的思想，若通过dp[i]表示以nums[i]结尾的最大连续子数组和，那么可以得到:

dp[i]=max(dp[i-1]+nums[i],nums[i])

由此可以得到，dp[i-1]<0时，dp[i-1]+nums[i]<nums[i]，因此：

  • dp[i-1]<0时，dp[i-1]=nums[i]
  • dp[i-1]>=0时，dp[i-1]=nums[i]+dp[i-1]

由于dp[i]仅和dp[i-1]以及nums[i]有关，因此为降低空间复杂度，可以将dp[i-1]，dp[i]简化为两个局部变量来进行计算。

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 核心思路

采用贪心的思想，采用maxTrueIndex维护当前最远可到达的距离。

  • 初始化：maxTrueIndex=0
  • 迭代更新：若第i个元素可以到达，那么位于[i,i+nums[i]]之内的元素均可到达，此时为了优化运算的时间，我们设置maxTrueIndex更新当前可到达的最远距离。maxTrueIndex=max(maxTrueIndex，i+nums[i])，位于maxTrueIndex下标之前的元素均可以到达。
  • 结果返回：若maxTrueIndex>=len(nums)-1，那么最后一个下标可以到达，返回True；反之返回False

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 核心思路

设置merge存储最终结果，算法流程如下：

  1. 对于intervals数组按照每个元素中第一个数字排序
  2. 循环遍历intervals数组：若merge为空，或者intervals[i]于merge最后一个元素不重合，则将intervals[i]加入merge中；否则，合并intervals[i]和merge的最后一个元素。
  3. 返回merge

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” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

10.2 核心思路

采用动态规划的思想，设置dp[i][j]表示机器人从起点走到(i,j)时的路径总数。由于机器人总是向下或者向右行走，因此，dp[i][j]的路径数目等于机器人从起点到达(i-1,j)的路径总数【向下走一步到达（i,j）】加上从起点到达(i,j-1)的路径总数【向右走一步到达（i,j）】

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]
oax_knud
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LeetCode热题HOT100(简单)，刷题自用，python，c++
qq_40283123的博客
02-13 1418
力扣hot100
leetcode数组下标大于间距-leetcode-hot100:leetcode-hot100-python
06-30
leetcode-hot100-python 关键词与解题思路（实时更新） Hot100 按出现频率排序—解题思路 review 1-10 两数之和。Hashmap，空间换时间，扩展：on 时间复杂度寻找两数之差等于定值，用在求子数组和为 k 或其他类似...
[LeetCode]2. 两数相加
张小猪的家
07-26 612
2. 两数相加 难度：中等 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例 1： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 示例 2： 输入：l1 = [0], l2 = [0] 输出：[0] 示例 3： 输入：l1 = [9,9,
leetcode--python--hot100--
AWhiteDongDong的博客
05-11 221
寻找两个正序数组的中位数 给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 参考 class Solution(object): def findMedianSortedArrays(self, nums1, nums2): """ :type nums1: List[int] :type nums2: List[int] :rtype: float
Leetcode python《热题 HOT 100》1. 两数之和
Dontla的博客
09-08 421
[@TOC](Leetcode 刷题记录) 1. 两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 ...
LeetCode 热题 HOT 100 —— 1. 两数之和（python解法）
weixin_42510648的博客
06-01 473
1.Leetcode01——两数之和（python解法） 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 示例1： 输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。 示例2： 输
leetcode刷题模板python-algorithm-pattern-python:算法模式-python
06-30
leetcode刷题模板python Introduction 此项目fork ，原repo用go语言实现，这里准备用python实现，用python的小伙伴可以打卡 算法模板，科学的刷题方式，最快速的刷题路径，让刷题也变得好玩起来, 你值得拥有 :dog_...
leetcode中325题python-leetcode:leetcode刷题
06-30
leetcode中325题python leetcode刷题 6月13日 1021, 921 6月17日 刷题日，刷15题 98, 236, 235, 15, 703 二叉树遍历: pre_order, in_order, post_order 广度优先遍历：队列实现，先进先出，还可以有个visited的集合...
LeetCode 刷题攻略：配思维导图，100+经典算法题目刷题顺序、经典算法模板-Python开发
05-25
LeetCode 刷题攻略：配思维导图，100+经典算法题目刷题顺序、经典算法模板、共40w字的详细图解，以及难点视频题解。按照刷题攻略上的顺序来刷题，让你在算法学习上不再迷茫！ 目录： 算法面试思维导图 B站算法视频...
leetcode算法题主函数如何写-leetcode:leetcode刷题--经典算法集合
06-30
leetcode算法题主函数如何写 算法导论 算法分析 | 渐进分析 给出两个任务的算法，我们如何找到哪一个更好? 通常对于我们来说，一个最简单的方法是实现这两种算法，在计算中运行两个程序以获得不同的输入，并查看哪一...
Leetcode hot100 刷题记录 (python)
qq_61631811的博客
02-20 560
【代码】Leetcode hot100 刷题记录 (python)
Leetcode Hot 100 刷题记录，python语言
最新发布
yuyu12prince的博客
06-29 206
leetcode hot 100
Leetcode python《热题 HOT 100》15. 三数之和
Dontla的博客
09-10 404
Leetcode python 之 《热题 HOT 100》：https://leetcode-cn.com/problemset/hot-100/ 15. 三数之和 给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。 注意：答案中不可以包含重复的三元组。 例如, 给定数组 nums ...
python解决LeetCode精选Hot100
pursuit_zhangyu的博客
10-23 1051
1.两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 试例 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]...
LeetCode 热题 HOT 100 第二十天 46. 全排列 中等题 用python3求解
weixin_40634691的博客
04-19 140
给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。 示例 1： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] 示例 2： 输入：nums = [0,1] 输出：[[0,1],[1,0]] 示例 3： 输入：nums = [1] 输出：[[1]] 提示： 1 <= nums.length <= 6 -10 <= nums[i] <= 10
leetcode--python--hot100--152
AWhiteDongDong的博客
06-06 150
乘积最大子数组 给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积 class Solution(object): def maxProduct(self, nums): """ :type nums: List[int] :rtype: int """ #空间复杂度O(N) # max_dp, min_dp = [nums[0]]
leetcode--python--hot100--79
AWhiteDongDong的博客
05-25 154
单词搜索 给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。 代码解析： backtrack用来判定对于某个以word[0]开头的board中的一个字母，剩余的是否能形成word;主函数用来遍历所有字母 class Solution(object): de
Leetcode刷题:热题HOT100-EASY篇-Python多算法实现（完结-共21题）
oax_knud的博客
11-14 624
Leetcode HOT100 EASY难度题解-python
leetcode-热题100 （python）版本
王不留行嘿呦嘿
06-02 576
以下列出面试高频出现，以及一些非常经典重要的算法题： 数组array类 题号 难度 题目链接 答案详解 备注 1 简单 两数之和 详解 无 53 简单 最大子序和 详解 动态规划，分治法 121 简单[ 买卖股票 题解 无 581 简单 最短无序连续子数组 题解 11 中等 盛最多水的容器 题解 无 100 中等 三数之和 题解 无 31 中等 下一个排列...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

oax_knud

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值