算法之动态规划（二）

动态规划：

一般步骤

1. 定义状态，简单的一般是一维数组，复杂的是二维三维数组。
2. 定义状态转移方程，这一步是处理子问题的通用解。
3. 分析不能满足状态转移方程的特殊情况，类似剪枝的功能
4. 得到最终解。

例题

1. 最小路径和

Leetcode 64

第64题：最小路径和
给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例:

输入:
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

问题分析

1. 定义状态 dp[i] [j] 是 包含i行j列的最小路径
2. 这个路径由dp[i-1] [j] 或者dp[i] [j-1] 再加上i ，j的值而得来。所以dp[i] [j] = min(dp[i-1] [j],dp[i] [j-1]) + grid[i] [j]
3. 特殊情况为考虑到左边界没有j-1，第一行只能通过j-1来，i == 0 and j == 0 不处理。
4. 最终结果为dp[-1] [-1]

from typing import List


class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        if not grid:
            return 0
        dp = [[0] * len(grid[0]) for _ in range(len(grid))]
        dp[0][0] = grid[0][0]
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if i == 0 and j == 0:
                    continue
                if j == 0:
                    dp[i][j] = dp[i - 1][j] + grid[i][j]
                elif i == 0:
                    dp[i][j] = dp[i][j - 1] + grid[i][j]
                else:
                    dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]
        return dp[-1][-1]

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        m,n=len(grid),len(grid[0])
        dp=[[0]*n for _ in range(m)]
        dp[0][0]=grid[0][0]
        for i in range(1,m):
            dp[i][0]=dp[i-1][0]+grid[i][0]
        for j in range(1,n):
            dp[0][j]=dp[0][j-1]+grid[0][j]
        for i in range(1,m):
            for j in range(1,n):
                dp[i][j]=grid[i][j] + min(dp[i-1][j],dp[i][j-1])
        return dp[-1][-1]

打家劫舍

Leetcode 198

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

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

示例 1:

输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
	 偷窃到的最高金额 = 1 + 3 = 4 。

示例 2:

输入: [2,7,9,3,1]
输出: 12
解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。

问题分析

1. Dp[i] 表示前i个家能获得的最大收益。
2. 由于不能连续偷，所以dp[i]=max（dp[i-2] +nums[i],dp[-1]) ,状态转移方程为前i-2个没有偷的数加上现在偷的数，与i-1偷的数比较大小。也就是 目前的金额与前两个房子的状态可以得到。
3. 这步暂没有想到。
4. 结果max(dp)

from typing import List


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