秒懂动态规划，从经典问题到算法解题

闲谈

2023-08-31 06:10:04

动态规划：从入门到精通的经典问题剖析

动态规划 是一种强大的算法设计方法，它擅长解决具有最优子结构、重叠子问题和最优解存储特点的复杂问题。本博客将带你踏上动态规划的入门之旅，通过经典问题的剖析，让你从零基础轻松掌握动态规划的精髓。

最长递增子序列问题

问题给定一个序列，求出该序列中最长的递增子序列的长度。

动态规划解法：

定义状态： dp[i]表示以第i个元素结尾的最长递增子序列的长度。
状态转移方程： dp[i] = max{dp[j] + 1 | j < i 且 arr[j] < arr[i]}
边界条件： dp[1] = 1

示例代码：

def longest_increasing_subsequence(arr):
    n = len(arr)
    dp = [1] * n

    for i in range(1, n):
        for j in range(i):
            if arr[j] < arr[i]:
                dp[i] = max(dp[i], dp[j] + 1)

    return max(dp)

找零钱问题

问题： 给定一组硬币的面值和一个目标金额，求出有多少种方法可以用这些硬币组成该目标金额。

动态规划解法：

定义状态： dp[i][j]表示用前i种硬币组成金额j的方法数。
状态转移方程： dp[i][j] = dp[i-1][j] + dp[i][j - 面值(i)]
边界条件： dp[0][0] = 1

示例代码：

def change_count(coins, target):
    n = len(coins)
    dp = [[0] * (target + 1) for _ in range(n + 1)]

    for i in range(n + 1):
        dp[i][0] = 1

    for i in range(1, n + 1):
        for j in range(target + 1):
            if coins[i-1] <= j:
                dp[i][j] = dp[i-1][j] + dp[i][j - coins[i-1]]

    return dp[n][target]

背包问题

问题： 给定一组物品的重量、价值和一个背包的容量，求出在不超过背包容量的情况下，将物品装入背包的最大价值。

动态规划解法：

定义状态： dp[i][j]表示考虑前i个物品，背包容量为j时，装入背包的最大价值。
状态转移方程： dp[i][j] = max{dp[i-1][j], dp[i-1][j - 重量(i)] + 价值(i)}
边界条件： dp[0][0] = 0

示例代码：

def knapsack(weights, values, capacity):
    n = len(weights)
    dp = [[0] * (capacity + 1) for _ in range(n + 1)]

    for i in range(1, n + 1):
        for j in range(capacity + 1):
            if weights[i-1] <= j:
                dp[i][j] = max(dp[i-1][j], dp[i-1][j - weights[i-1]] + values[i-1])

    return dp[n][capacity]

旅行者问题

问题描述： 给定一个城市列表和一个距离矩阵，求出从起点城市到终点城市的最小距离。

动态规划解法：

定义状态： dp[i][j]表示从起点城市到第i个城市的最小距离。
状态转移方程： dp[i][j] = min{dp[i-1][k] + 距离(k, j)}
边界条件： dp[1][1] = 0

示例代码：

def traveling_salesman(distances, start, end):
    n = len(distances)
    dp = [[float('inf')] * n for _ in range(1 << n)]
    dp[1 << start][start] = 0

    for mask in range(1 << n):
        for i in range(n):
            if mask & (1 << i):
                for j in range(n):
                    if mask & (1 << j) and i != j:
                        dp[mask | (1 << j)][j] = min(dp[mask | (1 << j)][j], dp[mask][i] + distances[i][j])

    return dp[(1 << n) - 1][end]