为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 DP优化入门：轻松掌握动态规划技巧

DP优化入门：轻松掌握动态规划技巧

标签：
算法与数据结构

本文介绍了动态规划的基础概念，包括其核心思想和适用场景，并详细讲解了几个经典的动态规划问题及其解法。此外，文章还探讨了几种DP优化入门的方法和技术，帮助读者提高算法效率。

动态规划是一种在计算机科学和数学中常用的算法技术，用于解决优化问题和寻找最优化解。动态规划通过将复杂的问题分解为一个或多个相对简单的子问题来求解，避免了重复计算，提高了算法效率。动态规划的核心在于使用递归和记忆化技术，通过存储子问题的解来加速后续计算过程。

动态规划的核心思想是将一个复杂的问题分解成多个简单的子问题，并通过保存子问题的解来避免重复计算。具体来说，动态规划涉及以下步骤：

  1. 定义状态：确定问题的状态，例如在0/1背包问题中，状态可以表示为前i个物品放入容量为j的背包中的最优解。
  2. 状态转移：定义状态转移方程，即如何从一个状态转移到另一个状态。例如，0/1背包问题的状态转移方程可以是dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i])。
  3. 初始化状态：通常需要初始化一些边界条件或特殊情况下的状态值。
  4. 计算最优解：通过递归或迭代的方式计算出所有状态的最优解。

动态规划适用于具有以下特征的问题：

  1. 最优子结构：问题的最优解可以通过其子问题的最优解来构造。
  2. 重叠子问题：问题可以分解成若干个子问题，并且这些子问题之间存在重叠。
  3. 无后效性：当前状态的决策仅依赖于之前的状态，而不依赖于未来的状态。

最长递增子序列

最长递增子序列（Longest Increasing Subsequence，LIS）问题是动态规划中的经典问题之一。给定一个序列，找到最长的递增子序列。

状态定义

  • 设dp[i]表示以第i个元素结尾的最长递增子序列的长度。

状态转移方程

  • 对于每个元素nums[i]，我们需要遍历前面的所有元素nums[j]，如果nums[j] < nums[i]，则dp[i] = max(dp[i], dp[j] + 1)。

初始化

  • 初始化时，每个元素的最长递增子序列的长度都为1。

代码实现

def longest_increasing_subsequence(nums):
    if not nums:
        return 0

    dp = [1] * len(nums)  # 初始化dp数组
    for i in range(len(nums)):
        for j in range(i):
            if nums[j] < nums[i]:
                dp[i] = max(dp[i], dp[j] + 1)

    return max(dp)

# 示例
nums = [10, 9, 2, 5, 3, 7, 101, 18]
print(longest_increasing_subsequence(nums))

0/1背包问题

0/1背包问题是一个经典的动态规划问题。给定n个物品的重量和价值，以及一个容量为W的背包，选择若干物品放入背包，使得总重量不超过背包容量且总价值最大。

状态定义

  • 设dp[i][j]表示前i个物品放入容量为j的背包中的最大价值。

状态转移方程

  • 如果不选择第i个物品，则dp[i][j] = dp[i-1][j]。
  • 如果选择第i个物品，则dp[i][j] = dp[i-1][j-w[i]] + v[i]，前提是j >= w[i]。
  • 取两种情况的最大值作为dp[i][j]的值。

初始化

  • 初始化时，dp[0][j]表示不放入任何物品时的最大价值，即为0。

代码实现

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

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

    return dp[n][capacity]

# 示例
weights = [1, 2, 3]
values = [6, 10, 12]
capacity = 5
print(knapsack(weights, values, capacity))

最短路径问题

最短路径问题是指在图中找到从一个顶点到另一个顶点的最短路径。Dijkstra算法是解决这个问题的常用动态规划方法之一。

状态定义

  • 设dp[u]表示从起点到顶点u的最短路径长度。

状态转移方程

  • 对于每个顶点u，考虑所有与其相邻的顶点v，dp[v] = min(dp[v], dp[u] + w(u, v)，其中w(u, v)表示边(u, v)的权重。

初始化

  • 初始化时，起点的最短路径长度为0，其他顶点的最短路径长度设为无穷大。

代码实现

import heapq

def dijkstra(graph, start):
    n = len(graph)
    distances = [float('inf')] * n
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)
        if current_distance > distances[current_node]:
            continue
        for neighbor, weight in graph[current_node]:
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# 示例
graph = {
    0: [(1, 1), (2, 4)],
    1: [(2, 1), (3, 2)],
    2: [(3, 1)],
    3: []
}
print(dijkstra(graph, 0))

动态规划的优化策略

状态压缩

状态压缩是一种用于减少动态规划中状态空间大小的技术，常用在状态较多且状态之间存在冗余的情况下。通过合理地利用位运算，可以将多个状态压缩到一个整数中，从而减少内存使用和计算复杂度。

示例代码

def knapsack_with_bitmasking(n, weights, values, capacity):
    dp = [0] * (1 << n)
    for mask in range(1 << n):
        for i in range(n):
            if mask & (1 << i):
                new_mask = mask ^ (1 << i)
                dp[mask] = max(dp[mask], dp[new_mask] + values[i])
    return max(dp)

# 示例
weights = [1, 2, 3]
values = [6, 10, 12]
capacity = 5
print(knapsack_with_bitmasking(len(weights), weights, values, capacity))

贪心优化

贪心优化是通过贪心策略来优化动态规划的过程，使得某些子问题的解可以直接采用贪心方法求解，而不需要进行完整的动态规划计算。

示例代码

def knapsack_greedy(weights, values, capacity):
    items = sorted(zip(weights, values), key=lambda x: x[1] / x[0], reverse=True)
    total_value = 0
    for weight, value in items:
        if weight <= capacity:
            total_value += value
            capacity -= weight
        else:
            total_value += (capacity / weight) * value
            break
    return total_value

# 示例
weights = [1, 2, 3]
values = [6, 10, 12]
capacity = 5
print(knapsack_greedy(weights, values, capacity))

数学优化

数学优化是一种通过数学工具来优化动态规划的过程，例如利用矩阵快速幂、线性代数等方法来减少计算复杂度。

示例代码

def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    matrix = [[1, 1], [1, 0]]
    result = matrix_power(matrix, n-1)
    return result[0][0]

def matrix_power(matrix, n):
    if n == 1:
        return matrix
    half = matrix_power(matrix, n // 2)
    result = matrix_multiply(half, half)
    if n % 2:
        result = matrix_multiply(result, matrix)
    return result

def matrix_multiply(a, b):
    return [
        [a[0][0] * b[0][0] + a[0][1] * b[1][0], a[0][0] * b[0][1] + a[0][1] * b[1][1]],
        [a[1][0] * b[0][0] + a[1][1] * b[1][0], a[1][0] * b[0][1] + a[1][1] * b[1][1]]
    ]

# 示例
print(fibonacci(10))

动态规划的实现技巧

状态转移方程的推导

状态转移方程是动态规划的核心，它定义了如何从一个状态转移到另一个状态。推导状态转移方程的关键在于明确各个状态之间的关系，并通过合理的选择和计算来得出最优解。

示例代码

def longest_increasing_subsequence(nums):
    dp = [1] * len(nums)
    for i in range(1, len(nums)):
        for j in range(i):
            if nums[j] < nums[i]:
                dp[i] = max(dp[i], dp[j] + 1)
    return max(dp)

# 示例
nums = [10, 9, 2, 5, 3, 7, 101, 18]
print(longest_increasing_subsequence(nums))
``

#### 0/1背包问题的状态转移方程推导
```python
def knapsack(weights, values, capacity):
    n = len(weights)
    dp = [[0 for _ in range(capacity + 1)] for _ in range(n + 1)]

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

    return dp[n][capacity]

# 示例
weights = [1, 2, 3]
values = [6, 10, 12]
capacity = 5
print(knapsack(weights, values, capacity))
``

#### 递归与迭代的转换

在动态规划中，递归和迭代是两种常见的方式来实现状态转移方程。递归方法更直观，但可能会导致重复计算和栈溢出。迭代方法通过循环来避免这些缺点，但可能更难理解。

#### 示例代码
```python
def longest_increasing_subsequence_recursive(nums):
    dp = [1] * len(nums)
    for i in range(1, len(nums)):
        for j in range(i):
            if nums[j] < nums[i]:
                dp[i] = max(dp[i], dp[j] + 1)
    return max(dp)

# 示例
nums = [10, 9, 2, 5, 3, 7, 101, 18]
print(longest_increasing_subsequence_recursive(nums))
``

#### 0/1背包问题的递归实现
```python
def knapsack_recursive(weights, values, capacity, i):
    if i == 0 or capacity == 0:
        return 0
    if weights[i-1] > capacity:
        return knapsack_recursive(weights, values, capacity, i-1)
    else:
        return max(knapsack_recursive(weights, values, capacity, i-1),
                   values[i-1] + knapsack_recursive(weights, values, capacity-weights[i-1], i-1))

# 示例
weights = [1, 2, 3]
values = [6, 10, 12]
capacity = 5
print(knapsack_recursive(weights, values, capacity, len(weights)))

时间复杂度分析

动态规划算法的时间复杂度通常依赖于状态的数量和状态转移方程的计算复杂度。合理选择状态和优化状态转移方程可以显著提高算法的效率。

示例代码

def knapsack(weights, values, capacity):
    n = len(weights)
    dp = [0] * (capacity + 1)
    for i in range(n):
        for j in range(capacity, weights[i]-1, -1):
            dp[j] = max(dp[j], dp[j-weights[i]] + values[i])
    return dp[capacity]

# 示例
weights = [1, 2, 3]
values = [6, 10, 12]
capacity = 5
print(knapsack(weights, values, capacity))

经典例题解析

背包问题

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

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

    return dp[n][capacity]

# 示例
weights = [1, 2, 3]
values = [6, 10, 12]
capacity = 5
print(knapsack(weights, values, capacity))

最长递增子序列

def longest_increasing_subsequence(nums):
    dp = [1] * len(nums)
    for i in range(1, len(nums)):
        for j in range(i):
            if nums[j] < nums[i]:
                dp[i] = max(dp[i], dp[j] + 1)
    return max(dp)

# 示例
nums = [10, 9, 2, 5, 3, 7, 101, 18]
print(longest_increasing_subsequence(nums))
``

### 实际问题中的应用

#### 路径规划
```python
import heapq

def dijkstra(graph, start):
    n = len(graph)
    distances = [float('inf')] * n
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)
        if current_distance > distances[current_node]:
            continue
        for neighbor, weight in graph[current_node]:
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# 示例
graph = {
    0: [(1, 1), (2, 4)],
    1: [(2, 1), (3, 2)],
    2: [(3, 1)],
    3: []
}
print(dijkstra(graph, 0))
``

### 常见错误及解决方案

动态规划中常见的错误包括：
- 状态定义不准确导致状态转移方程错误。
- 状态计算过程中重复计算导致效率低下。
- 边界条件处理不当导致计算结果错误。

解决这些问题的方法包括：
- 清晰地定义状态，确保状态转移方程正确。
- 使用记忆化技术避免重复计算。
- 仔细检查边界条件，确保所有情况都被覆盖。

#### 示例代码
```python
def longest_increasing_subsequence(nums):
    dp = [1] * len(nums)
    for i in range(1, len(nums)):
        for j in range(i):
            if nums[j] < nums[i]:
                dp[i] = max(dp[i], dp[j] + 1)
    return max(dp)

# 示例
nums = [10, 9, 2, 5, 3, 7, 101, 18]
print(longest_increasing_subsequence(nums))

动态规划的进阶学习方向

动态规划与其他算法结合

动态规划可以与其他算法技术结合使用，例如贪心算法、分治算法、图论算法等，通过结合不同的算法技术来解决更复杂的问题。

示例代码

def knapsack_greedy(weights, values, capacity):
    items = sorted(zip(weights, values), key=lambda x: x[1] / x[0], reverse=True)
    total_value = 0
    for weight, value in items:
        if weight <= capacity:
            total_value += value
            capacity -= weight
        else:
            total_value += (capacity / weight) * value
            break
    return total_value

# 示例
weights = [1, 2, 3]
values = [6, 10, 12]
capacity = 5
print(knapsack_greedy(weights, values, capacity))
``

#### 示例代码
```python
def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    matrix = [[1, 1], [1, 0]]
    result = matrix_power(matrix, n-1)
    return result[0][0]

def matrix_power(matrix, n):
    if n == 1:
        return matrix
    half = matrix_power(matrix, n // 2)
    result = matrix_multiply(half, half)
    if n % 2:
        result = matrix_multiply(result, matrix)
    return result

def matrix_multiply(a, b):
    return [
        [a[0][0] * b[0][0] + a[0][1] * b[1][0], a[0][0] * b[0][1] + a[0][1] * b[1][1]],
        [a[1][0] * b[0][0] + a[1][1] * b[1][0], a[1][0] * b[0][1] + a[1][1] * b[1][1]]
    ]

# 示例
print(fibonacci(10))

动态规划在竞赛中的应用

动态规划在编程竞赛中有着广泛应用，通过掌握动态规划的基本技巧和优化策略，可以高效地解决各种竞赛题目。

示例代码

def knapsack_with_bitmasking(n, weights, values, capacity):
    dp = [0] * (1 << n)
    for mask in range(1 << n):
        for i in range(n):
            if mask & (1 << i):
                new_mask = mask ^ (1 << i)
                dp[mask] = max(dp[mask], dp[new_mask] + values[i])
    return max(dp)

# 示例
weights = [1, 2, 3]
values = [6, 10, 12]
capacity = 5
print(knapsack_with_bitmasking(len(weights), weights, values, capacity))
``

#### 如何提高解题能力

提高动态规划解题能力的关键在于多做题、多思考、多总结。通过不断练习和优化代码，逐步提高算法的效率和解题速度。推荐在慕课网等平台上学习更多动态规划相关课程。

#### 示例代码
```python
import heapq

def dijkstra(graph, start):
    n = len(graph)
    distances = [float('inf')] * n
    distances[start] = 0
    priority_queue = [(0, start)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)
        if current_distance > distances[current_node]:
            continue
        for neighbor, weight in graph[current_node]:
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# 示例
graph = {
    0: [(1, 1), (2, 4)],
    1: [(2, 1), (3, 2)],
    2: [(3, 1)],
    3: []
}
print(dijkstra(graph, 0))
点击查看更多内容
发表于 2024.11.04 20:16， 共 180 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

守着星空守着你

手记
篇
粉丝
39
获赞与收藏
267

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消