【算法】DP问题——状态机模型

基本内容

• 入门例子 Leetcode 3259. 超级饮料的最大强化能量

题目简述：有两个数组energyDrinkA和energyDrinkB，分别代表两种能量饮料每小时提供的能量，在接下来的n小时内选择饮用这两种饮料中的一种，以最大化总能量。但是，如果你从一个饮料切换到另一个，你需要等待一个小时才能开始获得能量。

输入：energyDrinkA = [4, 1, 1], energyDrinkB = [3, 1, 1]

输出：7

• 基本思想

将可能存在的 K 个状态在原来 dp 数组扩展为二维数组 DP[N] → DP[N][K]，以入门例子为例，第一个状态是第 i 个小时喝的饮料为 A ，第二个状态是第 i 个小时喝的饮料为 B，每一个状态都可能来自于不同的状态，切换状态的第 i 个小时不摄入能量。

​ 假设第 i 时刻的状态为 B ，则可能有两种状态切换：

​ ① A → B：第 i 时刻无法摄入能量

​ ② B → B：摄入 B

• 解题代码

def maxEnergy(energyDrinkA, energyDrinkB):
    N = len(energyDrinkA)
    dp = [[0] * 2 for _ in range(N)] # 存储第i时刻喝A或者B饮料两种状态的最大值
    dp[0][0] = energyDrinkA[0]
    dp[0][1] = energyDrinkB[0]
    
    for i in range(1, n):
        # 第i时刻饮用 A
        dp[i][0] = max(dp[i - 1][0] + energyDrinkA[i],  # 继续喝 A
                       dp[i - 1][1])                  # 切换到 A，这一小时内不摄入内量
        
        # 第i时刻饮用 B
        dp[i][1] = max(dp[i - 1][1] + energyDrinkB[i],  # 继续喝 B
                       dp[i - 1][0])                  # 切换到 B，上一小时喝 A
    return max(dp[n - 1][0], dp[n - 1][1])

• 总结

这种题目有 K 个状态就是建立 DP[N][K] 的二维DP数组，若题目有三种饮料就是DP[N][3]，在没理解到使用状态压缩DP时，我尝试用一维数组建立，遍历可能存在的不同状态：① 继续喝同样的饮料；② 切换饮料；③ 可能存在一种情况: energyDrinkA = [3, 5, 3], energyDrinkB = [3, 4, 5] , 这种情况下只使用 ①、②状态都无法满足最优解。

题目

1. Leetcode 198. 打家劫舍

该题第 i 家房屋的状态划分为偷与没偷，对应了入门例子的第 i 个时间的状态是喝 A 饮料还是 B 饮料

class Solution:
    def rob(self, nums: List[int]) -> int:
        # 第一个数组存储第i次没偷， 第二个数组存储第i次偷了
        dp = [[0 for _ in range(len(nums))] for _ in range(2)] 
        dp[1][0] = nums[0] 
        for i in range(1, len(nums)):
            dp[0][i] = max(dp[0][i-1], dp[1][i-1])
            dp[1][i] = dp[0][i-1] + nums[i] #第i家偷了，上一家指定没偷
        return max(max(dp[0]), max(dp[1]))

2. Leetcode 213. 打家劫舍 II

与上一题目相比，需要判断最后一家和第一家是否同时偷取，如果偷了第一家，最后一家则不能偷取，反之也然。原来的题目在第 i 个房屋对应着两个状态，根据两个状态是无法判断是否偷取第一家，因为每个状态都可以由第 i-1 时刻的不同状态切换。因此，可以额外加入两个状态对应着在第一家不偷取的前提下第 i 个房屋的两个状态。

$$\{\begin{array}{l}第一家偷\{\begin{array}{l}第i家偷\\ 第i家不偷\end{array}\\ 第一家不偷\{\begin{array}{l}第i家偷\\ 第i家不偷\end{array}\end{array}$$

class Solution:
    def rob(self, nums: List[int]) -> int:
        if not nums:
            return 0
        if len(nums) == 1:
            return nums[0]
        n = len(nums)
        dp = [[0] * n for _ in range(4)]
        dp[1][0] = nums[0]
        for i in range(1, n):
            if i < n - 1: 
                dp[0][i] = max(dp[0][i-1], dp[1][i-1]) 
                dp[1][i] = dp[0][i-1] + nums[i]
                dp[2][i] = max(dp[2][i-1], dp[3][i-1])
                dp[3][i] = dp[2][i-1] + nums[i]
            else:  
                dp[0][i] = max(dp[0][i-1], dp[1][i-1])
                dp[1][i] = dp[0][i-1] # 最后一家不偷，不需要加上nums[i]
                dp[2][i] = max(dp[2][i-1], dp[3][i-1])
                dp[3][i] = dp[2][i-1] + nums[i]  

        return max(dp[0][n-1], dp[1][n-1], dp[2][n-1], dp[3][n-1])