数据结构算法--动态规划详解

女程序员jingyu

已于 2023-12-11 17:23:40 修改

阅读量1.1k

点赞数 23

分类专栏：数据结构算法详解文章标签：算法数据结构动态规划

于 2023-12-11 17:23:23 首次发布

本文链接：https://blog.csdn.net/jy18817386398/article/details/134735445

版权

数据结构算法详解专栏收录该内容

8 篇文章 0 订阅

订阅专栏

什么是动态规划？

动态规划：Dynamic Programmin，因此常用DP指代。定义：

将一个大问题拆分为一个个子问题；
每个子问题有最优解状态，最终全局最优解状态为子问题最优解状态的递推集合；
记录历史，避免重复计算。

动态规划算法步骤

定义状态。借助DP数组保存历史记录；DP含义明确，例如：DP[i]表示第i阶梯方案。
列出状态转移方程。找出数组之间的关系，这一步有可能是最难的一步。
初始化状态。DP[i]个状态的转移方程，跟DP[i - 1]和DP[i - 2]存在关联。

动态规划算法分类

线性算法

算法描述

在线性空间上递推，也就是在一条线上进行。

算法举例--求解最长公共子序列定义

例如：求最长公共子序列力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

算法举例--求解最长公共子序列复杂度

$O(nm)$

算法举例--求解最长公共子序列代码--c++

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int n = text1.size(), m = text2.size();
        vector<vector<int>> f(n + 1, vector<int>(m + 1, 0));
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= m; ++j) {
                if (text1[i - 1] == text2[j - 1]) {
                    f[i][j] = f[i - 1][j - 1] + 1;
                } else {
                    f[i][j] = max(f[i - 1][j], f[i][j - 1]);
                }
            }
        }
        return f[n][m];
    }
};

算法举例--求解最长公共子序列分析

状态定义。即f[i][j] = text1的[1, i]和text2的[1, j]区间的最长公共子序列长度；

列出状态转移方程。如果text1[i] == text2[j]，则问题进一步拆分为求解text1的[1, i - 1]和text2的[1, j - 1]的最长公共子序列 + 1，即f[i][j] = f[i - 1][j - 1] + 1；如果text1[i] != text2[j]，则求解text1的[1,i]和text2的[1,j]最长公共子序列长度无法延长，因此f[i][j]就会继承f[i - 1][j]与f[i][j - 1]中的较大值，即f[i][j] = max(f[i - 1][j],f[i][j - 1]) ；

初始化状态。f[i][0] = f[0][j] = 0。

背包算法

01背包算法定义

N件物品(每种仅1件，选择放或者不放)，背包容量V；第i件物品体积v[i]，价值w[i]；求解怎么放可以获得最大价值。

01背包算法代码--c++

#include<iostream>
using namespace std;

std::vector<int> 01_bag_dp(){
    const int N = 1010;
    std::vector<int> v = std::vector<int>(N, 0);
    std::vector<int> w = std::vector<int>(N, 0);
    std::vector<std::vector<int>> dp = std::vector<int>(N + 1, std::vector<int>(N + 1, 0));
    int n, m;    
    cin >> n >> m;
    for(int i = 1; i <= n; i++){
        cin >> v[i] >> w[i];
    }
    
    for(int i = 1; i <= n; i++){
        for(int j = 0; j <= m; j++){
            if(j < v[i])
                dp[i][j] = dp[i - 1][j];
            else
                dp[i][j]= max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
        }
        for(int j = m; j >= v[i]; j--){
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    return dp[m];
}

01背包算法分析

状态定义。dp[i][V] = 前i件物品恰放入背包后可以获得的最大价值；

列出状态转移方程。dp[i][V] = max(dp[i - 1][V], dp[i - 1][V - v[i] + w[i]])；

初始化状态。f[i][0] = f[0][V] = 0。

01背包算法优化

dp[i][V]实际是dp[i - 1][V]和f[i - 1][V - v[i]]子问题递推而来，因此每i次主循环中，以V递减推dp[v]。因此最后一个for循环加了空间优化。

目标和算法定义

另举一例，为01背包算法变种。给定非负整数数组nums和目标整数target，向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个表达式，表达式结果等于target

目标和算法代码--c++

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        int diff = sum - target;
        if (diff < 0 || diff % 2 != 0) {
            return 0;
        }
        int n = nums.size();
        int neg = diff / 2;
        // 数组综合sum，-元素之和为neg，则其余+元素之和为sum−neg，(sum−neg)−neg = target
        vector<vector<int>> dp(n + 1, vector<int>(neg + 1));
        /* dp数组初始化 */
        dp[0][0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= neg; j++) {
                dp[i][j] = dp[i - 1][j];
                /* 如果背包剩余j的容量大于放的物品nums[i-1]则就可以将物品nums[i-1]放入背包中 */
                if (j >= nums[i - 1]) {
                    dp[i][j] += dp[i - 1][j - nums[i - 1]];
                }
            }
        }
        return dp[n][neg];
    }
};

目标和算法分析

状态定义。dp[i][j] = 在数组中选取元素，前i个数的和等于j;

列出状态转移方程。如果j >= nums，dp[i][j] = dp[i − 1][j] + dp[i − 1][j − num]；如果j < nums，dp[i][j] = dp[i − 1][j]；

初始化状态。dp[0][0] = 1。

区间算法

算法描述

将整个问题区间逐步拆分成小区间来处理。

算法举例--最长回文子序列定义

给定字符串s，找出最长回文子序列，并返回该序列长度。

算法举例--最长回文子序列复杂度

一般是O(n^2)

算法举例--最长回文子序列代码--c++

int longestPalindromeSubseq(string s) {
    int n = s.size();
    vector<vector<int>> dp(n, vector<int>(n, 0));
    // base case
    for (int i = 0; i < n; i++)
        dp[i][i] = 1;
    // 反着遍历保证正确的状态转移
    for (int i = n - 1; i >= 0; i--) {
        for (int j = i + 1; j < n; j++) {
            // 状态转移方程
            if (s[i] == s[j])
                dp[i][j] = dp[i + 1][j - 1] + 2;
            else
                dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
        }
    }
    return dp[0][n - 1];
}

算法举例--最长回文子序列分析

状态定义。dp[i][j] = 最长回文子序列长度，数组s[i.......j]

列出状态转移方程。如果s[i] == s[j]，dp[i][j] = dp[i + 1][j - 1] + 2；否则，dp[i][j] = max(dp[i − 1][j]， dp[i][j - 1])；

初始化状态。dp[i][j] = 1。

树形算法

算法描述

dp动态规划应用在树状结构。

算法举例--二叉树最大路径和定义

二叉树中，路径即一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中至多出现一次，该路径至少包含一个节点，且不一定经过根节点。路径和是路径中各节点值的总和。

算法举例--二叉树最大路径复杂度

$o(n)$

算法举例--二叉树最大路径和代码

class Solution {
public:
    int maxPathSum(TreeNode *root) {
        int ans = INT_MIN;
        function<int(TreeNode*)> dfs = [&](TreeNode *node) -> int {
            if (node == nullptr)
                return 0; // 没有节点，和为 0
            int l_val = dfs(node->left); // 左子树最大链和
            int r_val = dfs(node->right); // 右子树最大链和
            ans = max(ans, l_val + r_val + node->val); // 两条链拼成路径
            return max(max(l_val, r_val) + node->val, 0); // 当前子树最大链和
        };
        dfs(root);
        return ans;
    }
};

算法举例--二叉树最大路径和分析

当前节点【拐弯】最大路径和 = 左子树最大链和 + 右子树最大链和 + 当前节点值

如果值为负，返回0

数位算法

算法描述

顾名思义，dp动态规划应用在数位。

算法举例--最大为N的数字组合定义

给定非递减顺序排列的数字数组 digits 。用任意次数 digits[i] 来写数字。例如，如果 digits = ['1','3','5']，我们可以写数字，如 '13', '551', 和 '1351315'。返回可以生成的小于或等于n 的正整数的个数。

算法举例--最大为N的数字组合复杂度

$O(lenlogn)$

len为digits长度

算法举例--最大为N的数字组合代码

class Solution {
public:
    int atMostNGivenDigitSet(vector<string> &digits, int n) {
        auto s = to_string(n);
        int m = s.length(), dp[m];
        memset(dp, -1, sizeof(dp)); // dp[i] = -1 表示 i 这个状态还没被计算出来
        function<int(int, bool, bool)> f = [&](int i, bool is_limit, bool is_num) -> int {
            if (i == m) return is_num; // 如果填了数字，则为 1 种合法方案
            if (!is_limit && is_num && dp[i] >= 0) return dp[i]; // 在不受到任何约束的情况下，返回记录的结果，避免重复运算
            int res = 0;
            if (!is_num) // 前面不填数字，那么可以跳过当前数位，也不填数字
                // is_limit 改为 false，因为没有填数字，位数都比 n 要短，自然不会受到 n 的约束
                // is_num 仍然为 false，因为没有填任何数字
                res = f(i + 1, false, false);
            char up = is_limit ? s[i] : '9'; // 根据是否受到约束，决定可以填的数字的上限
            // 注意：对于一般的题目而言，如果这里 is_num 为 false，则必须从 1 开始枚举，由于本题 digits 没有 0，所以无需处理这种情况
            for (auto &d : digits) { // 枚举要填入的数字 d
                if (d[0] > up) break; // d 超过上限，由于 digits 是有序的，后面的 d 都会超过上限，故退出循环
                // is_limit：如果当前受到 n 的约束，且填的数字等于上限，那么后面仍然会受到 n 的约束
                // is_num 为 true，因为填了数字
                res += f(i + 1, is_limit && d[0] == up, true);
            }
            if (!is_limit && is_num) dp[i] = res; // 在不受到任何约束的情况下，记录结果
            return res;
        };
        return f(0, true, false);
    }
};

算法举例--最大为N的数字组合分析

f(i, isLimit, isNum) = 从左往右第i位及其之后数位的合法方案；

isLimit为是否受n约束，如果为true，则至多为s[i]，如果为false否则至多为9；

isNum表示是否填了数字，如果为true，必须填数字，从0开始，如果为false，跳过。

女程序员jingyu

关注

23
点赞
踩
24

收藏

觉得还不错? 一键收藏
0
评论
数据结构算法--动态规划详解

如果text1[i] == text2[j]，则问题进一步拆分为求解text1的[1, i - 1]和text2的[1, j - 1]的最长公共子序列 + 1，即f[i][j] = f[i - 1][j - 1] + 1；= text2[j]，则求解text1的[1,i]和text2的[1,j]最长公共子序列长度无法延长，因此f[i][j]就会继承f[i - 1][j]与f[i][j - 1]中的较大值，即f[i][j] = max(f[i - 1][j],f[i][j - 1])；
复制链接

扫一扫