动态规划买卖股票/打家劫舍/零钱兑换专题

最新推荐文章于 2024-03-06 13:27:41 发布

ForwardSummer

最新推荐文章于 2024-03-06 13:27:41 发布

阅读量316

点赞数

分类专栏：数据结构与算法 Java leetcode 文章标签：动态规划买卖股票零钱兑换

本文链接：https://blog.csdn.net/weixin_45532984/article/details/127190910

版权

Java 同时被 3 个专栏收录

59 篇文章 5 订阅

订阅专栏

leetcode

51 篇文章 6 订阅

订阅专栏

数据结构与算法

24 篇文章 0 订阅

订阅专栏

一. 股票问题/打家劫舍/零钱兑换概述

买股票问题，小偷问题和零钱兑换是动态规划中经常遇到的问题，也是面试笔试经常爱考的问题，掌握这些基础的方法和思路是很有必要的。

买卖股票的问题的关注点在于今天的股票状态以及构成今天股票的状态从何而来。

打家劫舍的问题的关注点在于当前家要不要偷

零钱兑换的问题的关注点在于当前硬币要不要（转换为背包问题）

如果还不懂背包问题，可看看这篇文章算法-动态规划-背包问题

二. leetcode实战

1. leetcode121 买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

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

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

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        //当天持有股票或者不持有股票
        int[][] dp = new int[prices.length][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for(int i = 1; i < prices.length; 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],-prices[i]);
        }
        return dp[len-1][0];
    }
}

本题小结：（1）dp[i][j]表示第i天，这只股票要不要的情况，那么j只有两种情况

（2）由于股票只得买一次，抛售一次，所以在第i天买入是-prices[i]

特别的【1】：

dp[i][0]：规定了今天不持股，有以下两种情况：

昨天不持股，今天什么都不做；
昨天持股，今天卖出股票（现金数增加）
dp[i][1]：规定了今天持股，有以下两种情况：

昨天持股，今天什么都不做（现金数与昨天一样）；
昨天不持股，今天买入股票（注意：只允许交易一次，因此手上的现金数就是当天的股价的相反数）。

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

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在同一天出售。返回你能获得的最大利润。

输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
总利润为 4 + 3 = 7 。

class Solution {
    public int maxProfit(int[] p) {
        int[][] dp = new int[p.length][2];
        dp[0][0] = 0;
        dp[0][1] = -p[0];
        for(int i = 1; i < p.length; i++){
            //不持有股票
            dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]+p[i]);
            //持有股票
            dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]-p[i]);
        }
        return dp[p.length-1][0];
    }
}

本题小结：（1）和上题对比：

//没有持有股票:昨天也没有持有股票，昨天持有股票但是今天卖掉了
dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]+prices[i]);
//持有股票:昨天没有持有股票，今天买的,昨天有股票
dp[i][1] = Math.max(dp[i-1][1],-prices[i]);、

//不持有股票
dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]+p[i]);
//持有股票
dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]-p[i]);

唯一区别在于在持有股票时，既可能是昨天已经持有，今天也持有，不变，或者是，昨天没有持有，但是今天持有，昨天没有持有但是会有累计值。

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

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

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

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

示例 :

输入：prices = [3,3,5,0,0,3,1,4]
输出：6
解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天（股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。

class Solution {
    public int maxProfit(int[] prices) {
        if(prices == null || prices.length < 2) return 0;
        int len = prices.length;
        int[][][] dp = new int[len][2][3];
        int min_value = Integer.MIN_VALUE>>1;
        dp[0][0][0] = 0;         //无任何操作
        dp[0][0][1] = min_value; //非持有状态但是有一次股票卖出，不合理，设为min_value
        dp[0][0][2] = min_value; //非持有状态但是又二次股票卖出，不合理，设为min_value
        dp[0][1][0] = -prices[0];//持有状态,无卖出的次数，合理
        dp[0][1][1] = min_value; //持有状态，卖出过一次，不合理，设为min_value
        dp[0][1][2] = min_value; //持有状态，有两次卖出，不合理，设为min_value
        for(int i = 1; i < len; i++){
            dp[i][0][0] = 0;                                              //不持有股票，一次没卖出，设为0
            dp[i][0][1] = Math.max(dp[i-1][0][1],dp[i-1][1][0]+prices[i]);//不持有但卖过一次了，也许昨天不持有或昨天持有，今天卖了
            dp[i][0][2] = Math.max(dp[i-1][0][2],dp[i-1][1][1]+prices[i]);//不持有但卖过两次了，也许昨天不持有或昨天持有，今天卖了
            dp[i][1][0] = Math.max(dp[i-1][1][0],dp[i-1][0][0]-prices[i]);//持有一次没卖，也许昨天持有，或昨天不持有今天买的
            dp[i][1][1] = Math.max(dp[i-1][1][1],dp[i-1][0][1]-prices[i]);//持有卖过一次，也许昨天持有，或昨天不持有今天买的
            dp[i][1][2] = min_value;                                      //在持有股票的状态下还卖出过两次，不合理，设为min_value
        }
        return Math.max(0,Math.max(dp[len-1][0][1],dp[len-1][0][2]));
    }
}

状态的初始值：

dp[0][0][0] = 0; //无任何操作
dp[0][0][1] = min_value; //非持有状态但是有一次股票卖出，不合理，设为min_value
dp[0][0][2] = min_value; //非持有状态但是又二次股票卖出，不合理，设为min_value
dp[0][1][0] = -prices[0];//持有状态,无卖出的次数，合理
dp[0][1][1] = min_value; //持有状态，卖出过一次，不合理，设为min_value
dp[0][1][2] = min_value; //持有状态，有两次卖出，不合理，设为min_value

状态转移：

不持有股票，一次没卖出，设为0

dp[i][0][0] = 0;

不持有但卖过一次了，也许昨天不持有或昨天持有，今天卖了
dp[i][0][1] = Math.max(dp[i-1][0][1],dp[i-1][1][0]+prices[i])

不持有但卖过两次了，也许昨天不持有或昨天持有，今天卖了，最需要注意的地方，卖2次要从卖一次的状态转换而来
dp[i][0][2] = Math.max(dp[i-1][0][2],dp[i-1][1][1]+prices[i])

持有一次没卖，也许昨天持有，或昨天不持有，今天买的
dp[i][1][0] = Math.max(dp[i-1][1][0],dp[i-1][0][0]-prices[i])

持有并且卖过一次，也许昨天持有，或昨天不持有，今天买的
dp[i][1][1] = Math.max(dp[i-1][1][1],dp[i-1][0][1]-prices[i])

在持有股票的状态下还卖出过两次，不合理，设为min_value
dp[i][1][2] = min_value;

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

给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格。

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

输入: prices = [1,2,3,0,2]
输出: 3
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        int[][] dp = new int[len][3];
        dp[0][0] = 0;//没有买卖为0
        dp[0][1] = -prices[0];//买进
        dp[0][2] = 0;//没有买卖(初始没有)
        for(int i = 1; i < len; i++){
            dp[i][0] = Math.max(dp[i-1][0],dp[i-1][2]);//当前无股票，无股票可能因为本来就没有股票
            dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]-prices[i]);//当前有股票，可能因为前一天有或者从前一天没有且今天买入，不可能是冷静期
            dp[i][2] = dp[i-1][1]+prices[i];//当前没有股票，处于冷静期，在前一天卖出了股票
        }
        return Math.max(dp[len-1][0],dp[len-1][2]);
    }
}

本题小结：（1）在卖出和买入之间穿插一个新的状态，看图更好理解，图源【3】

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

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格；整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

输入：prices = [1, 3, 2, 8, 4, 9], fee = 2
输出：8
解释：能够达到的最大利润:
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int len = prices.length;
        int[][] dp = new int[len][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0]-fee;
        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][0];
    }
}

本题小结：（1）此题和122如出一辙，只是多了个fee

（2）因为买入卖出只需要一次fee，加在一边即可

6. leetcode322 零钱兑换

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。

计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1 。

你可以认为每种硬币的数量是无限的。

输入：coins = [1, 2, 5], amount = 11
输出：3
解释：11 = 5 + 5 + 1

class Solution {
    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount+1];
        Arrays.fill(dp,amount+1);
        dp[0] = 0;
        for(int i = 0; i < coins.length; i++){
            for(int j  = coins[i]; j <= amount; j++){
                dp[j] = Math.min(dp[j],dp[j-coins[i]]+1);
            }
        }
        if(dp[amount] > amount) return -1;
        return dp[amount];
    }
}

本题小结：（1）完全背包，所以可以取本层，dp[j]

（2）正序，从coins[i]开始取，且dp[0] = 0，因为不需要一个硬币即可达成

（3）刚开始给dp赋值为一个不可能的数，更新结束后，还是amount+1证明不能凑出来

7. leetcode518 零钱兑换II

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。

题目数据保证结果符合 32 位带符号整数。

输入：amount = 5, coins = [1, 2, 5]
输出：4
解释：有四种方式可以凑成总金额：
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1


class Solution {
    public int change(int amount, int[] coins) {
        int[] dp = new int[amount+1];
        dp[0] = 1;
        //状态转移方程
        for(int i = 0; i < coins.length; i++){
            for(int j = coins[i]; j <= amount; j++){
                dp[j] += dp[j-coins[i]];
            }
        }
        return dp[amount];
    }
}

本题小结：（1）背包，完全背包，重点在于dp[j] += dp[j-coins[i]]，此题不再求min和max，而是状态的累加值

（2）初始值dp[0] = 1只有当不选取任何硬币时，金额之和才为 00，因此只有 1 种硬币组合【4】

8. leetcode198 打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

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

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。

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

本体小结：（1）当前状态由两个状态转换而来，一是偷，二是不偷

（2）如果是偷，则昨天不能偷，状态由前天转换而来：dp[i] = dp[i-2]+nums[i]

（3）如果是不偷，状态可以由昨天转换而来：dp[i] = dp[i-1]

9. leetcode213 打家劫舍II

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

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，今晚能够偷窃到的最高金额。
输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

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

本题小结：（1）选了头就不能选尾，二选一

（2）复制产生两个新的数组，都遍历一遍即可

10. leetcode337 打家劫舍III

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。

除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

给定二叉树的 root 。返回在不触动警报的情况下，小偷能够盗取的最高金额。

输入: root = [3,2,3,null,3,null,1]
输出: 7
解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7

class Solution {
    public int rob(TreeNode root) {
        int[] dp = Erg(root); 
        return Math.max(dp[0],dp[1]);
    }
    public int[] Erg(TreeNode root){
        if(root == null) return new int[]{0,0};

        int[] dp1 = Erg(root.left);
        int[] dp2 = Erg(root.right);

        int[] dp = new int[2];
        dp[0] = Math.max(dp1[0],dp1[1]) + Math.max(dp2[0],dp2[1]);//当前节点不偷，左右孩子节点可以偷或者不偷
        dp[1] = root.val + dp1[0] + dp2[0];//当前节点偷
        return dp;
    }
}

本题小结：（1）只考虑当前节点偷和不偷的问题

（2）当前节点偷那么就是root.val + dp1[0] + dp2[0]

（3）当前节点不偷就可以左右子节点都偷，对于其中一个左子节点来说，也可以选择偷和不偷，那么最终取其中的最大值

参考来源：【1】leetcode liweiwei1419 暴力解法、动态规划（Java）

【2】leetcode MarcusXu 通俗易懂的动态规划解法

【3】leetcode liweiwei1419 动态规划（Java）

【4】 leetcode leetcode官方解题零钱兑换 II

ForwardSummer

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
动态规划买卖股票/打家劫舍/零钱兑换专题

买股票问题，小偷问题和零钱兑换是动态规划中经常遇到的问题，也是面试笔试经常爱考的问题，掌握这些基础的方法和思路是很有必要的。买卖股票的问题的关注点在于今天的股票状态以及构成今天股票的状态从何而来。打家劫舍的问题的关注点在于当前家要不要偷零钱兑换的问题的关注点在于当前硬币要不要（转换为背包问题）
复制链接

扫一扫