动态规划（三）打家劫舍和股票问题

AerialAce

已于 2023-06-05 23:58:48 修改

阅读量94

点赞数

分类专栏：算法文章标签：动态规划算法 leetcode

于 2023-06-05 23:58:34 首次发布

本文链接：https://blog.csdn.net/weixin_41029475/article/details/131035917

版权

算法专栏收录该内容

26 篇文章 0 订阅

订阅专栏

打家劫舍

198.打家劫舍

dp[i]，考虑下标为i，能够偷窃到的最高金额
dp[i] = max(dp[i-2]+nums[i],dp[i-1]);
dp[0]=nums[0],dp[1]=max(nums[0],nums[1])

class Solution {
    public int rob(int[] nums) {
        if(nums.length == 0)    return 0;        
        if(nums.length == 1)    return nums[0];
        int[] dp = new int[nums.length];
        dp[0]=nums[0];
        dp[1]=Math.max(nums[0],nums[1]);
        for(int i = 2; i < dp.length; i++){
            dp[i] = Math.max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[nums.length - 1];
    }
}

213.打家劫舍II

思路：分为两种情况，一种不考虑开头的房子，一种不考虑结尾的房子，然后分别调用打家劫舍1的代码，最后返回两者的最大值

class Solution {
    public int rob(int[] nums) {
        if(nums.length == 0)    return 0;
        if(nums.length == 1)    return nums[0];
        return Math.max(rob1(nums,0,nums.length - 2),rob1(nums,1,nums.length - 1));
    }

    public int rob1(int[] nums, int l, int r){
        if(r - l == 0)  return nums[l];
        int[]  dp = new int[r - l + 1];
        dp[0] = nums[l];
        dp[1] = Math.max(nums[l],nums[l+1]);
        for(int i = 2; i < dp.length; i++){
            dp[i] = Math.max(dp[i-2]+nums[i+l],dp[i-1]);
        }
        return dp[dp.length - 1];
    }
}

class Solution {
    public int rob(int[] nums) {
        if(nums.length == 0)    return 0;
        if(nums.length == 1)    return nums[0];
        return Math.max(rob1(nums,0,nums.length - 2),rob1(nums,1,nums.length - 1));
    }

    public int rob1(int[] nums, int l, int r){
        if(r - l == 0)  return nums[l];
        if(r - l == 1)  return Math.max(nums[l],nums[l+1]);
        int x = nums[l];
        int y = Math.max(x,nums[l+1]);
        int z = 0;
        for(int i = l+2; i <= r; i++){
            z = Math.max(x+nums[i],y);
            x = y;
            y = z;
        }
        return z;
    }
}

337.打家劫舍 III

总体思路：给每个节点设置偷与不偷俩个dp状态，通过后序递归遍历返回左右子节点的dp状态，计算当前节点的dp状态
DP解题步骤：

dp数组含义：考虑当前节点，dp[0]表示不偷当前节点时的最大金额，dp[1]表示偷当前节点时的最大金额；
dp[0] = max(ldp[0],ldp[1]+max(rdp[0],rdp[1]) ; dp[1] = ldp[0] + rdp[0] + val ；
初始化：空节点，偷与不偷都是返回0；
遍历顺序：使用后序遍历，利用函数返回值
举例推导：

class Solution {
    public int rob(TreeNode root) {
        int[] dp = robtree(root);
        return Math.max(dp[0],dp[1]);
    }
    public int[] robtree(TreeNode root){
        if(root == null)    return new int[]{0,0};
        int[] dp = new int[2];
        int[] ldp = robtree(root.left);
        int[] rdp = robtree(root.right);
        dp[0] = Math.max(ldp[0],ldp[1]) + Math.max(rdp[0],rdp[1]);
        dp[1] = ldp[0] + rdp[0] + root.val;
        return dp;
    }
}

股票问题

121. 买卖股票的最佳时机

暴力解法

//暴力解法
class Solution {
    public int maxProfit(int[] prices) {
        int res = 0;
        for(int i = 0; i < prices.length; i++){
            for(int j = i+1; j < prices.length; j++){
                res = Math.max(res,prices[j] - prices[i]);
            }
        }
        return res;
    }
}

贪心解法

取最左最小值，取最右最大值

class Solution {
    public int maxProfit(int[] prices) {
        int min = 10005;
        int res = 0;
        for(int i = 0; i < prices.length; i++){
            //记录左侧最小值
            min = Math.min(prices[i],min);
            //记录结果
            res = Math.max(res, prices[i] - min);
        }
        return res;
    }
}

动态规划

dp数组含义：dp[i][0]表示第i天结束后持有股票的所得最多现金，dp[i][1]表示第i天结束后不持有股票的所得最多现金；
递推公式：

第i天持有 = 【第i天买入，第i-1天不持有】 + 【第i-1天就持有】。dp[i][0] = max(-prices[i],dp[i-1][0])
第i天不持有 = 【第i天卖出，第i-1天持有】 +【第i-1天也不持有】。 dp[i][1] = max(dp[i-1][0]+prices[i],dp[i-1][1])
注意：由于本题股票全程只能买卖一次，所以如果买入股票，那么第i天持有股票即dp[i][0]一定就是 0-prices[i]

初始化：dp[0][0] = -prices[0]，dp[0][1] = 0，；

class Solution {
    public int maxProfit(int[] prices) {
        //1.dp[i][0]:第i天持有股票的状态，dp[i][1]:第i天不持有股票的状态
        int[][] dp = new int[prices.length][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for(int i = 1; i < prices.length; i++){
            //1.第i天才买入，注意本题只买卖一次
            //2.第i-1天就持有
            dp[i][0] = Math.max(-prices[i],dp[i-1][0]);
            //1.第i天卖出，第i-1天持有
            //2.第i-1天也不持有
            dp[i][1] = Math.max(dp[i-1][0]+prices[i],dp[i-1][1]);
        }
        return dp[prices.length - 1][1];
    }
}

一维数组优化

class Solution {
    public int maxProfit(int[] prices) {
        //1.dp[i][0]:第i天持有股票的状态，dp[i][1]:第i天不持有股票的状态
        int[] dp = new int[2];
        dp[0] = -prices[0];
        dp[1] = 0;
        for(int i = 1; i < prices.length; i++){
            //1.第i天才买入，注意本题只买卖一次
            //2.第i-1天就持有
            dp[0] = Math.max(-prices[i],dp[0]);            
            //1.第i天卖出，第i-1天持有
            //2.第i-1天也不持有
            dp[1] = Math.max(dp[0]+prices[i],dp[1]);

        }
        return dp[1];
    }
}

122.买卖股票的最佳时机II

动态规划

注意：本题因为一只股票可以买卖多次，所以当第i天买入股票的时候，所持有的现金可能有之前买卖过的利润。

class Solution {
    public int maxProfit(int[] prices) {
        //1.dp[i][0]:第i天持有股票的状态，dp[i][1]:第i天不持有股票的状态
        int[][] dp = new int[prices.length][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for(int i = 1; i < prices.length; i++){
            //1.第i天才买入，第i-1天不持有
            //2.第i-1天就持有
            dp[i][0] = Math.max(dp[i-1][1]-prices[i],dp[i-1][0]);
            //1.第i天卖出，第i-1天持有
            //2.第i-1天也不持有
            dp[i][1] = Math.max(dp[i-1][0]+prices[i],dp[i-1][1]);            
        }
        return dp[prices.length - 1][1];
    }
}

一维数组优化

class Solution {
    public int maxProfit(int[] prices) {
        //1.dp[i][0]:第i天不持有股票的状态，dp[i][1]:第i天持有股票的状态
        int[] dp = new int[2];
        dp[0] = 0;
        dp[1] = -prices[0];
        int temp = 0;
        for(int i = 1; i < prices.length; i++){
            //1.第i天卖出，第i-1天持有
            //2.第i-1天也不持有
            temp = dp[0];
            dp[0] = Math.max(dp[1]+prices[i],dp[0]);
            
            //1.第i天才买入，第i-1天不持有
            //2.第i-1天就持有
            dp[1] = Math.max(temp-prices[i],dp[1]);
        }
        return dp[0];
    }
}

贪心解法

想获得利润至少要两天为一个交易单元
最终利润是可以分解的，把利润分解为每天为单位的维度
局部最优：收集每天的正利润，全局最优：求得最大利润

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

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

dp数组含义：dp[i][0]表示第i天没有操作，dp[i][1]表示第i天第一次持有股票时的所得最多现金，dp[i][2]表示第i天第一次不持有股票时的所得最多现金，dp[i][3]表示第i天第二次持有股票时的所得最多现金，dp[i][4]表示第i天第二次不持有股票时的所得最多现金；
递推公式：

第i天不操作：dp[i][0] = dp[i - 1][0];
第i天第一次持有：【第i天买入，第i-1天不持有】 + 【第i-1天就持有】。dp[i][1] = max(-prices[i],dp[i-1][1])
第i天第一次不持有：【第i天卖出，第i-1天持有】 +【第i-1天不持有】。 dp[i][2] = max(dp[i-1][1]+prices[i],dp[i-1][2])
第i天第二次持有：【第i天第二次买入，第i-1天不持有】 + 【第i-1天就第二次持有】。dp[i][3] = max(dp[i-1][2]-prices[i],dp[i-1][3])
第i天第二次不持有：【第i天第二次卖出，第i-1天持有】 +【第i-1天第二次不持有】。 dp[i][4] = max(dp[i-1]3]+prices[i],dp[i-1][4])

初始化：dp[0][0] = 0, dp[0][1] = -prices[0]，dp[0][2] = 0，dp[0][3] = -prices[0]，dp[0][4] = 0；
遍历顺序：从小到大
举例推导

最大值一定是dp[i][4]，因为dp[i][4]也包含了dp[i][2]的值，当天买入再卖出即可

class Solution {
    public int maxProfit(int[] prices) {
        //dp[i][0]：第i天没有操作
        //dp[i][1]：第i天第一次持有股票时的所得最多现金
        //dp[i][2]：第i天第一次不持有股票时的所得最多现金
        //dp[i][3]：第i天第二次持有股票时的所得最多现金
        //dp[i][4]：第i天第二次不持有股票时的所得最多现金
        int len = prices.length;
        int[][] dp = new int[len][5];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        dp[0][2] = 0;
        dp[0][3] = -prices[0];
        dp[0][4] = 0;
        for(int i = 1; i < len; i++){
            dp[i][0] = dp[i-1][0];
            dp[i][1] = Math.max(dp[i-1][0]-prices[i],dp[i-1][1]);
            dp[i][2] = Math.max(dp[i-1][1]+prices[i],dp[i-1][2]);
            dp[i][3] = Math.max(dp[i-1][2]-prices[i],dp[i-1][3]);
            dp[i][4] = Math.max(dp[i-1][3]+prices[i],dp[i-1][4]);
        }
        return dp[len-1][4];
    }
}

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

dp数组含义：

dp[i][0]表示第i天没有操作
j为奇数时，dp[i][j]表示第i天第j/2+1次持有股票时的所得最多现金
j为偶数（大于0）时，dp[i][j]表示第i天第j/2次不持有股票时的所得最多现金

递推公式：

for(int j = 0; j < 2 * k; j+=2){
	//1.第i-1天不持有股票（dp[i-1][j]），第i天才购入股票（-prices[i]）
	//2.第i-1天就已经持有股票（dp[i-1][j+1]）
    dp[i][j+1] = Math.max(dp[i-1][j] - prices[i], dp[i-1][j+1]);
	//1.第i-1天持有股票（dp[i-1][j+1]），第i天才卖掉股票（+prices[i]）
	//2.第i-1天就已经不持有股票（dp[i-1][j+2]）
    dp[i][j+2] = Math.max(dp[i-1][j+1] + prices[i], dp[i-1][j+2]);
}

初始化

for(int i = 1; i < 2 * k ; i+=2){
	//奇数次为购入当前股票，初始化为 -prices[0]
    dp[0][i] = -prices[0];
}

遍历顺序
举例推导

代码：

class Solution {
    public int maxProfit(int k, int[] prices) {
        int len = prices.length;
        int[][] dp = new int[len][2*k+1];
        for(int i = 1; i < 2 * k ; i+=2){
            dp[0][i] = -prices[0];
        }
        for(int i = 1; i<len; i++){
            for(int j = 0; j < 2 * k; j+=2){
                dp[i][j+1] = Math.max(dp[i-1][j] - prices[i], dp[i-1][j+1]);
                dp[i][j+2] = Math.max(dp[i-1][j+1] + prices[i], dp[i-1][j+2]);
            }
        }
        return dp[len-1][2*k];
    }
}

309.最佳买卖股票时机含冷冻期

LeetCode题解
注意关注当天结束后的状态

dp含义：dp[i][0]:第i天结束后持有，dp[i][1]:第i天结束后不持有且处于冷冻期，dp[i][2]:第i天结束后不持有且不处于冷冻期。
状态转移：

dp[i][0]:第i天结束后持有。可能前一天i-1结束后就已经持有，对应状态dp[i-1][0]；或者今天i刚买入，那么前一天i-1结束后不持有且不处于冷冻期，对应状态dp[i-1][2]-prices[i];
dp[i][1]:第i天结束后不持有且处于冷冻期。说明当天卖出了股票，那么前一天i-1一定持有股票，对应状态dp[i][0] + prices[i]。
dp[i][2]:第i天结束后不持有且不处于冷冻期。说明当天i没有任何操作（没有买入也没有卖出）。若当天i处于冷冻期，说明前一天i-1卖出了股票，对应的状态为dp[i-1][1]；若当天i不处于冷冻期，对应的状态为dp[i-1][2]。

初始值：dp[0][0] = -prices[0]，持有时设置为 -prices[0]

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        int[][] dp = new int[len][3];
        dp[0][0] = -prices[0];
        for(int i = 1; i < len ; i++){
            dp[i][0] = Math.max(dp[i-1][0],dp[i-1][2]-prices[i]);
            dp[i][1] = dp[i-1][0] + prices[i];
            dp[i][2] = Math.max(dp[i-1][1],dp[i-1][2]);
        }
        return Math.max(dp[len - 1][1],dp[len - 1][2]);
    }
}

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

动态规划

122.买卖股票的最佳时机II，卖出时加上手续费即可。

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int len = prices.length;
        int[][] dp = new int[len][2];
        dp[0][0] = - prices[0];
        for(int i = 1; i < len; i++){
            dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]-prices[i]);
            dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]+prices[i]-fee);
        }
        return dp[len - 1][1];
    }
}

class Solution {
    public int maxProfit(int[] prices, int fee) {
        //转换思路，买入时先加上手续费
        int buy = prices[0] + fee;
        int res = 0;
        for(int i = 1; i < prices.length; i++){
            //如果当前价格小于之前buy的价格，那不如在当前价格购买更划算
            //如果当前buy是不计算手续费的price[i]，且prices[i]+fee < buy，说明此时卖出不仅可以赚回重新买入的手续费，且未来收益更大
            if(prices[i]+fee < buy) buy = prices[i] + fee;
            //如果当前价格高于buy，说明算上手续费，这次买卖也是正收益，但可能不是最大收益
            //先加上这次的收益，再设置buy为price[i]，若继续增大则可以继续加入到收益中
            if(prices[i] > buy){
                res+=prices[i] - buy;
                buy = prices[i];
            }
        }
        return res;
    }
}

AerialAce

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
动态规划（三）打家劫舍和股票问题

注意：本题因为一只股票可以买卖多次，所以当第i天买入股票的时候，所持有的现金可能有之前买卖过的利润。122.买卖股票的最佳时机II，卖出时加上手续费即可。，然后分别调用打家劫舍1的代码，最后返回两者的最大值。取最左最小值，取最右最大值。思路：分为两种情况，
复制链接

扫一扫