动态规划算法基础及C语言实例_c语言动态规划-CSDN博客

本文链接：https://blog.csdn.net/xingchen06/article/details/142330854

动态规划算法基础及C语言实例

1. 动态规划概述

动态规划（Dynamic Programming, DP）是一种将复杂问题分解为更简单子问题的算法设计思想，通常用于解决具有重叠子问题和最优子结构性质的问题。动态规划通过存储子问题的解（即记忆化）避免了重复计算，显著提高了计算效率。

重叠子问题是指在问题求解过程中，某些子问题会被多次计算。而最优子结构意味着问题的最优解可以由其子问题的最优解构成。

2. 动态规划的基本步骤

动态规划通常遵循以下几个步骤：

确定状态和定义状态表示
- 找到问题的子问题，并定义一个状态表示，例如dp[i]表示前i个元素的解。
状态转移方程
- 找出问题与子问题之间的递推关系。也就是如何通过已知的子问题解得到原问题的解。
边界条件（初始条件）
- 定义最小子问题的解，通常是问题最初状态的值。
计算顺序
- 确定计算子问题的顺序，一般从最小的子问题开始逐步求解较大的问题。
返回最终结果
- 根据问题的需求，返回最终的解。

3. 动态规划经典问题及C语言实例

示例1：斐波那契数列

问题描述：
计算斐波那契数列的第n个数，斐波那契数列定义为：

F(0) = 0，F(1) = 1
F(n) = F(n-1) + F(n-2)（对于n >= 2）

解题思路：
通过动态规划，利用一个数组来存储中间结果，避免重复计算。

#include <stdio.h>

int fibonacci(int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;
    
    int dp[n + 1];
    dp[0] = 0;
    dp[1] = 1;

    for (int i = 2; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }

    return dp[n];
}

int main() {
    int n = 10;
    printf("Fibonacci(%d) = %d\n", n, fibonacci(n));
    return 0;
}

示例2：0-1 背包问题

问题描述：
有一个容量为W的背包，和n个物品，每个物品的重量为wi，价值为vi。求如何选择物品使得在不超过背包容量的情况下，背包中的物品价值最大。

解题思路：
定义dp[i][w]表示前i个物品在容量为w时的最大价值。状态转移方程为：

如果不选择第i个物品：dp[i][w] = dp[i-1][w]
如果选择第i个物品：dp[i][w] = max(dp[i-1][w], dp[i-1][w-wi] + vi)

#include <stdio.h>

#define MAX_ITEMS 100
#define MAX_WEIGHT 1000

int knapsack(int n, int W, int weights[], int values[]) {
    int dp[MAX_ITEMS + 1][MAX_WEIGHT + 1] = {0};

    for (int i = 1; i <= n; i++) {
        for (int w = 0; w <= W; w++) {
            if (weights[i - 1] <= w) {
                dp[i][w] = (dp[i - 1][w] > (dp[i - 1][w - weights[i - 1]] + values[i - 1]))
                           ? dp[i - 1][w]
                           : (dp[i - 1][w - weights[i - 1]] + values[i - 1]);
            } else {
                dp[i][w] = dp[i - 1][w];
            }
        }
    }

    return dp[n][W];
}

int main() {
    int n = 4;  // 物品数量
    int W = 8;  // 背包容量
    int weights[] = {2, 3, 4, 5};
    int values[] = {3, 4, 5, 6};

    printf("Maximum value in Knapsack = %d\n", knapsack(n, W, weights, values));
    return 0;
}

示例3：最长上升子序列

问题描述：
给定一个整数数组，求该数组的最长严格递增子序列的长度。例如，数组[10, 9, 2, 5, 3, 7, 101, 18]的最长上升子序列是[2, 3, 7, 101]，长度为4。

解题思路：
定义dp[i]为以第i个元素为结尾的最长上升子序列长度。对于每个元素，检查前面的元素是否小于当前元素，并更新状态。

#include <stdio.h>

int lengthOfLIS(int arr[], int n) {
    if (n == 0) return 0;
    
    int dp[n];
    for (int i = 0; i < n; i++) dp[i] = 1;

    int maxLIS = 1;
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (arr[i] > arr[j]) {
                dp[i] = (dp[i] > dp[j] + 1) ? dp[i] : (dp[j] + 1);
            }
        }
        if (dp[i] > maxLIS) {
            maxLIS = dp[i];
        }
    }

    return maxLIS;
}

int main() {
    int arr[] = {10, 9, 2, 5, 3, 7, 101, 18};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("Length of Longest Increasing Subsequence: %d\n", lengthOfLIS(arr, n));
    return 0;
}