LeetCode分类练习之动态规划
动态规划算法介绍
主要思想
动态规划常常适用于有重叠子问题和最优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。
若要解一个给定问题，我们需要解其不同部分（即子问题），再根据子问题的解以得出原问题的解。动态规划往往用于优化递归问题，例如斐波那契数列，如果运用递归的方式来求解会重复计算很多相同的子问题，利用动态规划的思想可以减少计算量。
动态规划法仅仅解决每个子问题一次，具有天然剪枝的功能，从而减少计算量，一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。
动态规划模板步骤：
- 确定动态规划状态
- 写出状态转移方程（画出状态转移表）
- 考虑初始化条件
- 考虑输出状态
- 考虑对时间，空间复杂度的优化（Bonus）
LeetCode实践
300.最长上升子序列
- 题目描述：
给定一个无序的整数数组，找到其中最长上升子序列的长度。
输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。
- 动态规划思路：
- 确定动态规划状态
该题目可以直接用一个一维数组 dp 来存储转移状态， dp[i] 可以定义为以 nums[i] 这个数结尾的最长递增子序列的长度。举个实际例子，比如在 nums[10,9,2,5,3,7,101,18] 中， dp[0] 表示数字10的最长递增子序列长度，那就是本身，所以为1，对于 dp[5] 对应的数字7来说的最长递增子序列是 [2,5,7] （或者 [2,3,7] ）所以 dp[5]=3 。 - 写出状态转移方程
dp[i]是如何计算的？首先，在dp[i]之前，dp[0,1,2，……i-1]已经求出，分别代表以nums[0,1,2，……i-1]结尾的最长递增子序列，dp[i]的计算要保证两个条件：①dp[j] 0=<j<i的末尾元素nums[j]要小于num[i],这样加上nums[i]后可以保证还是递增的。②dp[j] 0=<j<i 中，要取满足条件①中最大的dp[j]对应的子序列与nums[i]相连，这样才能保证加1后是最大的递增序列。所以可以写出状态转移方程：
dp[i]=max(dp[j])+1,其中0=<j<i,且nums[j]<nums[i] - 初始化条件
- 对于本问题，子序列最少也是自己，所以长度为1，这样我们就可以方便的把所有的 dp 初始化为1，再考虑长度问题，由于 dp[i] 代表的是 nums[i] 的最长子序列长度，所以并不需要加1
- 考虑输出状态
主要有以下三种形式，对于具体问题，我们一定要想清楚到底dp数组里存储的是哪些值，最后我们需要的是数组中的哪些值：- 返回dp数组中最后一个值作为输出，一般对应二维dp问题。
- 返回dp数组中最大的那个数字，一般对应记录最大值问题。
- 返回保存的最大值，一般是 Maxval=max(Maxval,dp[i]) 这样的形式。
- 确定动态规划状态
本例中dp[i]存储的以num[i]这个元素结尾的最长递增子序列，数组nums本身并不是有序的，所以dp[i]的大小和i的大小没有关系,所以需要输出的是：max(dp)
-
第五步：考虑对时间，空间复杂度的优化
我们看到，之前方法遍历dp列表需要 ，计算每个 dp[i] 需要 的时间，所以总复杂度是前面遍历dp列表的时间复杂度肯定无法降低了，但是我们看后面在每轮遍历 [0,i] 的 dp[i] 元素的时间复杂度可以考虑设计状态定义，使得整个dp为一个排序列表，这样我们自然想到了可以利用二分法来把时间复杂度降到了 N l o g N NlogN NlogN，可以参考LeetCode题解中的动态规划+二分法。 -
代码：
class Solution:
def lengthOfLIS(self, nums: List[int]) -> int:
# 思路：动态规划
# 对于空数组
if not nums:
return 0
dp=[] # 存放最大上升子序列的长度
for i in range(len(nums)): # 当i 为0 时 for j in range(0): 不执行循环内的语句
dp.append(1)
for j in range(i):
if nums[i]>nums[j]:
dp[i]=max(dp[i],dp[j]+1)
return max(dp)
- 复杂度
- 时间复杂度： O ( n 2 ) O(n^2) O(n2)，其中 n 为数组nums 的长度。动态规划的状态数为 n，计算状态 dp[i] 时，需要 O ( n ) O(n) O(n)的时间遍历dp[0…i−1] 的所有状态，所以总时间复杂度为 O ( n 2 ) O(n^2) O(n2)。
- 空间复杂度： O ( n ) O(n) O(n)，需要额外使用长度为 n 的 dp 数组。
674 最长连续递增序列
- 题目描述：
给定一个未经排序的整数数组，找到最长且连续的的递增序列。
示例 1:
输入: [1,3,5,4,7]
输出: 3
解释: 最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为5和7在原数组里被4隔开。
- 思路及代码
class Solution:
def findLengthOfLCIS(self, nums: List[int]) -> int:
# 思路：动态规划
# 数组为空
if not nums:
return 0
# 1. 确定状态：dp[i]用于存放以nums[i]结束的最长连续递增序列
# 3. 初始状态：自身即为一个连续递增序列，所以初始状态均为1
dp=[1]*len(nums)
for i in range(1,len(nums)):
# 2. 状态转移方程
# 状态转移的条件：连续且递增
if nums[i]>nums[i-1]:
dp[i]=dp[i-1]+1
# 不满足条件时，状态不变
else:
dp[i]=1
# 4. 输出：
return max(dp)
- 复杂度：
- 时间复杂度：一次遍历便可求出dp[i],复杂度为 O ( N ) O(N) O(N)
- 空间复杂度： O ( N ) O(N) O(N)，需要额为长度为 N N N的数组
5 最长回文子串
- 题目描述：
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：
输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
- 思路及代码：
class Solution:
def longestPalindrome(self, s: str) -> str:
length=len(s)
# 边界条件:字符串值只包含一个字符
if length<2:
return s
# 1. 确定状态：dp[i][j]代表字符串s的子串s[i][j]是否为回文子串
# 3. 给定初始条件：初始状态均为Fasle
dp=[[False for _ in range(length)]for _ in range(length)]
max_len=1
start=0 # 记录回文子串的起始位置
# 2. 状态转移方程：
# 遍历所有的状态：这里没有遍历对角线的状态，因为对角线的状态肯定为True
for j in range(1,length):
for i in range(j):
# 状态转移条件:条件1，回文，即首尾相等
if s[i]==s[j]:
# 条件2：当首尾之间只有一个字符时，s[i][j]必为回文字符串
if j-i<3:
dp[i][j]=True
# 如果不满足条件2，则是否回文由s[i+1][j-1]决定
else:
# 注意：这里dp[i+1][j-1]的状态在该次循环之前已经计算过了
dp[i][j]=dp[i+1][j-1]
# dp[i][j]只能确定s[i:j]是否为回文子串，不是题目的直接要求
# 如果是回文子串，还需要判断是否为最长：
if dp[i][j]:
cur_len=j-i+1
# 如果当前回文子串最长，记录下当前回文子串的长度和起始位置
if cur_len>max_len:
start=i
max_len=cur_len
# 4. 输出
return s[start:start+max_len]
- 复杂度：
- 时间复杂度： O ( N 2 ) O(N^2) O(N2),其中 n 是字符串的长度。动态规划的状态总数为 O ( N 2 ) O(N^2) O(N2)，对于每个状态，我们需要转移的时间为 O ( 1 ) O(1) O(1)。
- 空间复杂度： O ( N 2 ) O(N^2) O(N2)，即存储动态规划状态需要的空间。
516 最长回文子序列
- 题目描述：
给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。
示例 1:
输入:
"bbbab"
输出:
4
区分子串和子序列，子串是连续的，子序列可以不连续，但要保持元素的顺序关系
- 思路及代码：
class Solution:
def longestPalindromeSubseq(self, s: str) -> int:
# 1.确定状态：dp[i][j]代表s[i][j]最大回文子序列的长度
n=len(s)
dp=[[0]*n for _ in range(n)]
# 3. 边界条件：
# 当i=j时，及只包含一个字符，dp[i][j]=1
for i in range(n):
dp[i][i]=1
# 当i>j是，不存在这样的状态，记为0
# 遍历各状态：要根据状态方程，确定遍历的顺序
# 对列按顺序遍历，行按逆序遍历，且i<j
for i in range(n-2,-1,-1):
for j in range (i+1,n):
# 2. 状态转移方程
if s[i]==s[j]:
# 状态方程左边i,右边i+1,所以i应当逆序遍历
# 状态方程左边j,右边j-1,所以j应当顺序遍历
dp[i][j]=dp[i+1][j-1]+2
else:
dp[i][j]=max(dp[i][j-1],dp[i+1][j])
# 4 确定输出:根据状态转移确定输出
return dp[0][n-1]
- 复杂度：
- 时间复杂度： O ( N 2 ) O(N^2) O(N2),其中 n 是字符串的长度。动态规划的状态总数为 O ( N 2 ) O(N^2) O(N2)，对于每个状态，我们需要转移的时间为 O ( 1 ) O(1) O(1)。
- 空间复杂度： O ( N 2 ) O(N^2) O(N2)，即存储动态规划状态需要的空间。
72 编辑距离
- 题目描述：
给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。
你可以对一个单词进行如下三种操作：
插入一个字符
删除一个字符
替换一个字符
示例 1:
输入: word1 = "horse", word2 = "ros"
输出: 3
解释:
horse -> rorse (将 'h' 替换为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')
- 思路及代码：
def minDistance(self, word1, word2):
#m,n 表示两个字符串的长度
m=len(word1)
n=len(word2)
#构建二维数组来存储子问题
dp=[[0 for _ in range(n+1)] for _ in range(m+1)]
#考虑边界条件，第一行和第一列的条件
for i in range(n+1):
dp[0][i]=i #对于第一行，每次操作都是前一次操作基础上增加一个单位的操作
for j in range(m+1):
dp[j][0]=j #对于第一列也一样，所以应该是1,2,3,4,5...
for i in range(1,m+1): #对其他情况进行填充
for j in range(1,n+1):
if word1[i-1]==word2[j-1]: #当最后一个字符相等的时候，就不会产生任
何操作代价，所以与dp[i-1][j-1]一样
dp[i][j]=dp[i-1][j-1]
else:
dp[i][j]=min(dp[i-1][j],dp[i][j-1],dp[i-1][j-1])+1 #分别
对应删除，添加和替换操作
return dp[-1][-1] #返回最终状态就是所求最小的编辑距离
- 复杂度：
- 时间复杂度 ： O ( m n ) O(mn) O(mn)，其中 m 为 word1 的长度，n 为 word2 的长度。
- 空间复杂度 ： O ( m n ) O(mn) O(mn)，我们需要大小为 O ( m n ) O(mn) O(mn) 的 数组来记录状态值。
扫一扫
410
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
