【动态规划二】简单多状态dp问题

已于 2024-05-05 00:30:25 修改
阅读量897 收藏 26
点赞数 21
分类专栏： 算法 文章标签： 动态规划 算法 leetcode
于 2024-05-04 17:31:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74126249/article/details/138427235
版权

目录

leetcode题目

一、按摩师

二、打家劫舍

三、打家劫舍 II

四、删除并获得点数

五、粉刷房子

六、买卖股票的最佳时机

七、买卖股票的最佳时机 II

八、买卖股票的最佳时机含冷冻期

九、买卖股票的最佳时机含手续费

十、买卖股票的最佳时机 III

十一、买卖股票的最佳时机 IV

大家在看本篇博客可以先去看一下我的第一篇动态规划的博客，这样会更加容易理解本篇博客的下列题目：

【动态规划一】斐波拉契数列模型 && 路径问题-CSDN博客文章浏览阅读409次，点赞15次，收藏16次。状态表示是指dp表(一维数组/二维数组)里面的值所表示的含义如何得到状态表示?1.1 题目要求1.2 经验 + 题目要求1.3 分析问题的过程中，发现重复子问题。https://blog.csdn.net/m0_74126249/article/details/138358428?spm=1001.2014.3001.5501

leetcode题目

一、按摩师

面试题 17.16. 按摩师 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/the-masseuse-lcci/description/1.题目解析

给定一个数组，数组元素表示预约时间，不能选择数组相邻元素，求最长的预约时长

2.算法分析

1.状态表示

dp[i]: 选择到 i 位置的时候，此时的最长预约时长

--->i位置可以选，可以不选，进一步细化

f[i]:选择到i位置的时候，nums[i]必选，此时的最长预约时长

g[i]:选择到i位置的时候，nums[i]不选，此时的最长预约时长

2.状态转移方程

注意题目说了不能选相邻的~

3.初始化

f[0] = nums[0], g[0] = 0;

4.填表顺序

从左向右两个表一起填

5.返回值

max(f[n-1], g[n-1])

3.算法代码

class Solution {
public:
    int massage(vector<int>& nums)
    {
        //1.创建dp表
        int n = nums.size();
        if(n == 0) return 0; //处理边界情况
        vector<int> f(n), g(n);
        //2.初始化dp表   
        f[0] = nums[0];
        //3.填表
        for(int i = 1; i < n; i++)
        {
            f[i] = g[i-1] + nums[i];
            g[i] = max(f[i-1], g[i-1]);
        }
        //4.返回值
        return max(f[n-1], g[n-1]);
    }
};

二、打家劫舍

198. 打家劫舍 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/house-robber/description/

1.题目解析

给定一个数组，数组元素表示房屋的金额，不能偷相邻房屋的金额，求能偷到的最大金额

2.算法分析

本质和题目一按摩师没有任何区别

1.状态表示

dp[i]: 偷到 第i个房屋的时候，此时偷到的最大金额

--->i位置可以选，可以不选，进一步细化

f[i]:偷到第i个房屋的时候，偷nums[i], 此时偷到的最大金额

g[i]: 偷到第i个房屋的时候，不偷nums[i], 此时偷到的最大金额

2.状态转移方程

f[i] = g[i-1] + nums[i]

g[i] = max(f[i-1], g[i-1]

3.初始化

f[0] = nums[0], g[0] = 0;

4.填表顺序

从左向右两个表一起填

5.返回值

max(f[n-1], g[n-1])

3.算法代码

class Solution {
public:
    int rob(vector<int>& nums) 
    {
        //1.创建dp表
        int n = nums.size();
        vector<int> f(n), g(n);
        //2.初始化dp表
        f[0] = nums[0];
        //3.填表
        for(int i = 1; i < n; i++)  
        {
            f[i] = g[i-1] + nums[i];
            g[i] = max(f[i-1], g[i-1]);
        }
        //4.返回值
        return max(f[n-1], g[n-1]);
    }
};

三、打家劫舍 II

213. 打家劫舍 II - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/house-robber-ii/1.题目解析

给定一个数组，首尾是相邻的(本质是个环)，每个元素代表金额，不能偷相邻元素的金额，求能偷到的最大金额数

2.算法分析

本题目本质就是题目一"按摩师"的变形，最大的区别就是收尾相邻的，我们可以尝试将本题转化成题目一

我们可以分类讨论，分为偷0位置的金额和不偷0位置的金额，如果偷0位置的金额，那么1位置和n-1位置的金额都不能偷了，相当于(2, n-2)位置的"按摩师"问题；如果不偷0位置的金额，那么就是(1, n-1)位置的"按摩师"问题，只需要求这两种情况偷到的金额的最大值即可

1.状态表示

f[i]: 偷到i位置的时候，偷nums[i]，此时偷到的最大金额

g[i]: 偷到i位置的时候，不偷nums[i]，此时偷到的最大金额

2.状态转移方程

f[i] = g[i-1] + nums[i]

g[i] = max(f[i-1], g[i-1])

3.初始化

f[0] = nums[0], g[0] = 0;

4.填表顺序

从左向右两个表一起填

5.返回值

max(f[n-1], g[n-1])

3.算法代码

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

    int rob1(vector<int>& nums, int left, int right)
    {
        if(left > right) return 0; //处理边界情况
        //1.创建dp表
        int n = nums.size();
        vector<int> f(n), g(n);
        //2.初始化dp表
        f[left] = nums[left];
        //3.填表
        for(int i = left + 1; i <= right; i++)
        {
            f[i] = g[i-1] + nums[i];
            g[i] = max(f[i-1], g[i-1]);
        }
        //4.返回值
        return max(f[right], g[right]);
    }
};

四、删除并获得点数

740. 删除并获得点数 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/delete-and-earn/description/1.题目解析

数组中可能有重复元素，每次选择删除值为 x 的元素，将获得 x 大小的点数，同时 x + 1 与 x - 1大小的数组元素将都被删除，求最终能够获得的最大点数

2.算法分析

这道题我们本质可以转化成"打家劫舍"问题~

我们可以先给nums数组排序，排完序之后如果想转化成打家劫舍问题，必须是相邻的位置不能选，而相邻的位置点数关系不一定刚好差1，而下标是连续的，因此我们可以开辟一个新的数组

nums数组的值为x，就将arr数组中下标位x的位置填充上nums数组中所有x的和, 这样的话arr数组相邻位置就不能选了，我们就可以在arr数组上进行"打家劫舍"了

1.状态表示

f[i]: 选到 i 位置的时候，选arr[i]，此时获得的最大点数

g[i]: 选到 i 位置的时候，不选arr[i]，此时获得的最大点数

2.状态转移方程

f[i] = g[i-1] + arr[i]

g[i] = max(f[i-1], g[i-1])

3.初始化

f[0] = nums[0], g[0] = 0;

4.填表顺序

从左向右两个表一起填

5.返回值

max(f[n-1], g[n-1])

3.算法代码

class Solution {
public:
    int deleteAndEarn(vector<int>& nums) 
    {
        const int N = 10001; //题目说了，数据最大是10000
        //1.预处理
        int arr[N] = {0};
        for(auto x : nums)
            arr[x] += x;

        //2."打家劫舍"
        //2.1 创建dp表
        vector<int> f(N), g(N);
        //2.2 初始化dp表
        f[0] = arr[0]; //可以不用写，arr数组已经初始化成了0
        //2.3 填表
        for(int i = 1; i < N; i++)
        {
            f[i] = g[i-1] + arr[i];
            g[i] = max(f[i-1], g[i-1]);
        }
        //2.4 返回值
        return max(f[N-1], g[N-1]);
    }
};

五、粉刷房子

LCR 091. 粉刷房子 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/JEj789/description/1.题目解析

有一排房子，每个房子可以粉刷成红蓝绿，但是相邻房子颜色不同粉刷不同颜色的成本不同，粉刷成本题目是以n×3的矩阵给出的，costs[i][0], costs[i][1], costs[i][2]分别表示第i个房子粉刷成红、蓝、绿的成本,  求粉刷完所有房子的最小花费成本

2.算法分析

1.状态表示

dp[i]: 粉刷到 i 位置的时候，此时的最小花费,  而第i个房子颜色有三种选择，进一步细化:

dp[i][0]: 粉刷到 i 位置的时候，i位置粉刷红色，此时的最小花费

dp[i][1]: 粉刷到 i 位置的时候，i位置粉刷蓝色，此时的最小花费

dp[i][2]: 粉刷到 i 位置的时候，i位置粉刷绿色，此时的最小花费

2.状态转移方程

以dp[i][0]为例，i位置粉刷红色，由于相邻位置颜色不能相同，因此i-1位置只能粉刷蓝色/绿色，此时的最小花费就是i-1位置粉刷蓝色/绿色的最小花费加上i位置的花费

dp[i][0] = min(dp[i-1][1], dp[i-1][2]) + costs[i][0]

dp[i][1] = min(dp[i-1][0], dp[i-1][2]) + costs[i][1]

dp[i][2] = min(dp[i-1][0], dp[i-1][1]) + costs[i][2]

3.初始化

添加虚拟头节点即可, 注意下标的映射关系~

4.填表顺序

从左向右三个表一起填

5.返回值

min(dp[n][0], dp[n][1], dp[n][2])

3.算法代码

class Solution {
public:
    int minCost(vector<vector<int>>& costs) 
    {
        //1.创建dp表
        int n = costs.size();
        vector<vector<int>> dp(n+1, vector<int>(3)); 
        //2.初始化dp表
        dp[0][1] = dp[0][1] = dp[0][2] = 0; //vector默认是0, 可以不用初始化
        //3.填表
        for(int i = 1; i <= n; i++)
        {
            dp[i][0] = min(dp[i-1][1], dp[i-1][2]) + costs[i-1][0];
            dp[i][1] = min(dp[i-1][0], dp[i-1][2]) + costs[i-1][1];
            dp[i][2] = min(dp[i-1][0], dp[i-1][1]) + costs[i-1][2];
        }
        //4.返回值
        return min(min(dp[n][0], dp[n][1]), dp[n][2]);
    }
};

六、买卖股票的最佳时机

121. 买卖股票的最佳时机 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/1.题目解析

给定prices数组，prices[i]表示一支给定的股票在第i天的价格，可以选择在任意一天买入股票，并在未来的某一天卖出，求能获得的最大利润

ps：本题从头到尾只能完成一笔交易

2.算法分析

1.状态表示

dp[i]: 第 i 天结束的时候，此时获得的最大利润 ---> 进一步细化

dp[i][0]: 第 i 天结束的时候，处于"买入"状态，此时获得的最大利润

dp[i][1]: 第 i 天结束的时候，处于"卖出"状态，此时获得的最大利润

2.状态转移方程 --- 根据最近的一步划分问题

第i天结束时，处于"买入"状态, 则第i-1天结束时，可以处于"买入"状态，第i天什么都不做即可；第i-1天结束时, 也可以处于"卖出"状态(因为只有1支股票, 本质是还没有买入过), 第i天买入了, 支付了prices[i]的费用！

dp[i][0] = max(dp[i-1][0], -prices[i])

第i天结束时，处于"卖出"状态, 则第i-1天结束时，可以处于"卖出"状态，第i天什么都不做即可；第i-1天也可以处于"买入"状态, 第i天将股票卖出, 获得prices[i]的利润！

dp[i][1] = max(dp[i-1][1],  dp[i-1][0] + prices[i])

3.初始化

dp[0][0] = -prices[0], dp[0][1] = 0

4.填表顺序

从左向右两个表一起填

5.返回值

dp[n-1][1]

ps: 最后一天结束时手上还有股票，一定不会获得最大利润~

3.算法代码

class Solution {
public:
    int maxProfit(vector<int>& prices) 
    {
        //1.创建dp表
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2));
        //2.初始化dp表
        dp[0][0] = -prices[0];
        //3.填表
        for(int i = 1; i < n; 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]);
        }
        //4.返回值
        return dp[n-1][1];
    }
};

七、买卖股票的最佳时机 II

122. 买卖股票的最佳时机 II - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/1.题目解析

与题目五的区别在于，没有限制可以完成多少笔交易，只要最后利润最大即可~

2.算法分析

1.状态表示

dp[i]: 第 i 天结束的时候，此时获得的最大利润 ---> 进一步细化

dp[i][0]: 第 i 天结束的时候，处于"买入"状态，此时获得的最大利润

dp[i][1]: 第 i 天结束的时候，处于"卖出"状态，此时获得的最大利润

2.状态转移方程 --- 根据最近的一步划分问题

第i天结束时，处于"买入"状态, 则第i-1天结束时，可以处于"买入"状态，第i天什么都不做即可；第i-1天结束时, 也可以处于"卖出"状态,  第i天买入了, 支付了prices[i]的费用！

dp[i][0] = max(dp[i-1][0],  dp[i-1][1] - prices[i])

第i天结束时，处于"卖出"状态, 则第i-1天结束时，可以处于"卖出"状态，第i天什么都不做即可；第i-1天也可以处于"买入"状态, 第i天将股票卖出, 获得prices[i]的利润！

dp[i][1] = max(dp[i-1][1],  dp[i-1][0] + prices[i])

3.初始化

dp[0][0] = -prices[0], dp[0][1] = 0

4.填表顺序

从左向右两个表一起填

5.返回值

dp[n-1][1]

ps: 最后一天结束时手上还有股票，一定不会获得最大利润~

3.算法代码

class Solution {
public:
    int maxProfit(vector<int>& prices) 
    {
        //1.创建dp表
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2));
        //2.初始化dp表
        dp[0][0] = -prices[0];
        //3.填表
        for(int i = 1; i < n; 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]);
        }
        //4.返回值
        return dp[n-1][1];
    }
};

八、买卖股票的最佳时机含冷冻期

309. 买卖股票的最佳时机含冷冻期 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/1.题目解析

与题目六的区别在于 股票卖出后，第二天处于冷冻期，不能买入，必须等冷冻期解除后才能买入股票

2.算法分析

1.状态表示

dp[i]: 第 i 天结束之后，此时的最大利润 ---> 可以继续细分

dp[i][0]: 第 i 天 结束之后，处于"买入状态", 此时的最大利润

dp[i][1]: 第 i 天 结束之后，处于"可交易状态"(冷冻期已经解封了), 此时的最大利润

dp[i][2]: 第 i 天 结束之后，处于"冷冻期"(刚把股票卖出去了), 此时的最大利润

2.状态转移方程

3.初始化

dp[0][0] = -prices[0],  dp[0][1] = 0, dp[0][2] = 0(当天买了又卖)

4.填表顺序

从左向右三个表一起填

5.返回值

max(dp[n-1][1], dp[n-1][2])  

ps:最后一天手里还有股票，也就是处于"买入状态"是不可能获得最大利润的~

3.算法代码

class Solution {
public:
    int maxProfit(vector<int>& prices) 
    {
        //1.创建dp表
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(3));
        //2.初始化dp表
        dp[0][0] = -prices[0];
        //3.填表
        for(int i = 1; i < n; 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][2]);
            dp[i][2] = dp[i-1][0] + prices[i];
        }
        //4.返回值
        return max(dp[n-1][1], dp[n-1][2]);
    }
};

九、买卖股票的最佳时机含手续费

714. 买卖股票的最佳时机含手续费 - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/1.题目解析

本题与前面题目的不同就是一笔交易要支付一次手续费，可以在买入股票的时候支付手续费,也可以再卖出的时候支付手续费

2.算法分析

1.状态表示

dp[i]: 第 i 天结束的时候，此时获得的最大利润 ---> 进一步细化

dp[i][0]: 第 i 天结束的时候，处于"买入"状态，此时获得的最大利润

dp[i][1]: 第 i 天结束的时候，处于"卖出"状态，此时获得的最大利润

2.状态转移方程 --- 根据最近的一步划分问题

2.1 卖出的时候支付费用

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)

2.2买入的时候支付费用

dp[i][0] = max(dp[i-1][0],  dp[i-1][1] - prices[i] - fee)

dp[i][1] = max(dp[i-1][1],  dp[i-1][0] + prices[i])

3.初始化

3.1 卖出的时候支付费用

dp[0][0] = -prices[0], dp[0][1] = 0

3.2 买入的时候支付费用

dp[0][0] = -prices[0] - fee, dp[0][1] = 0

4.填表顺序

从左向右两个表一起填

5.返回值

dp[n-1][1]

ps: 最后一天结束时手上还有股票，一定不会获得最大利润~

3.算法代码

3.1 卖出的时候支付费用

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee)
    {
        //1.创建dp表
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2));
        //2.初始化
        dp[0][0] = -prices[0];
        //3.填表
        for(int i = 1; i < n; 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);
        }
        //4.返回值
        return dp[n-1][1];
    }
};

3.2 买入的时候支付费用

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee)
    {
        //1.创建dp表
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2));
        //2.初始化
        dp[0][0] = -prices[0] - fee;
        //3.填表
        for(int i = 1; i < n; i++)
        {
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] - prices[i] - fee);
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] + prices[i]);
        }
        //4.返回值
        return dp[n-1][1];
    }
};

十、买卖股票的最佳时机 III

123. 买卖股票的最佳时机 III - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/1.题目解析

本题限制了最多完成两笔交易~

2.算法分析

1.状态表示

dp[i]: 第 i 天结束的时候，此时获得的最大利润 ---> 进一步细化(本题为了方便解释，就不用n×2的数组表示了，而是直接用两个表)

f[i] 第 i 天结束的时候，处于"买入"状态，此时获得的最大利润

g[i]: 第 i 天结束的时候，处于"卖出"状态，此时获得的最大利润

但是本题还有交易次数的限制，因此我们还要给f和g表加一个表示交易次数的维度

f[i][j]: 第i天结束的时候，完成了j笔交易，处于"买入"状态，此时获得的最大利润

g[i][j]:第i天结束的时候，完成了j笔交易，处于"卖出"状态，此时获得的最大利润

2.状态转移方程

f[i][j] = max(f[i-1][j], g[i-1][j] - prices[i]）

g[i][j] = max(g[i-1][j], f[i-1][j-1] + prices[i])

3.初始化

由于g[i][j]状态转移方程中用到了 i -1 和 j - 1, 因此我们本应该初始化一行和一列，但是我们可以稍微修改一下g[i][j]的状态转移方程就可以更加方便初始化

①g[i][j] = g[i-1][j]

②if(j - 1 >= 0)  g[i][j] = max(g[i][j], f[i-1][g-1] + prices[i])

此时只需要将f表和g表的第一行进行初始化即可

f[0][j]表示在第1天的时候，处于"买入"状态，获得的最大利润

g[0][j]表示在第1天的时候，处于"卖出"状态，获得的最大利润

为了获得最大利润，我们应该要尽可能珍惜交易次数，所以无论是买入还是卖出，我们都希望在第一天是0笔交易，因此 f[0][1] 与 f[0][2] 与 g[0][1] 与 g[0][2] 都初始化成 负无穷，这样求max就不会影响后续结果， 而f[0][0] = -prices[0], g[0][0] = 0

细节问题: 如果将上述几个值初始化成 负无穷, f[i][j] = max(f[i-1][j], g[i-1][j] - prices[i]） 这个转移方程中，g[i-1][j]还会减去一个正数，就会超出int的最小值，因此在做题中一个常用的值是 0x3f3f3f3f3f, 为啥设置成这个值，大家可以参考下面的博客

【算法设计与数据结构】为何程序员喜欢将INF设置为0x3f3f3f3f？_数据结构inf设值-CSDN博客文章浏览阅读4.1w次，点赞328次，收藏499次。在算法竞赛中，我们常常需要用到一个“无穷大”的值，对于我来说，大多数时间我会根据具体问题取一个99999999之类的数（显得很不专业啊！）在网上看别人代码的时候，经常会看到他们把INF设为0x7fffffff，奇怪为什么设一个这么奇怪的十六进制数，一查才知道，因为这是32-bit int的最大值。如果这个无穷大只用于一般的比较（比如求最小值时min变量的初值），那么0x7fffffff确实是一个完美_数据结构inf设值https://blog.csdn.net/jiange_zh/article/details/501980974.填表顺序

从上往下填每一行，每一行从左往右，两个表一起填

5.返回值

g 表最后一行的最大值(最后一天的时候，交易1笔，2笔，一直到 j 笔交易，这些值中的最大)

ps:  f 表表示的是"买入状态"，绝对不可能是最终结果

3.算法代码

class Solution {
public:
    const int INF = 0x3f3f3f3f;
    int maxProfit(vector<int>& prices) 
    {
        //1.创建dp表
        int n = prices.size();
        vector<vector<int>> f(n, vector<int>(3, -INF));
        auto g = f;
        //2.初始化dp表
        f[0][0] = -prices[0], g[0][0] = 0;
        //3.填表
        for(int i = 1; i < n; i++)
        {
            for(int j = 0; j < 3; j++)
            {
                f[i][j] = max(f[i-1][j], g[i-1][j] - prices[i]);
                g[i][j] = g[i-1][j];
                if(j >= 1) 
                    g[i][j] = max(g[i][j], f[i-1][j-1] + prices[i]);
            }
        }
        //4.返回值
        int ret = 0;
        for(int j = 0; j < 3; j++)
            ret = max(ret, g[n-1][j]);
        return ret;
    }
};

十一、买卖股票的最佳时机 IV

188. 买卖股票的最佳时机 IV - 力扣（LeetCode）icon-default.png?t=N7T8https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/1.题目解析

本题限制了最多完成 k 笔交易~

2.算法分析

有了题目九的详细分析，本题就是把题目九的两笔交易改成了k笔交易，大家直接改代码中的for循环次数即可, 注意vector的列数要变一下~

3.算法代码

class Solution {
public:
    const int INF = 0x3f3f3f3f;
    int maxProfit(int k, vector<int>& prices) 
    {
        //1.创建dp表
        int n = prices.size();
        vector<vector<int>> f(n, vector<int>(k + 1, -INF));
        auto g = f;
        //2.初始化dp表
        f[0][0] = -prices[0], g[0][0] = 0;
        //3.填表
        for(int i = 1; i < n; i++)
        {
            for(int j = 0; j <= k; j++)
            {
                f[i][j] = max(f[i-1][j], g[i-1][j] - prices[i]);
                g[i][j] = g[i-1][j];
                if(j >= 1) 
                    g[i][j] = max(g[i][j], f[i-1][j-1] + prices[i]);
            }
        }
        //4.返回值
        int ret = 0;
        for(int j = 0; j <= k; j++)
            ret = max(ret, g[n-1][j]);
        return ret;
    }
};

编程之路，妙趣横生
关注
  • 21
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划（多个状态同时dp）
luojiushenzi的博客
04-28 932
A. Vacationstime limit per test1 secondmemory limit per test256 megabytesinputstandard inputoutputstandard outputVasya has n days of vacations! So he decided to improve his IT skills and do sport. Vas...
动态规划算法（多状态dp1）
m0_52882232的博客
06-16 547
多状态dp问题，有限状态机
[线性DP] UVa1625 颜色长度 （LRJ代码）（多状态DP）
OI - IceCab
07-08 237
题目 思路 1.本题可以说是有难度了，首先思路就不好想到，DP有两个状态，两个状态分别有自己的状态转移方程。其次代码实现起来，细节很多，自己尝试写了一下，debug了一下午也没搞出来，只能搬来LRJ的代码了。 2.回顾一下本题的思考过程： 首先，可以想到LCS，因为每次都是从两个序列种的一个拿元素。最基本的状态就想到了，d(i,j)，表示从两个序列分别拿走i,j个元素后最小的指标函...
DP：简单多状态模型
weixin_51142926的博客
03-26 1220
多状态dp表示第i天的时候可能的状态不同，所以我们要去区分不同的状态。
【算法优选】 动态规划之简单多状态dp问题——壹
m0_71731682的博客
01-19 1264
动态规划相关题目都可以参考以下五个步骤进行解答：状态表⽰状态转移⽅程初始化填表顺序返回值后面题的解答思路也将按照这五个步骤进行讲解。
动态规划-dp(电路布线问题).pptx
05-30
动态规划-dp(电路布线问题) 动态规划是一种数学优化方法和计算机编程方法，美国应用数学家 Richard Bellman 于 1953 年引入动态规划。它既可以解决复杂的问题，又可以应用于多个领域，如航空工程、经济学等。动态...
动态规划的一些简单问题课件
11-02
动态规划是一种解决问题的方法，通常用于优化复杂度，通过将问题分解为子问题来解决。在本课件中，我们将探讨动态规划的一些基本概念，以及它在不同类型的背包问题中的应用。 首先，动态规划的引入是通过求解...
动态规划之选数问题_动态规划_
10-01
动态规划是一种强大的算法工具，广泛应用于计算机科学，特别是在优化问题中。这个主题“动态规划之选数问题”探讨了如何利用动态规划解决一类特定的选择或组合问题。MATLAB作为一种强大的数值计算和编程环境，是实现...
背包问题动态规划.zip
11-16
2. **初始化**：对于所有状态 `dp[i][w]`，当 `w=0` 或 `i=0` 时，问题变得简单，可以初始化为0，因为不装入任何物品或没有物品可装时，总价值为0。 3. **状态转移方程**：对于每个物品 `i` 和每个容量 `w`，我们有...
DP.rar_动态规划初级程序_水库调度
09-23
标题中的“DP.rar_动态规划初级程序_水库调度”揭示了我们要探讨的主题是关于动态规划在解决水库调度问题上的应用。动态规划是一种优化技术，它通过将大问题分解为更小的子问题来求解，通常用于处理具有重叠子问题和...
fjnu1362 收集样本问题 多状态dp
秋叶红于二月花
04-09 680
给定一个由n*n个方格组成的地图,每个方格都有一个价值,从左上角到右下角走两次,每一步只能朝右或者朝下走,一个方格内的价值只能获取一次,求可获取的最大总价值. 谜之作业题,不会做,看答案之后 状态表示: 以距原点的曼哈顿距离递增进行dp,同时对两次进行. dp[x1][x2][s]表示从原点第一次到(x1,s-x1),第二次到(x2,s-x2)所能收集的最大总价值,s为目标点到原点的曼...
【算法优选】 动态规划之简单多状态dp问题——贰
m0_71731682的博客
04-10 1607
动态规划相关题目都可以参考以下五个步骤进行解答：状态表示状态转移⽅程初始化填表顺序返回值后面题的解答思路也将按照这五个步骤进行讲解。
Monkey and Banana HDU - 1069 结构体记录多状态 （基础dp专题）
qq_45891413的博客
09-10 135
一组研究人员正在设计一项实验，以测试猴子的智商。他们将挂香蕉在建筑物的屋顶，同时，提供一些砖块给这些猴子。如果猴子足够聪明，它应当能够通过合理的放置一些砖块建立一个塔，并爬上去吃他们最喜欢的香蕉。 研究人员有n种类型的砖块，每种类型的砖块都有无限个。第i块砖块的长宽高分别用xi，yi，zi来表示。 同时，由于砖块是可以旋转的，每个砖块的3条边可以组成6种不同的长宽高。 在构建塔时，当且仅当A砖块的长和宽都分别小于B砖块的长和宽时，A砖块才能放到B砖块的上面，因为必须留有一些空间让猴子来踩。 你的任务是编写一
状态dp学习、
傻傻分不清、
07-24 551
练习衔接：传送门
算法合集：动态规划（二）——状态dp
mlgseminent的博客
10-01 902
动态规划（二）：状态dp
动态规划之状态压缩dp入门
热门推荐
qxAi的博客
02-04 5万+
状态压缩动态规划（简称状压dp）是另一类非常典型的动态规划，通常使用在NP问题的小规模求解中，虽然是指数级别的复杂度，但速度比搜索快，其思想非常值得借鉴。 为了更好的理解状压dp，首先介绍位运算相关的知识。 1.’&’符号，x&y，会将两个十进制数在二进制下进行与运算，然后返回其十进制下的值。例如3(11)&2(10)=2(10)。 2.’|’符号，x|y，会将两个十进制数在二进制下进行或运
【18】输出字符菱形
最新发布
2301_78786609的博客
07-19 346
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 238
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值