动态规划：打家劫舍&买卖股票

最新推荐文章于 2023-04-24 14:49:18 发布
最新推荐文章于 2023-04-24 14:49:18 发布
阅读量157 收藏 1
点赞数
分类专栏： C++刷题八股文 文章标签： 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42138662/article/details/119913148
版权

一、打家劫舍

1、基础

  1. 打家劫舍
    你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
    给定一个代表每个房屋存放金额的非负整数数组nums，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

1）dp数组含义

dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]

2）递推公式

对于第i间房屋，可以分为两种情况：

  • 不偷第i间房屋：dp[i] = dp[i - 1]
  • 偷第i间房屋：dp[i] = dp[i - 2] + nums[i]

3）dp数组初始化

dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]);

4）遍历方式

从头遍历到结尾：for (int i = 2; i < nums.size(); i++)

2、进阶

  1. 打家劫舍 II
    你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

该题目只是多了一个环形结构，根据题目中给定的条件，我们可以将环形结构分为两个直线结构，转变为基础题：
注意：这里的取是考虑的意思，取头不取尾是肯定不偷尾房间，但也不一定偷头房间，只是将头房间纳入要不要偷的考虑范围内

  • 取头不取尾
    在这里插入图片描述
  • 取尾不取头
    在这里插入图片描述
    最后再取两者最大值即可。动态规划过程中的dp数组含义，递推公式，初始化方法，遍历顺序和基础题相同。
class Solution {
private:
	/-----基础题：打家劫舍动态规划模块-----/
    int robByIndex(vector<int>& nums, int begIndex, int endIndex){
        if(begIndex == endIndex) return nums[begIndex];
        vector<int> dp(endIndex - begIndex + 1, 0);
        dp[0] = nums[begIndex];
        dp[1] = max(nums[begIndex], nums[begIndex + 1]);
        for(int i = 2; i < endIndex - begIndex + 1; i++){
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[begIndex + i]);
        }
        return dp[endIndex - begIndex];
    }
public:
	/-----分两种情况讨论-----/
    int rob(vector<int>& nums) {
        if(nums.size() == 1) return nums[0];
        int res1 = robByIndex(nums, 0, nums.size() - 2);
        int res2 = robByIndex(nums, 1, nums.size() - 1);
        return max(res1, res2);
    }
};

3、打家劫舍的树形动态规划

337. 打家劫舍 III
在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

这道题是一个典型的树形dp，需要融合dp和递归来进行解题

1）dp数组含义

这里使用二维的dp数组记录一个节点的两个状态：偷该节点，不偷该节点

2）递归参数与返回值

递归参数为当前节点，返回值为当前节点的dp数组

3）递归终止条件（终止条件即为dp数组初始化）

当前节点为空，偷不偷都是0： if (cur == NULL) return vector{0, 0};

4）遍历顺序（递归顺序）

由于根节点依赖于叶子节点，因此为后序遍历

5）单层递归逻辑（dp数组推导公式）

cur为当前节点

// 偷cur
int val1 = cur->val + left[0] + right[0];
// 不偷cur
int val2 = max(left[0], left[1]) + max(right[0], right[1]);
return {val2, val1};

6）解题代码

class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> result = robTree(root);
        return max(result[0], result[1]);
    }
    // 长度为2的数组，0：不偷，1：偷
    vector<int> robTree(TreeNode* cur) {
        if (cur == NULL) return vector<int>{0, 0};
        vector<int> left = robTree(cur->left);
        vector<int> right = robTree(cur->right);
        // 偷cur
        int val1 = cur->val + left[0] + right[0];
        // 不偷cur
        /---这里注意仍然要比较一下，不一定要偷左孩子或右孩子---/
        int val2 = max(left[0], left[1]) + max(right[0], right[1]);	
        return {val2, val1};
    }
};

由于dp数组只有只有两维，因此可以使用pair进行优化。相较于vector，pair占用内存更小，运行更快。

class Solution {
private:
    pair<int, int> robTree(TreeNode* root){
        if(root == nullptr) return{0, 0};

        pair<int, int> left = robTree(root->left);
        pair<int, int> right = robTree(root->right);

        int getRoot = root->val + left.first + right.first;
        int noGetRoot = max(left.first, left.second) + max(right.first, right.second);

        return{noGetRoot, getRoot};
    }
public:
    int rob(TreeNode* root) {
        pair<int, int> res = robTree(root);
        return max(res.first, res.second);
    }
};

二、买卖股票

1、单次买卖，持有一支

121. 买卖股票的最佳时机
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

1）dp数组含义

我们使用二维数组记录第i天的两种状态
dp[i][0]:第i天不持有股票手中的现金
dp[i][1]:第i天持有股票手中的现金

2）递推公式

如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来

  • 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
  • 第i天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i](注意：这里是因为只限制了买一次股票，因此如果第i天买入，手中现金就是-prices[i]，和前一天没有关系)

那么dp[i][0]应该选所得现金最大的，所以dp[i][0] = max(dp[i - 1][0], -prices[i]);

如果第i天不持有股票即dp[i][1]， 也可以由两个状态推出来

  • 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
  • 第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1][0]

同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

3）初始化

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

4）遍历顺序

从前往后遍历

5）最后返回值

最后返回一定是dp[prices.size() - 1][1]，因为最后一天的时候肯定是不持有股票才能赚钱

6）解题代码

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

7）pair优化

由于dp数组第二个维度只有两维，因此可以使用pair进行优化

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<pair<int, int>> dp(prices.size());

        dp[0].first = -prices[0];
        dp[0].second = 0;

        for(int i = 1; i < prices.size(); i++){
            dp[i].first = max(dp[i - 1].first, -prices[i]);
            dp[i].second = max(dp[i - 1].second, dp[i - 1].first + prices[i]);
        }

        if(dp[prices.size() - 1].second < 0) return 0;
        return dp[prices.size() - 1].second;
    }
};

8）滚动数组

由于dp数组只有两个维度，因此可以使用滚动数组优化为一维dp数组

// 版本二
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            dp[i % 2][0] = max(dp[(i - 1) % 2][0], -prices[i]);
            dp[i % 2][1] = max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
        }
        return dp[(len - 1) % 2][1];
    }
};

2、多次买卖，持有一支

122.给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

和单次买卖相比，只有递推公式发生了变化：

如果第i天持有股票即dp[i].first， 那么可以由两个状态推出来

  • 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1].first
  • 第i天买入股票，所得现金就是买入今天的股票后所得现金即：dp[i - 1].second - prices[i](注意：这里是因为只限制了买一次股票，因此如果第i天买入，手中现金就是-prices[i]，和前一天没有关系)

那么dp[i][0]应该选所得现金最大的，所以dp[i].first = max(dp[i - 1].first, dp[i - 1].second - prices[i]);

1）动态规划解法

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 0) return 0;
        vector<pair<int, int>> dp(prices.size());

        dp[0].first = - prices[0];
        dp[0].second = 0;

        for(int i = 1; i < prices.size(); i++){
            dp[i].first = max(dp[i-1].first, dp[i - 1].second - prices[i]);
            dp[i].second = max(dp[i - 1].second, dp[i - 1].first + prices[i]);
        }
        
        if(dp[prices.size() - 1].second < 0) return 0;
        return dp[prices.size() - 1].second; 
    }
};

2）贪心算法

本题还可以使用贪心算法解决，收集每天的正收益即可

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

3）滚动数组

// 版本二
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 2大小的二维数组
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            dp[i % 2][0] = max(dp[(i - 1) % 2][0], dp[(i - 1) % 2][1] - prices[i]);
            dp[i % 2][1] = max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
        }
        return dp[(len - 1) % 2][1];
    }
};

3、2次买卖，持有一支

123. 买卖股票的最佳时机 III
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

1）dp数组

当最多买卖两次的时候，一天的状态可以有四个：

  • dp[i][0]：第一次买入状态
  • dp[i][1]：第一次卖出状态
  • dp[i][2]：第二次买入状态
  • dp[i][3]：第二次卖出状态
    注意：这个状态是一个持续的过程，如第一次买入后，第二次买入前，均处于第一次买入状态

2）递推公式

每个状态都分为当天发生该状态和该状态在之前发生过两种，取两者最大值即可。注意第一次买入如果是当前买入，dp[i][0] = -prices[i]，因为第一次买入前手中现金就是0

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]);

3）初始化

dp[0][0] = -prices[0];
dp[0][0] = 0;
dp[0][2] = -prices[0];
dp[0][3] = 0;

注意：在初始化过程中dp[0][2]也要初始化为-prices[0]，虽然第一天不可能买第二次。题目要求最多买卖两次，但我们根据实际情况可能只买卖了一次，或者不买卖，这样初始化：

  • 在我们只买卖一次的时候将dp[i][0]和dp[i][1]的状态同步到了dp[i][2]和dp[i][3]；
  • 当我们买卖多次的时候，dp[i][0]和dp[i][1]在买卖一次后保持不变，dp[i][2]和dp[i][3]仅需在买卖第一次赚的钱基础上进行变化

这样，不管我们买卖了几次，dp[i][3]均是在要求内赚的最多的钱

4）遍历顺序

从前到后

5）代码实现

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 0) return 0;

        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、k次买卖，持有一支

188. 买卖股票的最佳时机 IV
给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

这个就是把2次买卖拓展为k次买卖，在dp数组推导的时候写成循环即可

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
    	/---特殊情况处理---/
        if(k == 0 || prices.size() == 0) return 0;

		/---dp数组定义，第一维度为天数，第二维度为每天的状态数-----/
        vector<vector<int>> dp(prices.size(), vector<int>(2 * k, 0));

		/---初始化dp数组，每个交易状态均初始化为-prices[0]-----/
        for(int i = 0; i <= 2 * k - 1; i = i + 2){
            dp[0][i] = -prices[0];
        }

		/---递推公式，第一次买入特殊处理，其余买入卖出使用循环处理----/
        for(int i = 1; i < prices.size(); i++){
            dp[i][0] = max(dp[i - 1][0], -prices[i]);
            for(int j = 1; j <= 2 * k - 1; j++){
                if(j % 2 == 1) dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] + prices[i]); //卖出
                if(j % 2 == 0) dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] - prices[i]); //买入
            }
        }

        /---不管买卖了多少次，最后一天最后一个状态就是赚的钱---/
        return dp[prices.size() - 1][2 * k - 1];
    }
};

5、多次买卖，持有一支，有冷却期

1）dp数组

由于包含了冷却期，将卖出状态分割成为了卖出当天，冷却期，卖出了且过了冷却期三个状态，因此一天有四种状态，因此：

  • dp[i][0]:买入股票状态（今天买入股票，或者是之前就买入了股票然后没有操作）
  • dp[i][1]:两天前就卖出了股票，度过了冷冻期，一直没操作，今天保持卖出股票状态
  • dp[i][2]:今天卖出了股票
  • dp[i][3]:今天为冷冻期状态，但冷冻期状态不可持续，只有一天

2）递推公式

			 /---如果是之前买了，今天保持;如果今天买了，则昨天可能是状态1或3---/
             dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][1], dp[i - 1][3]) - prices[i]); 
             dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]); //状态1的昨天可能是状态1或3
             dp[i][2] = dp[i - 1][0] + prices[i];  //状态2的昨天只能为状态0
             dp[i][3] = dp[i - 1][2];  //状态3的昨天只能为状态1

3）初始化

第一天买入状态初始化为-prices[0]
dp[0][0] = -prices[0];

4）遍历顺序

从前到后

5）返回值

由于卖出状态分割成为了卖出当天，冷却期，卖出了且过了冷却期三个状态，因此最后赚的最多的钱为最后一天三个状态的最大值

6）解题代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 0) return 0;
         vector<vector<int>> dp(prices.size(), vector<int>(4, 0));

         dp[0][0] = -prices[0];

         for(int i = 1; i < prices.size(); i++){
             dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][1], dp[i - 1][3]) - prices[i]);
             dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
             dp[i][2] = dp[i - 1][0] + prices[i];
             dp[i][3] = dp[i - 1][2];
         }

         return max(dp[prices.size() - 1][1], max(dp[prices.size() - 1][2], dp[prices.size() - 1][3]));


    }
};

6、多次买卖，持有一支，有手续费

  1. 买卖股票的最佳时机含手续费
    给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。
    你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。返回获得利润的最大值。
    注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

这个类型只是在买卖股票（多次买卖，持有一支）的基础上在当天卖出的时候多减去手续费。如果题目修改成买入也需要手续费的话，同理。

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        if(prices.size() == 0) return 0;

        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(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];
            
    }
};
我只是一只自动小青蛙
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划之股票买卖系列问题
小朱小朱绝不认输的博客
11-26 1950
文章目录一、股票买卖系列问题二、leetcode例题讲解股票买卖系列问题121. 买卖股票的最佳时机122. 买卖股票的最佳时机 II123. 买卖股票的最佳时机 III188. 买卖股票的最佳时机 IV309. 最佳买卖股票时机含冷冻期714. 买卖股票的最佳时机含手续费 动态规划问题还有一系列股票买卖的经典问题。在这里进行汇总学习。 一、股票买卖系列问题 121. 买卖股票的最佳时机：股票只能买卖一次。 122. 买卖股票的最佳时机 II：股票可以多次买卖。 123. 买卖股票的最佳时机 III：股票最
动态规划：经典题目汇总
hefrankeleyn的博客
10-02 3579
动态规划：经典题目汇总 文章目录动态规划：经典题目汇总一、动态规划的定义二、经典例题3.1 一维的DP：斐波那契数列、[使用最小花费爬楼梯](https://leetcode-cn.com/problems/min-cost-climbing-stairs/)3.2 二维的DP：不同路径1、不同路径2、最小路径和3.3 字符串变化的DP：最长公共子序列三、动态规划实战题目3.1 爬楼梯3.2 最小路径和3.3 最大子序列和、乘积最大子序列3.4 零钱兑换（和爬楼梯问题有异曲同工之妙）3.5 打家劫舍1、打家
动态规划（七）：买卖股票发大财
qq_42138662的博客
07-05 295
一、买卖股票（单次买卖，持有一支） 121. 买卖股票的最佳时机 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 1、dp数组含义 我们使用二维数组记录第i天的两种状态 dp[i][0]:第i天不持有股票手中的现金 dp[i][1]:第i天持有股票手
动态规划 - 买卖股票
毕业才是起点
03-20 751
动态规划的算法本质 本质上就是穷举状态，然后在选择中选择最优解 你只要记住状态和选择两个词即可 以上面的题目为例子 穷举框架 dp[i][k][0 or 1] 0 <= i <= n - 1, 1 <= k <= K n 为天数，大 K 为交易数的上限，0 和 1 代表是否持有股票。 此问题共 n × K × 2 种状态，全部穷举就能搞定。 for 0 <= i < n: for 1 <= k <= K: for s in {
浅谈什么是动态规划以及相关的「股票」算法题
程序员吴师兄的博客
05-07 363
动态规划1 概念   动态规划算法是通过拆分问题，定义问题状态和状态之间的关系，使得问题能够以递推（或者说分治）的方式去解决。在学习动态规划之前需要明确掌握几个重要概念。...
121. 买卖股票的最佳时机
weixin_43425544的博客
03-09 164
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock 著作权归领扣网络所有。商业转载请联系官.
动态规划算法详解（打家劫舍、买卖股票、单词拆分、爬楼梯等经典问题）
04-13
在编程领域，动态规划广泛应用于诸如爬楼梯、打家劫舍、买卖股票和单词拆分等一系列经典问题。 首先，让我们看看爬楼梯问题。假设你站在地面上，要到达楼梯顶部，每次可以走1步或2步。动态规划解决方案是通过维护一...
手撕力扣之动态规划：爬楼梯、不同路径、最小路径和、三角形最小路径和、买卖股票的最佳时机、打家劫舍1和2、最小花费爬楼梯、礼物的最大价值、剪绳子、连续子数组的最大和、乘积最大子数组、单词拆分、最大正方形
weixin_39770712的博客
11-09 281
力扣120. 三角形最小路径和 DP自下向上（二位数组） class Solution { public: int minimumTotal(vector<vector<int>>& triangle) { // 行数 int n = triangle.size(); // 从倒数第二行开始 for (int i = n - 2; i >= 0; i--) {
算法分享系列No.7--(大厂面试实际问题) 股票买卖系列 & 打家劫舍问题
尕白白的专栏
05-13 353
一、该类题目---基础信息列表 背景 大厂面试算法题，为了显示高逼格，显示高档次，经常跟实际问题相结合，想要考察面试人，从实际问题转化成熟悉的解题模型，灵活运用能力。近期问了些面试字节的朋友，30%都考到了股票。本次这类题型的梳理，也是对自己解决这类算法的一个总结。 初了岛屿问题属于DFS模式以外，其余的实际问题基本都是 动态规划，贪心思路，希望看完本文，能够通过各个算法的解题思路，对这两个算法----动态规划，贪心，如何解题有一个深度的了解！更能体会到大厂面试的套路。
【Leetcode 309】买入股票的最佳时机含冷冻期
qq_41972012的博客
04-29 219
问题描述： 给定一个整数数组，其中第i个元素代表了第i天的股票价格 。​ 设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。 测试用例： 输入: [1,2,3,0,2] 输出: 3 解释: 对应的交易状...
买卖股票的最佳时机
qq_41266084的博客
10-25 129
买卖股票的最佳时机 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。 注意：你不能在买入股票前卖出股票。 示例 1: 输入: [7,1,5,3,6,4] 输出: 5 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。 解答
股票买卖-动态规划
HeavenWalker
09-23 517
股票买卖之动态规划讲解-思路简单，容易掌握本质
[Leetcode] 买卖股票合集（动态规划）
皮卡丘在充电
01-16 1903
买卖股票的最佳时机
动态规划之买卖股票问题
weixin_62275996的博客
03-05 815
动态规划算法本质上就是穷举「状态」，然后在「选择」中选择最优解。 这个问题的「状态」有三个，第一个是天数，第二个是允许交易的最大次数，第三个是当前的持有状态（即之前说的rest的状态，我们不妨用 1 表示持有，0 表示没有持有）。然后我们用一个三维数组就可以装下这几种状态的全部组合： 比如说dp[3][2][1]的含义就是：今天是第三天，我现在手上持有着股票，至今最多进行 2 次交易。再比如dp[2][3][0]的含义：今天是第二天，我现在手上没有持有股票，至今最多进行 3 次交易。
动态规划学习-买卖股票
m0_58228798的博客
05-08 142
一. 题目描述： 动态规划分析： 代码： class Solution { public: int maxProfit(vector<int>& prices) { int n=prices.size(); vector<vector<int> > dp(n,vector<int>(2,0)); dp[0][1]=-prices[0]; for(int i=1;
动态规划--买卖股票问题详解
weixin_63894681的博客
11-10 780
代码随想录训练营 买卖股票问题合集。
动态规划---买卖股票的最佳时机
m0_51431003的博客
09-27 2555
动态规划---买卖股票的最佳时机
动态规划之—状态机模型(股票买卖 IV、股票买卖 V)
最新发布
chp的博客
04-24 312
这道题没有交易次数的限制，但是有了冷却时间，我们需要添加一维来表示冷却时间。首先画出状态机模型，有两种状态：手中有货和手中无货，手中有货可以继续保持，或者卖掉。手中有货可以继续保持，或者买入。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值