codetop标签动态规划大全C++讲解(三)！！动态规划刷穿地心！！学吐了家人们o(╥﹏╥)o

已于 2024-10-06 13:07:35 修改
阅读量659 收藏 5
点赞数 19
分类专栏： # 秒杀系列：题型大乱炖，剑指offer!!!! 文章标签： 动态规划 c++ 算法
于 2024-10-06 13:06:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45962681/article/details/142725919
版权

每天复习一篇，只有十题左右

1.买卖股票的最佳时机

给prices数组，只能买卖一次！
0持有，1不持有
注意：只能买一次，状态不能从dp[i-1][1]转移，所以只有-prices[i]，如果不限次数就可以写dp[i - 1][1] - prices[i]了!!!

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<vector<int>> dp(prices.size(), vector<int>(2, 0));
        dp[0][0] = -prices[0];
        for(int i = 1; i < prices.size(); i ++){
            dp[i][0] = max(- prices[i], dp[i - 1][0]);
            dp[i][1] = max(dp[i - 1][0] + prices[i], dp[i - 1][1]);
        }
        return dp[prices.size() - 1][1];
    }
};

2.买卖股票的最佳时机含手续费

无限次买卖，卖出同时需要付一笔手续费

因为是无限次买卖，所以状态从dp[i-1][1]转移，不限次数写成dp[i - 1][1] - prices[i]
买的时候减去fee

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        vector<vector<int>> dp(prices.size(), vector<int>(2, 0));
        //0持有,1不持有
        dp[0][0] = -prices[0];
        for(int i = 1; i < prices.size(); i ++){
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
        }
        return dp[prices.size() - 1][1];
    }
};

3.买卖股票的最佳时机III

限制最多可以完成两笔交易

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        //0第一次持有,1第一次不持有,2第二次持有,3第二次不持有
        vector<vector<int>> dp(prices.size(), vector<int>(4, 0));
        dp[0][0] = -prices[0];
        dp[0][2] = -prices[0];
        for(int i = 1; i < prices.size(); i ++){
            dp[i][0] = max(dp[i - 1][0], -prices[i]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
            dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] - prices[i]);
            dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] + prices[i]);
        }
        return dp[prices.size() - 1][3];
    }
};

4.买卖股票的最佳时机IV

最多可以完成k笔交易，也就是说，最多可以买k次，卖k次

k从1开始，分奇偶

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        vector<vector<int>> dp(prices.size(), vector<int>(2*k + 1, 0));
        //奇数持有，偶数不持有
        for(int i = 1; i < 2*k + 1; i ++){
            if(i % 2 == 1) dp[0][i] = -prices[0];
        }
        for(int i = 1; i < prices.size(); i ++){
            for(int j = 1; j <= 2*k - 1; j += 2){
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] - prices[i]);
                dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] + prices[i]);
            }
        }
        return dp[prices.size() - 1][2 * k];
    }
};

5.打家劫舍

给定一个代表每个房屋存放金额的非负整数数组，相邻房屋装有相互连通的防盗系统，求最多偷的金额。
关键函数： dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);

class Solution {
public:
    int rob(vector<int>& nums) {
        vector<int> dp(nums.size(), 0);
        if(nums.size() == 0) return 0;
        if(nums.size() == 1) return nums[0];
        if(nums.size() == 2) return max(nums[0], nums[1]);
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for(int i = 2; i < nums.size(); i ++){
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return dp[nums.size() - 1];
    }
};

6.打家劫舍II

房屋围城一圈，最后一个房屋和第一个房屋紧邻，偷相邻房间会自动报警

  1. 考虑不包含首尾元素
  2. 考虑包含首元素不包含尾元素
  3. 考虑不包含首元素包含尾元素
    考虑是包含但不一定要选，所以情况23包含了1
    简单点来说，考虑偷第一个不偷第二个和偷第二个不偷第一个的情况
    两个情况取最值，单领一个情况的计算就和I一样
class Solution {
public:
    int rob(vector<int>& nums) {
        int len = nums.size();
        if(len == 0) return 0;
        if(len == 1) return nums[0];
        if(len == 2) return max(nums[0], nums[1]);
        int result1 = robRange(nums, 0, len - 2);
        int result2 = robRange(nums, 1, len - 1);
        int result = max(result1, result2);
        return result;
    }
    int robRange(vector<int>& nums, int start, int end){
        vector<int> dp(nums.size() + 1, 0);
        dp[start] = nums[start];
        dp[start + 1] = max(nums[start], nums[start + 1]);
        for(int i = start + 2; i <= end; i ++){
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return dp[end];
    }
};

7.不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
问总共有多少条不同的路径？
关键代码：
dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for(int i = 0; i < m; i ++) dp[i][0] = 1;
        for(int i = 0; i < n; i ++) dp[0][i] = 1;
        for(int i = 1; i < m; i ++){
            for(int j = 1; j < n; j ++){
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};

8.不同路径II

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
网格中的障碍物和空位置分别用 1 和 0 来表示。

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for(int i = 0; i < m && obstacleGrid[i][0] == 0; i ++) dp[i][0] = 1;
        for(int j = 0; j < n && obstacleGrid[0][j] == 0; j ++) dp[0][j] = 1;
        for(int i = 1; i < m; i ++){
            for(int j = 1; j < n; j ++){
                if(obstacleGrid[i][j] == 1) continue;
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};

9.最小路径和

给定一个包含非负整数的m * n网格grid，找出一条从左上角到右下角的路径，使得路径上的数字总和最小。

注意边界问题，第一行第一列需要初始化，所有for都是从1开始的

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size();
        int n = grid[0].size();
        vector<vector<int>> dp(m, vector<int>(n, 0));
        dp[0][0] = grid[0][0];
        for(int i = 1; i < m; i ++) dp[i][0] = dp[i - 1][0] + grid[i][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 ++){
            for(int j = 1; j < n; j ++){
                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
            }
        }
        return dp[m - 1][n - 1];
    }
};

10.三角形的最小路径和

给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。

相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。
在这里插入图片描述
题目的意思，在相邻节点的条件下，求最小路径，与(i, j)点相邻的结点为(i + 1, j)和 (i + 1, j + 1)

第 i 行的第 j 个元素从哪里来？可以从第 i - 1 行第 j 或第 j - 1 个元素下落过来。
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - 1]) + triangle[i][j]

注意边界！！！dp[i][0]必须初始化，dp[0][i]不用，因为dp[0][i]一定只有一个，毕竟三个三角形

class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int m = triangle.size();
        vector<vector<int>> dp(m, vector<int>(m, INT_MAX));
        dp[0][0] = triangle[0][0];
        for(int i = 1; i < m; i ++) dp[i][0] = dp[i - 1][0] + triangle[i][0];
        for(int i = 1; i < m; i ++){
            for(int j = 1; j < triangle[i].size(); j ++){
                dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - 1]) + triangle[i][j];
            }
        }
        int res = INT_MAX;
        for(int i = 0; i < m; i ++){
            res = min(res, dp[m - 1][i]);
        }
        return res;
    }
};

11.两个字符串的删除操作

给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。

dp[i][j]：以i-1为结尾的字符串word1，和以j-1为结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。

  1. 当word1[i - 1] 与 word2[j - 1]相同的时候，dp[i][j] = dp[i - 1][j - 1]
  2. 当word1[i - 1] 与 word2[j - 1]不相同的时候，有三种情况：
  • 删word1[i - 1]，最少操作次数为dp[i - 1][j] + 1
  • 删word2[j - 1]，最少操作次数为dp[i][j - 1] + 1
  • 删word1[i - 1]和word2[j - 1]，操作的最少次数为dp[i - 1][j - 1] + 2
class Solution {
public:
    int minDistance(string word1, string word2) {
        int len1 = word1.size();
        int len2 = word2.size();
        vector<vector<int>> dp(len1 + 1, vector<int>(len2 + 1, 0));
        for(int i = 0; i <= len1; i ++) dp[i][0] = i;
        for(int i = 0; i <= len2; i ++) dp[0][i] = i;
        for(int i = 1; i <= len1; i ++){
            for(int j = 1; j <= len2; j ++){
                if(word1[i - 1] == word2[j - 1]) dp[i][j] = dp[i - 1][j - 1];
                else dp[i][j] =  min(dp[i - 1][j - 1] + 2, min(dp[i - 1][j] + 1, dp[i][j - 1] + 1));
            }
        }
        return dp[len1][len2];
    }
};

12.编辑距离

可以对一个单词进行增加，删除和替换，现有两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。

dp[i][j]表示以下标i-1结尾的字符串word1，和以下标j-1结尾的字符串word2，最近编辑距离为dp[i][j]，所以i，j最大都可以达到len

  1. word[i - 1] == word2[j - 1]的时候不操作，dp[i][j]=dp[i-1][j-1]
  2. word1[i - 1] ！= word2[j - 1]的时候操作，分三种情况，增删换
  • 增加/删除：word1增加一个元素，相当于word2减少一个元素。比如word1 = “a”，word2 = “ab”，word1增加一个元素b和word2删除一个元素b的操作数是一样的；word1减少一个元素，相当于word2增加一个元素，比如word1 = “ab”，word2 = “a”，word1减少一个b和word2增加一个b用的操作数是一样的。所以dp[i][j] = dp[i][j - 1] + 1
  • 替换：dp[i][j] = dp[i - 1][j - 1] + 1
class Solution {
public:
    int minDistance(string word1, string word2) {
        int len1 = word1.size();
        int len2 = word2.size();
        vector<vector<int>> dp(len1 + 1, vector<int>(len2 + 1, 0));
        for(int i = 0; i <= len1; i ++) dp[i][0] = i;
        for(int i = 0; i <= len2; i ++) dp[0][i] = i;
        for(int i = 1; i <= len1; i ++){
            for(int j = 1; j <= len2; j ++){
                if(word1[i - 1] == word2[j - 1]) dp[i][j] = dp[i - 1][j - 1];
                else dp[i][j] = min(dp[i - 1][j] + 1, min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1));
            }
        }
        return dp[len1][len2];
    }
};

13.一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
请你找出并返回 strs 的最大子集的大小，该子集中 最多 有 m 个 0 和 n 个 1 。

背包有2个维度，m个0和n个1属于背包，strs数组是物品，由于物品只能选一次，所以这是个01背包问题
dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i] [j]。
递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for(string str : strs){//遍历物品
            int zoreNums = 0;
            int oneNums = 0;
            for(int i = 0; i < str.size(); i ++){
                if(str[i] == '0') zoreNums ++;
                else oneNums ++;
            }
            for(int j1 = m; j1 >= zoreNums; j1 --){//遍历背包，两个维度
                for(int j2 = n; j2 >= oneNums; j2 --){
                    dp[j1][j2] = max(dp[j1][j2], dp[j1 - zoreNums][j2 - oneNums] + 1);
                }
            }
        }
        return dp[m][n];

    }
};
___Dream
关注
专栏目录
基础动态规划/凑硬币 经典例题算法详解 [C++实现]
weixin_51456573的博客
05-05 3611
基础动态规划算法 目录基础动态规划算法经典问题算法1 暴力破解算法2 动态规划补充结尾 经典问题 现在给你一定硬币，数量为n个，去购买一个价格为m的物品； 硬币的面额分别为a，b，c； 问：如何消费才能使用最少的硬币而且刚好不需要找零？请写出使用最少的硬币数；否则输出-1； 例： 硬币数量 n = 3；面额分别为{1，2，5}；物品价格 m = 11； 输出结果为：3 【11 = 5 + 5 + 1】 算法1 暴力破解 按硬币的面额分别尝试，按例题，先使用面额最小的硬币，那么剩下所需要的硬币数量应该是f
算法 动态规划 简单直观理解 矩阵链乘法 带图讲解
weixin_51472145的博客
04-04 6734
简单直观理解 矩阵链乘法 带图讲解，动态规划算法
动态规划详解
每天学习一点点，成长一小步
03-23 2万+
以下为最常见的使用动态规划的例子： 一、动态规划的三大步骤 动态规划，无非就是利用历史记录，来避免我们的重复计算。而这些历史记录，我们得需要一些变量来保存，一般是用一维数组或者二维数组来保存。下面我们先来讲下做动态规划题很重要的三个步骤： 第一步骤：定义数组元素的含义，上面说了，我们会用一个数组，来保存历史数组，假设用一维数组 dp[] 吧。这个时候有一个非常非常重要的点，就是规定你这个数组元素的含义，例如你的 dp[i] 是代表什么意思？ 第二步骤：找出数组元素之间的关系式，我觉得动态规划，还是有一点类
自动驾驶决策 - 规划 - 控制 （持续更新！！！）
BigDavid123的博客
03-19 2329
自动驾驶学习记录
★动态规划（DP算法）详解
qq_17807067的博客
04-25 3万+
动态规划（DP算法）详解
C++入门基础（万字详解！！！）
忘忧.
08-15 4万+
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。因此：C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。
剑指offer(C++)-JZ19：正则表达式匹配(算法-动态规划)
翟天保的博客
11-25 1万+
C++实现——正则表达式匹配(算法-动态规划)
算法：动态规划——最长公共子序列
Sauron7i的博客
04-23 6357
文章目录一、动态规划概念1. 动态规划步骤最长公共子序列问题题目示例分析代码（递归）查表打印最长公共子序列 一、动态规划概念 动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。 与分治法不同的是，适合于用动态规划法求解的问题，经分解得到的子问题往往不是互相独立的。若用分治法解这类问题，则分解得到的子问题数目太多，以至于最后解决原问题需要耗费指数时间。 然而，不同子问题的数目常常只有多项式量级。在用分治法求解时，有些子问题被重复计算了许多
算法学习 - 01背包问题（动态规划C++）
累了就歇一会
04-28 1万+
动态规划 01背包 问题描述 求解思路 代码实现 放入哪些物品 代码动态规划我在上一篇博客里已经讲了一点动态规划了，传送门：算法学习 - 动态规划(DP问题)(C++)这里说一下，遇到动态规划应该如何去想，才能找到解决办法。最主要的其实是要找状态转移的方程，例如上一篇博客里面，找的就是当前两条生产线的第i个station的最短时间和上一时刻的时间关系。minTime(station[1][i]) =
c++动态规划——背包问题
YinghaoGuo的博客
11-08 1万+
问题基础：有N件物品和一个容量为C的背包。第i件物品的体积是W[i]，价值是V[i]。求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。 怎样才能得到放入书包物品的的最大价值呢？ 解决方法——【动态规划】 运筹学的分支，纠结决策过程最优化的数学方法 把多阶段问题分解为相互联系单一阶段小问题求解，上一阶段的决策可以对下一阶段的决策产生影响 各个阶段的决
【C++动态库编程】C++名称改编、标准C接口、extern “C”、函数调用约定以及def文件详解
dvlinker的技术专栏
08-27 3万+
本文通过一个具体的dll动态库编程实例，详细讲述动态库导出接口相关的导入导出声明、标准C接口、extern "C"作用、函数调用约定声明、跨语言调用dll接口以及def文件等内容。
C++ 数字三角形(动态规划)
ChanJose的博客
01-25 9500
一、题目 有三种方法实现： 这里就求权值之和最大的，最小的类似就不分析了。 1.自底向上 缺点：算法复杂，重复计算 2.自顶向下 缺点：重复计算，浪费时间 3.动态规划 思路和自底向上、自顶向下一样，只不过开多一个数组opt存储计算过的到达a[i][j]的权值之和最大的数 二、思路： 方法1：自底向上 1.从最后一行出...
C++入门基础(万字总结）（建议收藏！！！）
热门推荐
IamGreeHand的博客
09-22 26万+
文章目录什么是C++C++的发展史C++关键字命名空间命名空间的定义1.命名空间的普通定义2.命名空间可以嵌套3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。命名空间使用1.加命名空间名称及作用域限定符2.使用using namespace 命名空间名称引入3.使用using将命名空间中的成员引入C++中的输入和输出缺省参数全缺省半缺省参数函数重载函数重载的原理extern “C”引用引用的特征1.引用在定义时必须初始化2.一个变量可以有多个引用3.引用一旦引用了一个实体
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
深入详解C/C++动态内存管理
dvlinker的技术专栏
07-19 1万+
本文详细讲述了C/C++动态内存管理方面的内容，并具体阐述了几类常见的动态内存异常，以供大家借鉴或参考！
【AGC005D】~K Perm Counting（计数抽象成图）
2301_77025310的博客
10-01 318
注意到位置为id，权值为v ,不合法的情况，当且仅当 v = id+k或 v= id-k。dp(i,j,pd)表示考虑到第i号点， 连了j条边，是否有连接i 到 i-1号点。因此，我们把每一个位置和权值抽象成点 ，不合法的情况之间连一条边，可以构成二分图。由此可知，当选了n条边，就恰好n个位置不合法，限制条件是：连的边不能相邻，求出f(m) ，f(m)指代至少有m个位置不合法的方案数。由此总共有2n 个点 k 条链，链与链之间无边 互不干涉。把二分图展开成k条链，进行dp。简单的乘法原理罢了。
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 857
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 147
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
C++：图的最短路径问题
han2205277149的博客
10-04 712
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值