CSP-J/S 复赛算法线性DP

人才程序员

于 2024-10-05 19:16:27 发布

阅读量409

点赞数 10

分类专栏： CSP-J 文章标签：算法贪心算法竞赛 c++ c语言动态规划

本文链接：https://blog.csdn.net/m0_62599305/article/details/142716857

版权

CSP-J 专栏收录该内容

39 篇文章 1 订阅

订阅专栏

文章目录

前言
线性动态规划
DP算法三要素
线性DP示例
- 例题1：爬楼梯问题
总结

前言

在算法竞赛中，动态规划（Dynamic Programming，简称DP）是一种强大的解题技巧，尤其在处理具有重叠子问题和最优子结构性质的问题时，表现得尤为出色。在线性动态规划中，我们关注的是通过线性结构（如数组或链表）来表达问题，并通过递推的方法来求解最优解。这类问题的特点在于，状态的转移通常只依赖于前一个或前几个状态，具有良好的可计算性。

在线性DP中，我们将问题划分为多个阶段，并在每个阶段进行状态更新。通过精心设计状态转移方程，我们能够逐步逼近问题的最优解。这种方法不仅可以显著降低时间复杂度，还能有效减少空间复杂度，使得解决复杂问题变得可行。

线性动态规划

线性动态规划其实是一种解决问题的小技巧，它的核心思想是“把大问题变成小问题，一步一步解决”。就像我们爬楼梯，如果要爬到楼顶，我们不可能一口气跳上去，而是需要一阶一阶地爬，每一步都建立在之前的基础上。线性动态规划也是这样，每一步的结果都要依赖前面几步已经算出来的结果，然后一点一点地推进到最终的答案。

简单来说，线性动态规划就是把复杂的问题拆成一系列简单的步骤，然后从简单到复杂，逐步解决。

DP算法三要素

在动态规划（DP）算法中，状态、阶段和决策是非常重要的三个部分，可以把它们想象成解题过程中需要回答的三个关键问题。

状态：状态就像你在解题过程中的每一个“中间站”或“当前局面”。比如你在打游戏时，你当前的血量、分数、位置这些都可以称为“状态”。在DP算法中，每一个状态都会影响后面的选择和结果。
阶段：阶段可以理解为问题解决过程中的每一个“步骤”或“阶段”。就像你在做一个任务时，一步一步往前推进，每一阶段都有新的目标。在DP里，每一阶段我们都在解决一部分问题，直到最终完成所有阶段。
决策：决策就是每到一个阶段时你要做的“选择”。好比你在游戏里遇到敌人，你要选择是攻击还是防守。在DP算法中，每一阶段我们根据当前状态要做一个选择，这个选择会影响接下来的状态和结果。

通俗点讲，动态规划就是通过分析每个“状态”，在每个“阶段”做出“决策”，一步步积累，最终解决整个问题的过程。

线性DP示例

例题1：爬楼梯问题

题目描述

假设你在一个楼梯上，有 n 级台阶。每次你可以选择走 1 级或 2 级台阶。请问有多少种不同的方法可以到达楼顶？

分析过程

定义状态：
- 我们用 f(n) 表示到达第 n 级台阶的方法总数。
状态转移：
- 要到达第 n 级台阶，有两种可能：
  - 从第 n-1 级台阶走一步上来。
  - 从第 n-2 级台阶走两步上来。
- 所以，我们可以得到公式：
  $f (n) = f (n - 1) + f (n - 2)$
- 这就意味着，要到达第 n 级台阶的方法总数等于到达第 n-1 级台阶和 n-2 级台阶的方法总数之和。
初始条件：
- f(1) = 1：只有一种方法到达第一层（一步上去）。
- f(2) = 2：有两种方法到达第二层（一步一步上去，或者一步跳两层）。
计算方法：
- 从小的台阶开始，利用我们得到的公式来计算到达更高台阶的方法数，直到 n 级台阶。

示例代码（C语言）

#include <stdio.h>

int climbStairs(int n) {
    if (n == 1) return 1; // 1级台阶
    if (n == 2) return 2; // 2级台阶
    
    int a = 1; // f(1)
    int b = 2; // f(2)
    int result;
    
    for (int i = 3; i <= n; i++) {
        result = a + b; // f(n) = f(n-1) + f(n-2)
        a = b; // 更新 f(n-2)
        b = result; // 更新 f(n-1)
    }
    
    return result; // 返回 f(n)
}

int main() {
    int n = 5; // 假设有5级台阶
    printf("到达 %d 级台阶的方法总数是：%d\n", n, climbStairs(n));
    return 0;
}

例题2：最小路径和

题目描述

在一个二维数组中，每个元素表示一个非负整数。你从左上角的格子开始，目标是到达右下角的格子。每次只能向下或向右移动，请问到达右下角的最小路径和是多少？

分析过程

定义状态：
- 我们用 dp[i][j] 表示到达位置 (i, j) 的最小路径和。
状态转移：
- 要到达位置 (i, j)，我们只能从上面 (i-1, j) 或左边 (i, j-1) 移动过来。因此我们可以得到公式：
  $\text{grid}[i][j] + \min(dp[i-1][j], dp[i][j-1])$
- 这意味着到达 (i, j) 的最小路径和等于当前位置的值加上从上面或左边到达的最小路径和。
初始条件：
- dp[0][0] = grid[0][0]：起始位置的路径和就是它本身。
- 第一行和第一列的路径和只能从左或上方累计。
计算方法：
- 通过遍历整个二维数组，利用我们得到的公式来计算每个位置的最小路径和。

示例代码（C语言）

#include <stdio.h>

#define MAX 100 // 假设数组的最大大小

int minPathSum(int grid[MAX][MAX], int m, int n) {
    int dp[MAX][MAX];
    
    // 初始化起始点
    dp[0][0] = grid[0][0];
    
    // 初始化第一行
    for (int j = 1; j < n; j++) {
        dp[0][j] = dp[0][j-1] + grid[0][j];
    }
    
    // 初始化第一列
    for (int i = 1; i < m; i++) {
        dp[i][0] = dp[i-1][0] + grid[i][0];
    }
    
    // 填充整个dp数组
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[i][j] = grid[i][j] + (dp[i-1][j] < dp[i][j-1] ? dp[i-1][j] : dp[i][j-1]);
        }
    }
    
    return dp[m-1][n-1]; // 返回右下角的最小路径和
}

int main() {
    int grid[3][3] = { {1, 3, 1},
                       {1, 5, 1},
                       {4, 2, 1} };
    printf("到达右下角的最小路径和是：%d\n", minPathSum(grid, 3, 3));
    return 0;
}

例题3：最大子序和

题目描述

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

分析过程

定义状态：
- 用 dp[i] 表示以 nums[i] 结尾的最大子序和。
状态转移：
- 选择以 nums[i] 结尾的子序和，我们可以选择加上前面的子序和或重新开始。
- 公式为：
  $\max(dp[i-1] + \text{nums}[i], \text{nums}[i])$
- 这意味着当前的最大子序和要么是前一个最大子序和加上当前元素，要么是当前元素本身。
初始条件：
- dp[0] = nums[0]：以第一个元素结尾的最大子序和就是它本身。
计算方法：
- 遍历整个数组，利用我们得到的公式来计算每个位置的最大子序和，并记录全局最大值。

示例代码（C语言）

#include <stdio.h>

int maxSubArray(int* nums, int numsSize) {
    int dp[numsSize];
    dp[0] = nums[0];
    int max_sum = dp[0];
    
    for (int i = 1; i < numsSize; i++) {
        dp[i] = (dp[i-1] + nums[i] > nums[i]) ? (dp[i-1] + nums[i]) : nums[i];
        if (dp[i] > max_sum) {
            max_sum = dp[i]; // 更新全局最大值
        }
    }
    
    return max_sum; // 返回最大子序和
}

int main() {
    int nums[] = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("最大子序和是：%d\n", maxSubArray(nums, size));
    return 0;
}