动态规划问题

1、最长递增子序列

def LIS(nums):
  # dp[i]表示以nums[i]结尾的最长递增子序列
  res = 0
  length = len(nums)
  if length<2: return length
  dp = [1 for _ in range(length)]
  for i in range(length):
    for j in range(i):
      if nums[i] > nums[j]:
        dp[i] = max(dp[i], dp[j] + 1)
    res = max(res, dp[i])
  return res

def LIS2(nums):
  # 数组up表示最长上升子序列，遍历nums，up都小于nums[i]，append，否则替换比nums[i]大的最小的那个元素
  length = len(nums)
  if length<2: return length
  up = [nums[0]]
  for num in nums[1:]:
    if up[-1] < num:
      up.append(num)
      continue
    # 二分查找比num应该在的位置
    l, r = 0, len(up)-1
    while l<r:
      mid = l+((r-l)>>1)
      if up[mid]<num:
        l = mid+1
      else:
        r=mid
    up[l] = num
  return len(up)

2、最大子数组和

def maxSeqSum(nums):
  # dp[i]表示以nums[i]结尾的最大连续子序列和
  if not nums:
    return -1
  length = len(nums)
  max_sum = nums[0]

  # 1、dp数组，需要O(n)空间
  dp = nums.copy()
  for i in range(1, length):
    dp[i] = max(dp[i-1]+nums[i], nums[i])
    max_sum = max(dp[i], max_sum)
  
  # 2、优化空间O(1)
  cur_sum = nums[0]
  for i in range(1, length):
    cur_sum = nums[i] if cur_sum<0 else cur_sum+nums[i]
    max_sum = max(cur_sum, max_sum)
  
  return max_sum

3、最大子序列乘积

def maxProduct(nums):
  length = len(nums)
  res = nums[0]
  # dp[i]表示nums[i]结尾的最大子数组乘积
  dp_max = dp_min = nums.copy()
  for i in range(1, length):
    dp_max = max(dp_max[i-1]*nums[i], nums[i], dp_min[i-1]*nums[i])
    dp_min = min(dp_max[i-1]*nums[i], nums[i], dp_min[i-1]*nums[i])
    res = max(res, dp_max[i])
  
  # 空间优化
  max_dp = min_dp = 1
  for i in range(length):
    temp_min = min_dp
    temp_max = max_dp
    min_dp = min(nums[i], temp_max*nums[i], temp_min*nums[i])
    max_dp = max(nums[i], temp_max*nums[i], temp_min*nums[i])
    res = max(max_dp, res)

  return res