Leetcode 动态规划

zhen24

已于 2024-03-24 12:29:45 修改

阅读量65

点赞数

分类专栏：数据结构和算法每周算法 Python 文章标签： leetcode 动态规划算法

于 2022-08-24 14:21:17 首次发布

本文链接：https://blog.csdn.net/weixin_43692357/article/details/126503542

版权

Python 同时被 3 个专栏收录

47 篇文章 0 订阅

订阅专栏

数据结构和算法

15 篇文章 0 订阅

订阅专栏

每周算法

5 篇文章 0 订阅

订阅专栏

初体验

动态规划一般分为一维、二维、多维（使用状态压缩），对应形式为 dp(i)、dp(i)(j)、二进制dp(i)(j)。

动态规划做题步骤:
    明确 dp(i)应该表示什么（二维情况：dp(i)(j）；
    根据 dp(i) 和 dp(i-1) 的关系得出状态转移方程；
    确定初始条件，如 dp(0)。

一. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。	
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。

示例 1：
	输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶
示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1.  1 阶 + 1 阶 + 1 阶
2.  1 阶 + 2 阶
3.  2 阶 + 1 阶

分析:

    假定n=10,首先考虑最后一步的情况,要么从第九级台阶再走一级到第十级,要么从第八级台阶走两级到第十级,因而,要想到达第十级台阶,
最后一步一定是从第八级或者第九级台阶开始.也就是说已知从地面到第八级台阶一共有X种走法,从地面到第九级台阶一共有Y种走法,
那么从地面到第十级台阶一共有X+Y种走法.
即F(10)=F(9)+F(8)
    分析到这里,动态规划的三要素出来了.
        边界:F(1)=1,F(2)=2
        最优子结构:F(10)的最优子结构即F(9)和F(8)
        状态转移函数:F(n)=F(n-1)+F(n-2)

解答:

class Solution(object):
    def climbStairs(self, n):
        if n<=2:
           return n
        a,b=1,2　　#这是边界,而不是题目中所提的1步,2步   
        # tip 如果可以1 2 3 步   则为a,b,c=1,2,4
        for i in range(3,n+1):
            a,b=b,a+b　　　　　　　　　#最优子结构
        return b

二.最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例:
输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

解答:

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        for i in range(1,len(nums)):
            nums[i]=nums[i]+max(nums[i-1],0)
        return max(nums)

三.打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，
如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，
能够偷窃到的最高金额。

示例 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 。

解答:

公式:  dp[k] = max(dp[k - 2] + num, dp[k - 1])   # k处的值为num
class Solution:
    def rob(self, nums):
        if len(nums) == 0:
            return 0
        n = len(nums)
        dp = [0,0]
        dp[1] = nums[0]
        for i in range(2, n + 2):
            dp.append(max(dp[i - 2] + nums[i - 1], dp[i - 1]))
        return max(dp)

进阶解答:

class Solution:
    def rob(self, nums):
        prev = 0
        curr = 0

        # 每次循环，计算“偷到当前房子为止的最大金额”
        for i in nums:
            # 循环开始时，curr 表示 dp[k-1]，prev 表示 dp[k-2]
            # dp[k] = max{ dp[k-1], dp[k-2] + i }
            prev, curr = curr, max(curr, prev + i)
            # 循环结束时，curr 表示 dp[k]，prev 表示 dp[k-1]

        return curr

四.不同的路径II

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
网格中的障碍物和空位置分别用 1 和 0 来表示。
说明：m 和 n 的值均不超过 100。

示例 1:
输入:
[
  [0,0,0],
  [0,1,0],
  [0,0,0]
]
输出: 2
解释:
3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

思路:

如为3*3的矩形,f(中)=f(上)+f(左))

解答:

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid):
        m = len(obstacleGrid)
        n = len(obstacleGrid[0])
        for i in range(m):
            for j in range(n):
                temp = obstacleGrid[i][j]
                if temp == 0:
                    if i == j == 0:
                        obstacleGrid[i][j] = 1
                    else:
                        left = obstacleGrid[i][j - 1] if j > 0 else 0
                        up = obstacleGrid[i - 1][j] if i > 0 else 0
                        obstacleGrid[i][j] = left + up
                else:
                    obstacleGrid[i][j] = 0
        print(obstacleGrid)
        return obstacleGrid[-1][-1]