动态规划总结(更新)

最新推荐文章于 2022-11-05 16:15:45 发布

Better-1

最新推荐文章于 2022-11-05 16:15:45 发布

阅读量239

点赞数

分类专栏：剑指

本文链接：https://blog.csdn.net/caihuanqia/article/details/105869651

版权

剑指专栏收录该内容

192 篇文章 3 订阅

订阅专栏

参考 labuladong
Dynamic programming，简称DP。例如背包问题和斐波那契数列等，剪绳子问题(写过)。
核心是分治思想，通过子问题求之：划分状态-状态表示-状态转移-确定边界。
如斐波那契数列： F[I] = F[I-1] + F[I-2]：自底向上。
主要包括自顶向下(又叫记忆化搜索)和自底向上两种思路。

首先，动态规划问题的一般形式就是求最值。
既然是要求最值，核心问题是什么呢？求解动态规划的核心问题是穷举。因为要求最值，肯定要把所有可行的答案穷举出来，然后在其中找最值呗。

动态规划的穷举有点特别，因为这类问题存在**「重叠子问题」，如果暴力穷举的话效率会极其低下，所以需要「备忘录」–字典/哈希表**或者「DP table」来优化穷举过程，避免不必要的计算。

动态规划问题一定会具备「最优子结构」，才能通过子问题的最值得到原问题的最值。
只有列出正确的「状态转移方程」才能正确地穷举。

动态规划的三要素：重叠子问题、最优子结构、状态转移方程 写出状态转移方程是最困难的，这也就是为什么很多朋友觉得动态规划问题困难的原因

状态转移方程：

明确 base case -> 明确「状态」-> 明确「选择」 -> 定义 dp 数组/函数的含义

题目的类型主要包含以下几个方面：
子序列类型：最长公共子序列；最大子数组
背包类型：0-1背包；完全背包；
贪心类型：区间调度

斐波纳契数列

# 初始化 base case
dp[0][0][...] = base
# 进行状态转移
for 状态1 in 状态1的所有取值：
    for 状态2 in 状态2的所有取值：
        for ...
            dp[状态1][状态2][...] = 求最值(选择1，选择2...)

首先是斐波那契数列：
数学规律就是： f(n) = f(n-1) + f(n-2)
暴力求解：

def dongtai(n):
	if n == 1:
		return 1
	if n == 2:
		return 2
	return dongtai(n-1) + dongtai(n-2)

问题是有很多的重叠子问题： f(10) = f(9) + f(8)，等式右边两个在求解的时候，必然有很多重复的，比如f(9) = f(8) + f(7)；8又出现了！

所以这里如果引入备忘录–字典：可以解决这个问题。

record = {}
def dongtai(n):
	if n == 1:
		return 1
	if n == 2:
		return 2
	if n in record:
		return record[n]
	record[n] = dongtai(n-1) + dongtai(n-2)
	return record[n]

但是，上述主要的思路还是自顶向下的思路，也可以换成自底向上的思路，就是用for循环，从低层考虑起来，就可以避免这个问题。递归树：
在这里插入图片描述


def dongtai(n):
	dp = [0] * n
	for i in range(n):
		if i == 1:
			dp[0] = 1
		elif i == 2:
			dp[1] = 2
		else:
			dp[i] = dp[i-1] + dp[i-2]

def dongtai(n):
	for i in range(n):
		if i == 1:
			a = 1
		elif i == 2:
			b = 2
		else:
			c = a + b
			a = b
			b = c

零钱的拼凑问题无非就是拼成的组合数 / 最少使用多少枚硬币拼成~ 这些硬币都是无限的。

具体的转移公式很相似，区别在初始化的第0列需要注意！！另一个注意点是因为是无限的，所以每次操作主要在本行也就是当前选择的硬币上操作 ~ dp[i][j] = dp[i][j-coins[i-1]] + dp[i-1][j]
这种题根本不需要考虑重复的问题，因为本来就是不会回头的，并且原本就是无限的。不会回头指的是比如 1 2 3 三种面额，当考虑到3这种面额的时候，不会再回过头取再考虑2的情况，那些情况已经是已有的组合了。

如果是一堆硬币，不是无限的，那么怎么操作~~ 首先排序。求组合数
dp[i][j] = dp[i-1][j] + dp[i-1][j-nums[i]] === 感觉没什么意义~~

零钱兑换II

在这里插入图片描述


class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        if not amount:  ###注意，amount为0的情况下是1，全部选择数为0也是一个选择
            return 1
        if not coins:
            return 0
        dp = []
        for i in range(1+len(coins)):
            dp.append([0]*(amount+1)) # 只要满足了减到0，那么就是1了，在1的基础上，dp[1] = dp[0] 
        for i in range(1+len(coins)):
            dp[i][0] = 1   

        for i in range(1, len(coins)+1):
            for j in range(1, amount+1): # 二维两者可以颠倒，但是一维不行！！
                if j - coins[i-1] >= 0:
                    dp[i][j] = dp[i][j-coins[i-1]] + dp[i-1][j]  ## 之所以是dp[i][j-conins[i-1]]是因为第i枚是可以重复使用的。
                else:
                    dp[i][j] = dp[i-1][j]
        
        return dp[-1][-1]

凑零钱问题

给你 k 种面值的硬币，面值分别为 c1, c2 … ck，每种硬币的数量无限，再给一个总金额 amount，问你最少需要几枚硬币凑出这个金额，如果不可能凑出，算法返回 -1 。
比如说 k = 3，面值分别为 1，2，5，总金额 amount = 11。那么最少需要 3 枚硬币凑出，即 11 = 5 + 5 + 1。

如何列出正确的状态转移方程？
1、确定 base case，这个很简单，显然目标金额 amount 为 0 时算法返回 0，因为不需要任何硬币就已经凑出目标金额了。
2、确定「状态」，也就是原问题和子问题中会变化的变量。由于硬币数量无限，硬币的面额也是题目给定的，只有目标金额会不断地向 base case 靠近，所以唯一的「状态」就是目标金额 amount。
3、确定「选择」，也就是导致「状态」产生变化的行为。目标金额为什么变化呢，因为你在选择硬币，你每选择一枚硬币，就相当于减少了目标金额。所以说所有硬币的面值，就是你的「选择」。
4、明确 dp 函数/数组的定义。

一般来说函数的参数就是状态转移中会变化的量，也就是上面说到的「状态」；函数的返回值就是题目要求我们计算的量。就本题来说，状态只有一个，即「目标金额」，题目要求我们计算凑出目标金额所需的最少硬币数量。所以我们可以这样定义 dp 函数：dp(n) 的定义：输入一个目标金额 n，返回凑出目标金额 n 的最少硬币数量。

状态转移方程
在这里插入图片描述
其实，求价值为n的解相当于求价值为n-coin（某一价值）的解加上1。
所以转移方程就是dp[n] = min(dp[n-coin] + 1)----coin属于所有选择中的某一个。

一个好的地方是往大了就是刚好amount+1初始化，因为后续运算用的是min。

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        n = len(coins)
        dp = []
        for i in range(n+1):
            dp.append([amount+1]*(amount+1))
        for i in range(n+1):
            dp[i][0] = 0
        for i in range(1, n+1):
            for j in range(1, amount+1):
                if j - coins[i-1] >= 0:
                    dp[i][j] = min(dp[i][j-coins[i-1]]+1, dp[i-1][j])
                else:
                    dp[i][j] = dp[i-1][j]
        if dp[-1][-1] == amount+1:
            return -1
        return dp[-1][-1]

def coin(coins, n):
	dp = [0] * n
	dp[0] = 0
	res = "-INF"
	for i in coins:
		res = min(res, dp[n-i]-1)
	dp
		


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

    def dp(n):
        # base case
        if n == 0: return 0
        if n < 0: return -1
        # 求最小值，所以初始化为正无穷
        res = float('INF')
        for coin in coins:
            subproblem = dp(n - coin)
            # 子问题无解，跳过
            if subproblem == -1: continue
            res = min(res, 1 + subproblem)

        return res if res != float('INF') else -1

    return dp(amount)

64. 最小路径和 ----以及一个列表的坑

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。

这里给出自顶向下和自底向上两种，自顶向下较差，这里被一个列表的浅拷贝绊倒了。
在这里插入图片描述
复盘：。。。其实很简单~~

class Solution:
    def minPathSum(self, grid):

        if not grid:
            return 0
        
        m = len(grid)
        n = len(grid[0])
        dp = []
        for i in range(m):
            dp.append([0]*n)

        for i in range(m):
            for j in range(n):
                if i == 0:
                    dp[i][j] = dp[i][j-1] + grid[i][j]
                elif j == 0:
                    dp[i][j] = dp[i-1][j] + 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 = len(grid)
        n = len(grid[-1])

        record = []
        # record = [[-1]*n]*m       ---- 浅拷贝，每一个的变化会带动一列的变化。---所以会导致清除已变化的失败。
        for i in range(m):
            record.append([-1]*n)

        def dp(i, j):
            if record[i][j] != -1:      
                return record[i][j]
            if i == 0 and j == 0:
                record[i][j] = grid[0][0]
                return record[i][j]
            if i == 0:
                record[i][j] = dp(i,j-1) + grid[i][j]
                return record[i][j]
            elif j == 0:
                record[i][j] = dp(i-1,j) + grid[i][j]
                # ceshi.add((i, j))
                return record[i][j]
            elif i <= m - 1 and j <= n - 1:
                res = dp(i-1,j) + grid[i][j]
                record[i][j] = min(dp(i, j-1) + grid[i][j], res)
                return record[i][j]
                
        dp(m-1, n-1)
        return record[-1][-1]

自底向上

class Solution:   # 注意 自底向上，其实底部都已经安排好，不用担心。验证即可。
    def minPathSum(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])
        record = [[0]*n]*m

        for i in range(m):
            for j in range(n):
                if i == 0 and j == 0 :
                    record[i][j] = grid[i][j]
                elif i == 0:
                    record[i][j] = record[i][j-1] + grid[i][j]
                elif j == 0:
                    record[i][j] = record[i-1][j] + grid[i][j]
                else:
                    res = record[i-1][j] + grid[i][j]
                    record[i][j] = min(record[i][j-1] + grid[i][j], res)

        return record[-1][-1]

Better-1

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
动态规划总结(更新)

Dynamic programming，简称DP。例如背包问题和斐波那契数列等，剪绳子问题(写过)。核心是分治思想，通过子问题求之：划分状态-状态表示-状态转移-确定边界。如斐波那契数列： F[I] = F[I-1] + F[I-2]：自底向上。主要包括自顶向下(又叫记忆化搜索)和自底向上两种思路。...
复制链接

扫一扫