力扣刷题（二）动态规划

动态规划

动态规划常常适用于有重叠子问题和优子结构性质的问题，动态规划方法所耗时间往往远少于朴素解法。
主要思想
若要解一个给定问题，我们需要解其不同部分（即子问题），再根据子问题的解以得出原问题的解。动态规划往往用于优化递归问题，例如斐波那契数列，如果运用递归的方式来求解会重复计算很多相同的 子问题，利用动态规划的思想可以减少计算量。
动态规划法仅仅解决每个子问题一次，具有天然剪枝的功能，从而减少计算量，
一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。

动态规划模板步骤：

确定动态规划状态
写出状态转移方程（画出状态转移表）
考虑初始化条件
考虑输出状态
考虑对时间，空间复杂度的优化（Bonus）

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

解题思路

第一步：确定动态规划状态

这个题目必须用二维的dp数组来记录状态，主要原因就是子串有回文的限制。用两个指针来记录子串的位置可以很好的实现子串的回文要求，又因为后结果需要返回的是子串，这里不同于之前题目的用dp保存长度，我们必须找到具体哪个部分符合回文子串的要求。这里插一句，其实也有求回文子串长度的题目Leetcode516. 长回文子序列,如果有兴趣可以看一 下。这里我们定义 dp[i][j] 表示子串s从i到j是否为回文子串。

第二步写出状态转移方程

首先我们需要知道符合回文的条件：字符串首尾两个字符必须相等，否则肯定不是回文。
当字符串首尾两个字符相等时：如果子串是回文，整体就是回文，这里就有了动态规划的思想，出现了子问题；相反，如果子串不是回文，那么整体肯定不是。
对于字符串 s,s[i,j] 的子串是 s[i+1,j-1] ，如果子串只有本身或者空串，那肯定是回文子串了，所以我们讨论的状态转移方程不是对于 j-1-(i+1)+1<2 的情况(整理得 j-i<3 )，当 s[i] 和 s[j] 相等并且 j-i<3 时，我们可以直接得出 dp[i][j] 是True。

第三步：考虑初始化条件

我们需要建立一个二维的初始状态是False的来保存状态的数组来表示dp，又因为考虑只有一个字 符的时候肯定是回文串，所以dp表格的对角线 dp[i][i] 肯定是True。

第四步：考虑输出状态

这里dp表示的是从 i 到 j 是否是回文子串，这样一来就告诉我们子串的起始位置和结束位置，但是由于我们需要找到长的子串，所以我们优化一下可以只记录起始位置和当前长度（当然你要是 喜欢记录终止位置和当前长度也是没问题的）。

第五步：考虑对时间，空间复杂度的优化

对于这个问题，时间和空间都可以进一步优化，对于空间方面的优化：这里采用一种叫中心扩散的方法来进行，而对于时间方面的优化，则是用了Manacher‘s Algorithm（马拉车算法）来进行优化。具体的实现可以参考动态规划、Manacher 算法 ，具体代码如下：

class Solution:
    def longestPalindrome(self, s: str) -> str:
        # 动态规划，记忆化搜索
        dp = [[-1 for _ in range(len(s))] for __ in range(len(s))]
        def get_dp(i, j):
            if dp[i][j] >= 0:
                return dp[i][j]
            if i==j:
                dp[i][j] = 1
            elif i+1==j:
                dp[i][j] = 2 if s[i]==s[j] else 0
            else:
                if s[i]==s[j] and get_dp(i+1,j-1)>0:
                    dp[i][j] = j-i+1
                else:
                    dp[i][j] = 0
            return dp[i][j]
        maxlen = 0
        result = ""
        for j in range(len(s)):
            for i in range(j+1):
                if get_dp(i,j) > maxlen:
                    maxlen = get_dp(i,j)
                    result = s[i:j+1]
        return result
        

从中间到两边尽心判断回文，代码如下：

class Solution:
    def longestPalindrome(self, s: str) -> str:
        # 中间拓展
        def get_max(i):
            max_len = 1
            max_string = s[i]
            d = 1
            while i-d>=0 and i+d<len(s) and s[i-d]==s[i+d]:
                d += 1
            if 2*d-1 > max_len:
                max_len = 2*d - 1
                max_string = s[i-d+1:i+d]
            d = 0
            while i-1-d>=0 and i+d<len(s) and s[i-d-1]==s[i+d]:
                d += 1
            if 2*d > max_len:
                max_len = 2*d
                max_string = s[i-d:i+d]
            return max_string

        result = ""
        for i in range(len(s)):
            temp = get_max(i)
            if len(temp) > len(result):
                result = temp
        return result

Leetcode 72、编辑距离
给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

1、插入一个字符
2、删除一个字符
3、替换一个字符

第一步：确定动态规划状态

这个题目涉及到两个字符串，所以我们先想到就是用两维数组来保存转移状态，定义dp[i][j] 为字符串word1长度为 i 和字符串word2长度为 j 时，word1转化成word2所执行的少操作次数的值。

第二步：写出状态转移方程

关于这个问题的状态转移方程其实很难想到，这里提供的一个方向就是试着举个例子，然后通过例子的变化记录每一步变化得到的少次数，来找到删除，插入，替换操作的状态转移方程具体应该怎么写。
我们采用从末尾开始遍历 word1 和 word2 ，
当 word1[i] 等于 word2[j] 时，说明两者完全一样，所以 i 和 j 指针可以任何操作都不做，用状态转移式子表示就是dp[i][j]=dp[i-1][j-1] ，也就是前一个状态和当前状态是一样的。
当 word1[i] 和 word2[j] 不相等时，就需要对三个操作进行递归了，这里就需要仔细思考状态转移方程的写法了。
对于插入操作，当我们在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)

第三步：考虑初始化条件

我们还是利用dp转移表法来找到状态转移的变化，这里我们用空字符串来额外加入到word1和word2中，这样的目的是方便记录每一步操作，例如如果其中一个是空字符串，那么另外一个字符至少的操作数都是1，就从1开始计数操作数，以后每一步都执行插入操作，也就是当 i=0 时， dp[0][j]=j ,同理可得，如果另外一个是空字符串，则对当前字符串执行删除操作就可以了，也就是 dp[i][0]=i 。

第四步：考虑输出状态

在转移表中我们可以看到，可以从左上角一直遍历到左下角的值，所以终的编辑距离就是后一个状态的值，对应的就是 dp[-1][-1] 。

第五步：考虑对时间，空间复杂度的优化

和上题一样，这里由于dp[i][j] 只和dp表中附近的三个状态（左边，右边和左上边）有关，所以同样可以进行压缩状态转移的空间存储。

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        # 动态规划
        dp = [[i for i in range(len(word1)+1)] for __ in range(len(word2)+1)]
        for i in range(len(word2)+1):
            dp[i][0] = i
        for j in range(1, len(word2)+1):
            for i in range(1, len(word1)+1):
                if word1[i-1] == word2[j-1]:
                    dp[j][i] = dp[j-1][i-1]
                else:
                    dp[j][i] = min(dp[j-1][i], dp[j][i-1], dp[j-1][i-1]) + 1
        return dp[-1][-1]

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

给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下，一夜之内能够偷窃到的最高金额。

class Solution:
    def rob(self, nums: List[int]) -> int:
        if not nums:
            return 0
        # 动态规划
        dp = [[0,0] for i in range(len(nums))]
        for i in range(len(nums)):
            dp[i][0] = dp[i-1][1] + nums[i]
            dp[i][1] = max(dp[i-1])
        return max(dp[-1])

解题思路

这个问题不复杂，其实利用一般的迭代可以直接解出来，但是这里讲动态规划，所以还是按照标准的套路来

第一步：确定动态规划状态

直接定义题目所求的偷窃的高金额，所以 dp[i] 表示偷窃第 i 号房子能得到的高金额。

第二步：写出状态转移方程

如果我们不考虑限制条件相邻两个房子不能抢，那么问题就很简单。想得到第 i 个房间偷窃到的高金额的时候，我们会考虑子问题前 i-1 间的高金额 dp[i-1] ，然后再加上当前房间的金额，所以后可以表达为 dp[i]=dp[i-1]+nums[i] 。
但是需要注意的是，这里限制了相邻两个房子是不能抢的，接下来我们就要考虑两种情况。如果抢了第i个房间，那么第 i-1 肯定是不能抢的，这个时候需要再往前一间，用第 i-2 间的金额加上当前房间的金额，得到的状态转移方程是dp[i]=dp[i-2]+nums[i] 。
如果没有抢第 i 个房间，那么肯定抢了第 i-1 间的金额，所以直接有 dp[i]=dp[i-1] 。
后综合一下两种情况，就可以很快得到状态转移方程： dp[i]=max(dp[i-2]+nums[i],dp[i-1])

第三步：考虑初始化条件

初始化条件需要考虑第一个房子和第二个房子，之后的房子都可以按照规律直接求解，当我们只有一个房子的时候，自然只抢那间房子，当有两间房的时候，就抢金额较大的那间。综合起来就是 dp[0]=nums[0]，dp[1]=max(nums[0],nums[1]) 。

第四步:考虑输出状态

直接返回状态转移数组的后一个值就是所求的大偷窃金额。

第五步：考虑对时间，空间复杂度的优化

时间复杂度为不能再优化了，空间复杂度方面如果用动态规划是不能优化，但是如果用迭代的方法只存储临时变量来记录每一步计算结果，这样可以降到 。

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

class Solution:
    def rob(self, nums: List[int]) -> int:
        if not nums:
            return 0
        if len(nums)==1:
            return max(0, nums[0])
        # 动态规划
        def get_res(num):
            dp = [[0,0] for i in range(len(num))]
            for i in range(len(num)):
                dp[i][0] = dp[i-1][1] + num[i]
                dp[i][1] = max(dp[i-1])
            return max(dp[-1])
        return max(get_res(nums[1:]), get_res(nums[:-1]))

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

解题思路

这个问题和上面的例题也非常相似，直接套用动态规划套路也可以很快解决出来：

第一步：确定动态规划状态

这里求的是长子串的长度，所以我们可以直接定义一个二维的 dp[i][j] 来表示字符串第 i 个字符到第 j 个字符的长度，子问题也就是每个子回文字符串的长度。

第二步：写出状态转移方程

我们先来具体分析一下整个题目状态转移的规律。对于 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] 加上 s[i] 或者 s[j] 的数值中较大的；

第三步：考虑初始化条件

很明显看出来的当只有一个字符的时候，长回文子序列就是1，所以可以得到 dp[i] [j]=1(i=j) 接下来我们来看看
当 i>j 时，不符合题目要求，不存在子序列，所以直接初始化为0。 当 i<j 时，每次计算表中对应的值就会根据前一个状态的值来计算。

第四步：考虑输出状态

我们想要求长子序列的时候，我们可以直接看出来 dp[0][-1] 是大的值，直接返回这个值就是最后的答案。

第五步：考虑对时间，空间复杂度的优化

对于这个题目，同样可以考虑空间复杂度的优化，因为我们在计算 dp[i][j] 的时候，只用到左边和下边。如果改为用一维数组存储，那么左边和下边的信息也需要存在数组里，所以我们可以考虑在每次变化前用临时变量 tmp 记录会发生变化的左下边信息。

【注】对于二维的数组的动态规划，采用了画状态转移表的方法来得到输出的状态，这种方法更加直观能看出状态转移的具体过程，同时也不容易出错。当然具体选择哪种方法则需要根据具体题目来确定， 如果状态转移方程比较复杂的利用这种方法就能简化很多。

class Solution:
    def longestPalindromeSubseq(self, s: str) -> int:
        # 动态规划
        dp = [[-1 for i in s] for j in s]
        def get_dp(i,j):
            if dp[i][j] >= 0:
                return dp[i][j]
            if i == j:
                dp[i][j] = 1
            elif i+1 == j:
                dp[i][j] = 2 if s[i]==s[j] else 1
            elif i+2 == j:
                dp[i][j] = 3 if s[i]==s[j] else max(get_dp(i+1,j), get_dp(i,j-1))
            else:
                dp[i][j] = 2+get_dp(i+1, j-1) if s[i]==s[j] else max(get_dp(i+1,j), get_dp(i,j-1))
            return dp[i][j]

        get_dp(0, len(s)-1)
        return get_dp(0, len(s)-1)

Leetcode 674. 最长连续递增序列
给定一个未经排序的整数数组，找到最长且连续的的递增序列，并返回该序列的长度。

解题思路

这道题是不是一眼看过去和上题非常的像，没错了，这个题目大的不同就是连续两个字，这样就让这 个问题简单很多了，因为如果要求连续的话，那么就不需要和上题一样遍历两遍数组，只需要比较前后 的值是不是符合递增的关系。

第一步：确定动态规划状态

对于这个问题，我们的状态dp[i]也是以nums[i]这个数结尾的长递增子序列的长度

第二步：写出状态转移方程

这个问题，我们需要分两种情况考虑，第一种情况是如果遍历到的数 nums[i] 后面一个数不是比他大或者前一个数不是比他小，也就是所谓的不是连续的递增，那么这个数列长连续递增序列就是他本身，也就是长度为1。
第二种情况就是如果满足有递增序列，就意味着当前状态只和前一个状态有关，dp[i] 只需要在前一个状态基础上加一就能得到当前长连续递增序列的长度。总结起来，状态的转移方程可以写成 dp[i]=dp[i-1]+1

第三步：考虑初始化条件

和上面长子序列相似，这个题目的初始化状态就是一个一维的全为1的数组。

第四步：考虑输出状态

与上题相似，这个问题输出条件也是求dp数组中大的数。

第五步：考虑是否可以优化

这个题目只需要一次遍历就能求出连续的序列，所以在时间上已经没有可以优化的余地了，空间上来看的话也是一维数组，并没有优化余地。

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