Task02：动态规划

一、例题：300 最长上升子序列

题目描述

给定一个无序的整数数组，找到其中最长上升子序列的长度。
示例：

输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

说明:

可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
你算法的时间复杂度应该为 O(n2) 。

分析

1. 用一个一维数组dp来存储转移状态，dp[i]可以定义为以nums[i]这个数结尾的最长递增子序列的长度。
2. 比较当前dp[i]的长度和dp[i]对应产生新的子序列长度，找到长度最长的作为dp[i]的值。
3. 把所有的dp初始化为1，dp数组长度即为原nums数组长度。
4. 返回保存的最大值。

代码

class Solution(object):
    def lengthOfLIS(self, nums):
      if not nums:
            return 0
      dp=[1]*len(nums) 
      for i in range(1, len(nums)):
          for j in range(i):
              if nums[i] > nums[j]:
                  dp[i] = max(dp[i], dp[j]+1)
      return max(dp)

二、674 最长连续递增序列

题目描述

给定一个未经排序的整数数组，找到最长且连续的的递增序列。

示例 1:
输入: [1,3,5,4,7]
输出: 3
解释: 最长连续递增序列是 [1,3,5], 长度为3。
尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为5和7在原数组里被4隔开。

分析

1. 用一个一维数组dp来存储转移状态，dp[i]可以定义为以nums[i]这个数结尾的最长连续递增子序列的长度。
2. 比较nums[i]与其后一个数的大小，若小于等于则dp[i+1]=1，反之dp[i+1]=dp[i]+1
3. 把所有的dp初始化为1，dp数组长度即为原nums数组长度。
4. 返回保存的最大值。

代码

class Solution:
    def findLengthOfLCIS(self, nums):
        if not nums:
            return 0
        dp = [1] * len(nums)
        for i in range(1, len(nums)):
            if nums[i] > nums[i-1]:
                dp[i] = dp[i-1]+1
            else:
                dp[i] = 1
        return max(dp)

三、5 最长回文子串

题目描述

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：
输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。

分析

1. 定义d[i][j]表示子串s从i到j是否为回文子串。
2. 当字符串首尾两个字符相等时：如果子串是回文，整体就是回文，这里就有了动态规划的思想，出现了子问题；相反，如果子串不是回文，那么整体肯定不是。
3. d表格的对角线d[i][i]肯定是True。
4. 记录起始位置和当前长度。

代码

class Solution:
    def longestPalindrome(self, s)
        n = len(s)
        result = ''
        if n < 2:
            return s
        d = [[False for _ in range(n)] for _ in range(n)]
        for i in range(0, n):
                d[i][i] = True
        for j in range(0, n):
            for i in range(0, j+1):
                if j == i:
                    pass
                elif j == i+1:
                    d[i][i + 1] = (s[i] == s[i + 1])
                else:
                    d[i][j] = (d[i+1][j-1] and s[i] == s[j])
                if d[i][j] and ((j-i+1) > len(result)):
                    result = s[i:j+1]
        return result

四、516 最长回文子序列

题目描述

给定一个字符串s，找到其中最长的回文子序列。可以假设s的最大长度为1000。

示例 1:
输入:
“bbbab”
输出:
4

分析

1. 定义一个二维的d[i][j]来表示字符串第i个字符到第j个字符的长度。
2. 对于d[i][j]，当s[i]和s[j]相等时，s[i+1…j-1]这个字符串加上2就是最长回文子序列；当s[i]和s[j]不相等时，说明它俩不可能同时出现在 s[i…j] 的最长回文子序列中，那么把它俩分别加入 s[i+1…j-1] 中，看看哪个子串产生的回文子序列更长即可。
3. d表格的对角线d[i][i]肯定是1。
4. 输出d[0][-1]。

代码

class Solution:
    def longestPalindromeSubseq(self, s):
        d = [[0 for _ in range(len(s))] for _ in range(len(s))]
        for i in range(len(s)):
                d[i][i] = 1

        for i in range(len(s),-1,-1):
            for j in range(i+1,len(s)):
                    if s[i] == s[j]:
                        d[i][j] = d[i + 1][j - 1] + 2
                    else:
                        d[i][j] = max(d[i + 1][j], d[i][j - 1])
        return d[0][-1]

五、72 编辑距离

题目描述

你可以对一个单词进行如下三种操作：
插入一个字符
删除一个字符
替换一个字符
示例 1:
输入: word1 = “horse”, word2 = “ros”
输出: 3
解释:
horse -> rorse (将 ‘h’ 替换为 ‘r’)
rorse -> rose (删除 ‘r’)
rose -> ros (删除 ‘e’)

分析

1. 用 d[i][j] 表示 A 的前 i 个字母和 B 的前 j 个字母之间的编辑距离。
2. 对于插入操作，当我们在word1中插入一个和word2一样的字符，那么
   word2就被匹配了，所以可以直接表示为dp[i][j-1]+1
   对于删除操作，直接表示为dp[i-1][j]+1
   对于替换操作，直接表示为dp[i-1][j-1]+1
   状态转移方程可以写成min(dp[i][j-1]+1,dp[i-1][j]+1,dp[i-1][j-1]+1)​。
3. 一个空串和一个非空串的编辑距离为 d[i][0] = i 和 d[0][j] = j
4. 输出d[-1][-1]。

代码

class Solution:
    def minDistance(self, word1, word2):
        n = len(word1)
        m = len(word2)
        if n * m == 0:
            return n + m
        d = [[0] * (m + 1) for _ in range(n + 1)]

        for i in range(n + 1):
            d[i][0] = i
        for j in range(m + 1):
            d[0][j] = j

        for i in range(1, n + 1):
            for j in range(1, m + 1):
                if word1[i - 1] != word2[j - 1]:
                    d[i - 1][j - 1] += 1
                d[i][j] = min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1])
        return d[-1][-1]

六、198 打家劫舍

题目描述

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
示例 1:
输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。

分析

1. 定义dp[i]表示偷窃第i号房子能得到的最高金额。
2. 偷窃第i间房屋，那么就不能偷窃第i-1间房屋，偷窃总金额为前i-2间房屋的最高总金额与第i间房屋的金额之和。
   不偷窃第i间房屋，偷窃总金额为前i-1间房屋的最高总金额。
3. 只有一个房子的时候，只抢那间房子，有两间房的时候，就抢金额较大的那间。dp[0]=nums[0]，dp[1]=max(nums[0],nums[1])​。
4. 返回dp[-1]。

代码

class Solution:
    def rob(self, nums):
        if not nums: return 0
        n = len(nums)
        if n == 1:
            return nums[0]
        dp = [0] * n
        dp[0] = nums[0]
        dp[1] = max(nums[0], nums[1])
        for i in range(2, n):
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
        return dp[-1]

七、213 打家劫舍 II

题目描述

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
示例 1:
输入: [2,3,2]
输出: 3
解释: 你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

分析

1. 定义dp[i]表示偷窃第i号房子能得到的最高金额。
2. 在不偷窃第一个房子的情况下最大金额是 p1
   在不偷窃最后一个房子的情况下最大金额是 p2。
   综合偷窃最大金额为max(p1,p2) 。每个子问题就和上题是一样的了。
3. dp[0]=nums[0]，dp[1]=max(nums[0],nums[1])。
4. 返回dp[-1]。

代码

class Solution:
    def rob(self, nums):
        if len(nums) == 0:
            return 0
        if len(nums) <= 2:
            return max(nums)

        dp1 = [0 for i in range(len(nums) - 1)]
        dp1[0] = nums[0]
        dp1[1] = max(nums[0], nums[1])
        for i in range(2, len(nums) - 1):
            dp1[i] = max(dp1[i - 2] + nums[i], dp1[i - 1])

        dp2 = [0 for i in range(len(nums) - 1)]
        dp2[0] = nums[1]
        dp2[1] = max(nums[2], nums[1])
        for i in range(3, len(nums)):
            dp2[i - 1] = max(dp2[i - 3] + nums[i], dp2[i - 2])
        return max(dp1[-1], dp2[-1])