14 动态规划

• 要点
  • 递归 + 记忆化 --> 递推
  • 状态的定义： opt[n], dp[n], fib[n]
  • 状态转移方程：opt[n] = best_of(opt[n-1], opt[n-2], … )
  • 最优子结构
• 动态规划与回溯与贪心算法对比
  • 回溯（递归） -- 存在重复计算
  • 贪心算法 -- 永远局部最优
  • 动态规划 -- 记录局部最优子结构 / 多种记录值
• leetcode 算法题
  • https://leetcode.com/problems/climbing-stairs/description/

class Solution:

    def climbStairs(self, n: int) -> int:

        y = x = 1

        for _ in range(1, n):

            y, x = x + y, y

        return y

• https://leetcode.com/problems/triangle/description/

class Solution:

    def minimumTotal(self, triangle: List[List[int]]) -> int:

        mini = triangle[-1]

        length = len(triangle[-1])

        for i in range(length-2, -1, -1):

            for j in range(i+1):

                mini[j] = triangle[i][j] + min(mini[j], mini[j+1])

        return mini[0] 

• https://leetcode.com/problems/maximum-product-subarray/submissions/

# 动态规划

class Solution:

    def maxProduct(self, nums):

        length = len(nums)

        if length == 1:

            return nums[0]

        res = nums[0]

        dp = [nums[0] for _ in range(2)]

        for i in range(1, length):

            dp = [j * nums[i] for j in dp]

            dp = [max(dp[0], dp[1], nums[i]), min(dp[0], dp[1], nums[i])]

            res = max(res, dp[0])

        return res

   

   

# 递归

class Solution:

    def maxProduct(self, nums):

        def recursion(i):

            if i == 0:

                return nums[i], nums[i], nums[i]

            maxi, mini, res = recursion(i-1)

            maxi, mini = maxi * nums[i], mini * nums[i]

            return max(maxi, mini, nums[i]), min(maxi, mini, nums[i]), max(maxi, mini, res, nums[i])

   

        return recursion(len(nums) - 1)[2]

• 股票买卖问题
  • https://leetcode.com/problems/best-time-to-buy-and-sell-stock/#/description

import sys

class Solution:

    def maxProfit(self, prices: List[int]) -> int:

        length = len(prices)

        if length == 1: return 0

        res = 0

        minprice = sys.maxsize

        for i in range(length):

                if prices[i] < minprice:

                    minprice = prices[i]

                profit = prices[i] - minprice

                if profit > res:

                    res = profit

        return res 

• https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/submissions/

# Greedy

class Solution:

    def maxProfit(self, prices: List[int]) -> int:

        if len(prices) < 2:

            return 0

        profit = 0

        for index in range(1, len(prices)):

            day_profit = prices[index] - prices[index-1]

            if day_profit > 0:

                profit += day_profit

        return profit

• https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/

# Greedy

class Solution:

    def maxProfit(self, prices: List[int]) -> int:

        if len(prices) < 2:

            return 0

        profit = 0

        for index in range(1, len(prices)):

            day_profit = prices[index] - prices[index-1]

            if day_profit > 0:

                profit += day_profit

        return profit

• https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/

from sys import maxsize

   

   

class Solution:

    def maxProfit(self, k: int, prices: List[int]) -> int:

        length = len(prices)

        if length < 2 or k < 1:

            return 0

        res = 0

        if k >= length / 2:

            for i in range(length - 1):

                res += max(prices[i + 1] - prices[i], 0)

            return res

   

        profit = [[[-maxsize for _ in range(2)] for _ in range(k + 1)] for _ in range(2)]

        profit[0][0] = [0, -prices[0]]

        pre_index, cur_index = 0, 1

        res = 0

        for i in range(1, length):

            profit[cur_index][0][0] = 0

            profit[cur_index][0][1] = max(profit[pre_index][0][1], -prices[i])

   

            for count in range(1, min(k + 1, i // 2 + 2)):

   

                profit[cur_index][count][0] = max(profit[pre_index][count][0], profit[pre_index][count - 1][1] +

                                                 prices[i])

                profit[cur_index][count][1] = max(profit[pre_index][count][1], profit[pre_index][count][0] -

                                                 prices[i])

                res = max(res, profit[cur_index][count][0])

   

            cur_index, pre_index = (cur_index + 1) % 2, (pre_index + 1) % 2

   

        return res 

   

• https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/submissions/

from sys import maxsize

class Solution:

    def maxProfit(self, prices):

        length = len(prices)

        if length < 2:

            return 0

        hold, nohold_cold, nohold_nocold = -prices[0], -maxsize, 0

        res = 0

        for i in range(1, length):

            hold = max(nohold_nocold - prices[i], hold)

            nohold_nocold = max(nohold_cold, nohold_nocold)

            nohold_cold = hold + prices[i]

            res = max(res, nohold_cold, nohold_nocold)

        return res

• https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/

class Solution:

    def maxProfit(self, prices: List[int], fee: int) -> int:

        length = len(prices)

        if length < 2:

            return 0

        hold, no_hold = -prices[0], 0

        res = 0

        for i in range(1, length):

            hold = max(hold, no_hold - prices[i])

            no_hold = max(no_hold, hold + prices[i] - fee)

            res = max(res, no_hold)

        return res 

• https://leetcode.com/problems/longest-increasing-subsequence/

# 动态规划

class Solution1:

    def lengthOfLIS(self, nums: List[int]) -> int:

        if not nums: return 0

        length = len(nums)

        if length < 2: return 1

        res = [1] * length

        for i in range(1, length):

            for j in range(i):

                if nums[j] < nums[i]:

                    res[i] = max(res[i], res[j] + 1)

                    

        return max(res)

        

# 二分查找

class Solution:

    def lengthOfLIS(self, nums):

        if not nums: return 0

        if len(nums) < 2: return 1

        res = [nums[0]]

        for num in nums[1:]:

            if num > res[-1]:

                res.append(num)

            else:

                index = self.binary_search(res, num)

                res[index] = num

        return len(res)

   

    @staticmethod

    def binary_search(nums, num):

        left = 0

        right = len(nums) - 1

        middle = 0

        while left < right:

            middle = (left + right) // 2

            if nums[middle] == num:

                return middle

            elif nums[middle] < num:

                left = middle + 1

            else:

                right = middle

   

        return right# 确保所替换的值一定不小于 num

  

• https://leetcode.com/problems/coin-change/

class Solution:

    def coinChange(self, coins: List[int], amount: int) -> int:

        res = [amount + 1] * (amount + 1)

        res[0] = 0

        for i in range(1, amount+1):

            for j in coins:

                if i - j >= 0:

                    res[i] = min(res[i], res[i - j] + 1)

        return res[-1] if res[-1] < amount + 1 else -1 

• https://leetcode.com/problems/edit-distance/

class Solution:

    def minDistance(self, word1: str, word2: str) -> int:

        m, n = len(word1) + 1, len(word2) + 1

        dp = [[0 for _ in range(n)] for _ in range(m)]

        for i in range(m):

            dp[i][0] = i

        for j in range(n):

            dp[0][j] = j

        for i in range(1, m):

            for j in range(1, n):

                dp[i][j] = min(dp[i-1][j-1] + (0 if word1[i-1] == word2[j-1] else 1),

                             dp[i][j-1] + 1,

                             dp[i-1][j] + 1)

        return dp[-1][-1]