代码随想录文章讲解
动态规划
- dp[i]表示i之前包括i的以nums[i]结尾最长上升子序列的长度
- 位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。所以：
if (nums[i] > nums[j]) dp[i] = max(dp[i], dp[j] + 1);注意这里不是要dp[i] 与 dp[j] + 1进行比较，而是我们要取dp[j] + 1的最大值。
- 每一个i，对应的dp[i]（即最长上升子序列）起始大小至少都是1.
- dp[i] 是有0到i-1各个位置的最长升序子序列 推导而来，那么遍历i一定是从前向后遍历。j其实就是0到i-1，遍历i的循环在外层，遍历j则在内层.
class Solution:
def lengthOfLIS(self, nums: List[int]) -> int:
if len(nums) == 1:
return 1
dp = [1] * len(nums)
res = 0
for i in range(1, len(nums)):
for j in range(i):
if nums[j] < nums[i]:
dp[i] = max(dp[i], dp[j]+1)
res = max(res, dp[i])
return res
Build Subsequence(using binary search)
import bisect
class Solution:
def lengthOfLIS(self, nums: List[int]) -> int:
sub = []
for num in nums:
i = bisect.bisect_left(sub, num)
if i == len(sub):
sub.append(num)
else:
sub[i] = num
return len(sub)
代码随想录文章讲解
贪心
class Solution:
def findLengthOfLCIS(self, nums: List[int]) -> int:
if len(nums) == 1:
return 1
res = 1
cur = 1
for i in range(1, len(nums)):
if nums[i] > nums[i-1]:
cur += 1
else:
cur = 1
res = max(cur, res)
return res
动态规划
- dp[i]：以下标i为结尾的数组的连续递增的子序列长度为dp[i] 。
- 如果 nums[i + 1] > nums[i]，那么以 i+1 为结尾的数组的连续递增的子序列长度 一定等于 以i为结尾的数组的连续递增的子序列长度 + 1 。即：
dp[i + 1] = dp[i] + 1;
- 以下标i为结尾的数组的连续递增的子序列长度最少也应该是1，即就是nums[i]这一个元素。所以dp[i]应该初始1;
- 从递推公式上可以看出， dp[i + 1]依赖dp[i]，所以一定是从前向后遍历。
class Solution:
def findLengthOfLCIS(self, nums: List[int]) -> int:
if len(nums) == 1:
return 1
dp = [1] * len(nums)
res = 0
for i in range(1, len(nums)):
if nums[i-1] < nums[i]:
dp[i] = dp[i-1] + 1
res = max(dp[i], res)
return res
代码随想录文章讲解
动态规划
dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]。 （特别注意： “以下标i - 1为结尾的A” 标明一定是 以A[i-1]为结尾的字符串 ）- 根据
dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。即当A[i - 1]和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;根据递推公式可以看出，遍历i 和 j 要从1开始！
- 根据
dp[i][j]的定义，dp[i][0]和dp[0][j]其实都是没有意义的！但dp[i][0]和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;所以dp[i][0]和dp[0][j]初始化为0。
- 外层for循环遍历A，内层for循环遍历B。
class Solution:
def findLength(self, nums1: List[int], nums2: List[int]) -> int:
dp = [ [0]*(len(nums2)+1) for _ in range(len(nums1)+1) ]
res = 0
for i in range(1, len(nums1)+1):
for j in range(1, len(nums2)+1):
if nums1[i-1] == nums2[j-1]:
dp[i][j] = dp[i-1][j-1]+1
res = max(res, dp[i][j])
return res
class Solution:
def findLength(self, nums1: List[int], nums2: List[int]) -> int:
dp = [ [0]*(len(nums2)) for _ in range(len(nums1)) ]
res = 0
for i in range(len(nums1)):
if nums1[i] == nums2[0]:
dp[i][0] = 1
res = max(res, 1)
for j in range(len(nums2)):
if nums2[j] == nums1[0]:
dp[0][j] = 1
res = max(res, 1)
for i in range(1, len(nums1)):
for j in range(1, len(nums2)):
if nums1[i] == nums2[j]:
dp[i][j] = dp[i-1][j-1]+1
res = max(res, dp[i][j])
return res
动态规划（滚动数组）
- 我们可以看出
dp[i][j]都是由dp[i - 1][j - 1]推出。那么压缩为一维数组，也就是dp[j]都是由dp[j - 1]推出。也就是相当于可以把上一层dp[i - 1][j]拷贝到下一层dp[i][j]来继续用。
- 此时遍历B数组的时候，就要从后向前遍历，这样避免重复覆盖。
class Solution:
def findLength(self, nums1: List[int], nums2: List[int]) -> int:
dp = [ 0 for _ in range(len(nums1)+1) ]
res = 0
for i in range(1, len(nums1)+1):
for j in range(len(nums2), 0, -1):
if nums1[i-1] == nums2[j-1]:
dp[j] = dp[j-1]+1
else:
dp[j] = 0
res = max(res, dp[j])
return res
