代码随想录——动态规划（二）:打家劫舍系列，买卖股票系列

最新推荐文章于 2024-06-28 15:02:50 发布
最新推荐文章于 2024-06-28 15:02:50 发布
阅读量718 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41433002/article/details/124013711
版权

题目来自《代码随想录》

文章目录

377. 组合总和 Ⅳ

完全背包问题看要求求的是组合数还是排列数

	//如果求组合数就是外层for循环遍历物品，内层for遍历背包。
	//如果求排列数就是外层for遍历背包，内层for循环遍历物品。
	public int combinationSum4(int[] nums, int target) {
		int[] dp = new int[target+1];
		dp[0] = 1;
		
		for(int j=0; j<target+1; j++){
			for(int i=0; i<nums.length; i++){
				if(j>=nums[i]) dp[j] += dp[j-nums[i]];
			}
		}
		return dp[target];
	}

70. 爬楼梯

	public int climbStairs(int n) {
        int[] stairs = new int[]{1,2};//每次可爬楼梯数
		int[] dp = new int[n+1];
		dp[0] = 1;
		for(int j=0; j<n+1; j++){
			for(int i=0; i<stairs.length; i++){
				if(j>=stairs[i]) dp[j] += dp[j-stairs[i]];
			}
		}
		return dp[n];
    }

322. 零钱兑换

https://leetcode-cn.com/problems/coin-change/

  1. 求组合数
  2. 初始化要初始化最大！因为要求min！
  3. 如果dp[j-coins[i]]就是max，那没有计算的必要
  4. 最后输出不是max才输出，否则输出-1
	//dp[i]:凑成金额所需的 最少的硬币个数
	//递推公式：dp[j] = min(dp[j - coins[i]] + 1, dp[j]);
	//dp[j]必须初始化为一个最大的数，否则就会在min(dp[j - coins[i]] + 1, dp[j])比较的过程中被初始值覆盖。!!!
	public int coinChange(int[] coins, int amount) {
		int[] dp = new int[amount+1]; 
        //初始化dp数组为最大值
        for (int j = 0; j < dp.length; j++) {
            dp[j] = Integer.MAX_VALUE;
        }
        //当金额为0时需要的硬币数目为0
        dp[0] = 0;
		for(int i=0; i<coins.length; i++){
			//System.out.println("当前i=" + i);
			for(int j=coins[i]; j<amount+1; j++){
				//只有dp[j-coins[i]]不是初始最大值时，该位才有选择的必要
				if (dp[j - coins[i]] != Integer.MAX_VALUE) dp[j] = Math.min(dp[j], dp[j-coins[i]]+1);
			}
		}
		return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
	}

279. 完全平方数

	//放入包中的物品是i*i
	public int numSquares(int n) {
		int[] dp = new int[n+1];
		int max = Integer.MAX_VALUE;
		for(int i=0; i<n+1; i++) dp[i]=max;
		dp[0] = 0;
		
		for(int i=1; i*i<=n; i++){
			for(int j=i*i; j<n+1; j++){
				if(dp[j-i*i] != max) dp[j] = Math.min(dp[j], dp[j-i*i]+1);
			}
		}		
		return dp[n]==max?-1:dp[n];
	}

139. 单词拆分

https://leetcode-cn.com/problems/word-break/

	/*
	 * 每个单词是物品，s是背包，物品能否把背包装满
	 * 例：s = "leetcode", wordDict = ["leet", "code"]，返回true
	 * 例：s = "applepenapple", wordDict = ["apple", "pen"]，返回true
	 * 
	 * dp[i]的含义：字符串长度为i的话，dp[i]为true，表示可以拆分为一个或多个在字典中出现的单词。
	 * 执行用时：11 ms, 在所有 Java 提交中击败了14.20%的用户
	 * 内存消耗：41.5 MB, 在所有 Java 提交中击败了43.14%的用户
	 */
	public boolean wordBreak(String s, List<String> wordDict) {
		boolean[] dp = new boolean[s.length()+1];
		dp[0] = true;
		for (int i = 1; i <= s.length(); i++) {//分割的最后一个字符的位置
            for (int j = 0; j < i; j++) {//当前单词开始 的位置
				/*
				 * 成为true的条件
				 * 1. 包含这个单词：wordDict.contains(s.substring(j,i))
				 * 2. 除了这个单词的前一部分也是true：valid[j]
				 */
            	if(wordDict.contains(s.substring(j,i)) && dp[j]) dp[i] = true;           	
			}
		}
		return dp[s.length()];
	}

198. 打家劫舍

	/*
	 * dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。
	 */
	public int rob(int[] nums) {
		int[] dp = new int[nums.length+1];
		dp[1] = nums[0];//第一家肯定偷了收益最高
		//show(nums);
		for(int i=2; i<nums.length+1; i++){
			//System.out.println(i);
			/*
			 * 1. 偷：dp[i-2]+nums[i]
			 * 2. 不偷：dp[i-1]
			 * 上面两个求max
			 */
			dp[i] = Math.max(dp[i-2]+nums[i-1], dp[i-1]);
		}
		return dp[nums.length];
	}

213. 打家劫舍 II

和上面一样，成环，两次考虑求max

	public int rob(int[] nums) {
        if (nums == null || nums.length == 0)
            return 0;
        int len = nums.length;
        if (len == 1)
            return nums[0];
        return Math.max(robAction(nums, 0, len - 1), robAction(nums, 1, len));
    }

    int robAction(int[] nums, int start, int end) {
        int x = 0, y = 0, z = 0;
        for (int i = start; i < end; i++) {
            y = z;
            z = Math.max(y, x + nums[i]);
            x = y;
        }
        return z;
    }

337. 打家劫舍 III

	/*
	 * 树形dp
	 * dp[2]当中存两个值，这个结点偷了的最多的钱，以及不透这个结点最多多少钱
	 */	
	//int[] dp = new int[2];//dp[0]偷的最多钱，dp[1]不偷的最多钱
	public int rob(TreeNode root) {
		int[] res = robaction(root);
        return Math.max(res[0], res[1]);
	}
	/*
	// 不偷：Max(左孩子不偷，左孩子偷) + Max(又孩子不偷，右孩子偷)
    // root[0] = Math.max(rob(root.left)[0], rob(root.left)[1]) +
    // Math.max(rob(root.right)[0], rob(root.right)[1])
    // 偷：左孩子不偷+ 右孩子不偷 + 当前节点偷
	 */
	public int[] robaction(TreeNode root) {
		int res[] = new int[2];
		if(root == null) return res;

		//后序遍历
		int[] l = robaction(root.left);
		int[] r = robaction(root.right);
		
		//如果当前偷，左不偷+右不偷+自己
		res[0] = l[1] + r[1] + root.val;
		//如果当前不偷，左右偷的max
		res[1] = Math.max(l[0], l[1]) + Math.max(r[0], r[1]);
		
		System.out.println("当前偷的结点为：" + root.name + "，val = " + root.val);
		System.out.println("偷：" + res[0] + "，不偷：" + res[1]);	
		
		return res;
	}

121. 买卖股票的最佳时机

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/

	/*
	 * 1. 暴力超时，202 / 211 个通过测试用例
	 */
	public int maxProfit(int[] prices) {
		int ans = Integer.MIN_VALUE;		
		for(int i=0; i<prices.length; i++){//买入天
			for(int j=i; j<prices.length; j++){//卖出天
				if((prices[j] - prices[i]) > ans) ans = prices[j] - prices[i];
			}
		}
		return ans;
	}
	
	@Test
	public void test(){
		int[] nums1 = new int[]{7,1,5,3,6,4};
		System.out.println(maxProfit2(nums1));
	}
	
	/*
	 * 2. 动态规划：差的累积什么时候变成负数了，什么时候重新买入
	 * 执行用时：3 ms, 在所有 Java 提交中击败了32.63%的用户
	 * 内存消耗：57.5 MB, 在所有 Java 提交中击败了45.50%的用户
	 */
	public int maxProfit2(int[] prices) {
		int difsum = 0;
		int res = 0;
		for(int i=1; i<prices.length; i++){
			difsum += (prices[i] - prices[i-1]);
			if(difsum < 0) difsum = 0;
			res = Math.max(difsum, res);
			System.out.println("res:" + res + ", difsum:" + difsum);
		}
		return res;
	}

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/

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

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/

	/*
	 * 一天一共就有五个状态，
	 * 1. 没有操作
	 * 2. 第一次买入
	 * 3. 第一次卖出
	 * 4. 第二次买入
	 * 5. 第二次卖出
	 * dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。
	 */
	public int maxProfit(int[] prices) {
		int[][] dp = new int[prices.length][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<prices.length; i++){
			//第i天持有一次买入的情况：1.前一天买了 2. 今天买入，两个求max
			dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0]-prices[i]);
			//第i天持有一次卖出的情况：1.前一天卖了 2. 今天卖，两个求max
			dp[i][2] = Math.max(dp[i-1][2], dp[i-1][1]+prices[i]);
			//第i天持有二次买入的情况：1.前一天买了 2. 今天买入，两个求max
			dp[i][3] = Math.max(dp[i-1][3], dp[i-1][2]-prices[i]);
			//第i天持有二次卖出的情况：1.前一天卖了 2. 今天卖，两个求max
			dp[i][4] = Math.max(dp[i-1][4], dp[i-1][3]+prices[i]);
		}
		//show(dp);
		return dp[prices.length-1][4];
	}

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv/

	/*
	 * 一天一共就有五个状态，
	 * 1. 没有操作
	 * 2. 第一次买入
	 * 3. 第一次卖出
	 * 4. 第二次买入
	 * 5. 第二次卖出
	 * dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。
	 */
	public int maxProfit(int k, int[] prices) {
		if( k==0 || prices.length==0) return 0;
		int len = prices.length;
		int[][] dp = new int[len][2*k+1];
		
		for(int i=0; i<2*k+1; i++){ //第一天初始化
			if(i%2 != 0) dp[0][i] = -prices[0];
		}
		
		for(int i=1; i<len; i++){
			for(int j=1; j<5; j++){
				if(j%2 == 1){//买入的情况
					dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-1]-prices[i]);
				}else{//卖出的情况
					dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-1]+prices[i]);
				}
			}
		}				
		return dp[len-1][2*k];
	}

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/

	/*
	 * 四个状态
	 * 1.买入股票状态
	 * 2.两天前就卖出了股票，度过了冷冻期，一直没操作，今天保持卖出股票状态
	 * 3.今天卖出了股票
	 * 4.冷冻期状态
	 */
	public int maxProfit(int[] prices) {
		int len = prices.length;
		int[][] dp = new int[len][4];
		
		dp[0][0] = -prices[0]; //第一天买入股票，其他三天都是0
		
		for(int i=1; i<len; i++){
			for(int j=0; j<4; j++){
				/*
				 * 一、买入股票状态
				 * 	1.今天买入的股票：-prices[i]
				 * 		前一天是冷冻期：dp[i - 1][3] - prices[i]
				 * 		前一天是状态二：dp[i - 1][1] - prices[i]
				 * 	2.保持了买入状态：dp[i-1][0]
				 */
				dp[i][0] = Math.max(dp[i-1][0], Math.max(dp[i-1][3], dp[i-1][1])-prices[i]);
				
				/*
				 * 二、度过冷冻期的卖出状态
				 * 	1.前一天是冷冻期：dp[i-1][1]
				 * 	2.前一天是状态二：dp[i-1][3]
				 */
				dp[i][1] = Math.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 Math.max(dp[len-1][1], Math.max(dp[len-1][2], dp[len-1][3]));
	}

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/

	/*
	 * 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 
	 * 即：dp[i - 1][0]
	 * 第i天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 
	 * 即：dp[i - 1][1] - prices[i]
	 * 
	 * 
	 * 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金
	 *  即：dp[i - 1][1]
	 *  第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金，注意这里需要有手续费了
	 *  即：dp[i - 1][0] + prices[i] - fee
	 */
	public int maxProfit1(int[] prices, int fee) {
	    int len = prices.length;
	    // 0 : 持股（买入）
	    // 1 : 不持股（售出）
	    // dp 定义第i天持股/不持股 所得最多现金
	    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][0] + prices[i] - fee, dp[i - 1][1]);
	    }
	    return Math.max(dp[len - 1][0], dp[len - 1][1]);
	}
平什么阿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
代码随想录训练营day51|309、最佳买卖股票时机含冷冻期；714、买卖股票的最佳时机含手续费；总结
weixin_43561267的博客
04-20 75
给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格；非负整数 fee 代表了交易股票的手续费用。你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。设计一个算法计算出最大利润。注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格。只是动态规划递推公式里多减去了一个费用而已。返回获得利润的最大值。四种状态比较难分析。
Leetcode:122. 买卖股票的最佳时机 II(贪心算法）
stackempty2的博客
09-21 202
122. 买卖股票的最佳时机 II 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 示例 1: 输入: [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 随后，在第 4 天（股票价格 = 3）的时候
代码随想录章节目录—力扣算法题系列：数组.Java版（可点击文中超链接跳转到想看的题目）
放下华子我只抽RuiKe5的博客
08-16 116
数组是非常基础的数据结构，在面试中，考察数组的题目一般在思维上都不难，主要是考察对代码的掌控能力也就是说，想法很简单，但实现起来 可能就不是那么回事了。首先要知道数组在内存中的存储方式，这样才能真正理解数组相关的面试题数组是存放在连续内存空间上的相同类型数据的集合。数组可以方便的通过下标索引的方式获取到下标下对应的数据。举一个字符数组的例子，如图所示：需要两点注意的是数组下标都是从0开始的。数组内存空间的地址是连续的正是。
代码随想录算法训练营第38、39天 | 509. 斐波那契数 70. 爬楼梯 746. 使用最小花费爬楼梯 62.不同路径 63. 不同路径 II
lebowskii的博客
10-29 434
day 38 39
【代码随想录】-回溯专题
一舟的博客
01-06 1114
而满足回溯条件的某个状态的点称为“回溯点”。许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。回溯算法其实就是一个不断探索尝试的过程，探索成功了也就成功了，探索失败了就在退一步，继续尝试……回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）。的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，，因为回溯法解决的都是在集合中递归查找子集，回溯算法实际上一个类似。
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
代码随想录全套文档 动态规划、回溯、递归、二叉树、贪心
「代码随想录」动态规划专题精讲（v1.2）.pdf
07-15
「代码随想录」动态规划专题精讲（v1.2）.pdf
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录算法PDF.rar
08-06
代码随想录算法PDF.rar
代码随想录刷题笔记
m0_50120894的博客
03-14 1964
前言 作者是一名普通本科大二学生，近期购置了Carl学长的代码随想录。同时我也加入了代码随想录星球，准备按照书上的顺序进行一下算法的学习，大概会保持每天一题的进度。会在CSDN上更新自己的进度，当做打卡，也会写一些反思和总结，希望能提高自己的算法水平。 使用的是leetcode网站进行刷题，leetcode网站有对应的学生会员，有一定的优惠。目前使用的语言是java。因为接下来可能有软件的课，准备熟悉一下这种语言。 leetcode 704 二分查找 题目链接 思路总结： 二分查找，取中间值，然
代码随想录1刷—链表篇
h0327x的博客
06-24 330
通过自己定义构造函数初始化节点： 使用默认构造函数初始化节点： 所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！注意：C++里最好是再手动释放这个D节点，释放这块内存。 双指针 递归 707.设计链表 206.反转链表 双指针 递归 24.两两交换节点 递归 19.删除链表的倒数第N个节点 双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。注意几个细节：1
随想录学习笔记目录
Tommy__li的博客
08-08 334
2022.8.6 ，正式开始了刷题的道路，现在是准大三，希望最后这半年可以有一个质的飞跃，在明年秋招能获得想要的offer。也因为卡哥的原因，想要用Markdown来记笔记，让自己可以能够更好的复习，比goodnote更好用，更方便。这个专栏主要记录自己在刷算法题中遇到的问题，为二刷做准备！ps：目录先这样了 后面再慢慢完善例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。......
LeetCode 算法：二叉树的直径 c++
小金牛来了
06-24 1165
LeetCode 算法：二叉树的直径 c++
代码随想录算法训练营第52天（py）| 动态规划 | 647. 回文子串、516.最长回文子序列
uncle_tou的博客
06-28 421
给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。
day54--面试专题（基础篇）
最新发布
ZHUSHANGLIN的博客
06-28 1044
有一个有序表为 1,5,8,11,19,22,31,35,40,45,48,49,50 当二分查找值为 48 的结点时，查找成功需要比较的次数。使用二分法在序列 1,4,6,7,15,33,39,50,64,78,75,81,89,96 中查找元素 81 时，需要经过（ ）次比较。② A[M] > T，中间值右侧的其它元素都大于 T，无需比较，中间索引左边去找，M - 1 设置为右边界，重新查找。将数组分为两个子集，排序的和未排序的，每一轮从未排序的子集中选出最小的元素，放入排序子集。
【代码随想录】【算法训练营】【第49天】 [300]最长递增子序列 [674]最长连续递增序列 [718]最长重复子数组
weixin_54954007的博客
06-24 465
思路及算法思维，指路。题目来自。day 49，周二，坚持不了一点~
指针的相关知识
m0_49236682的博客
06-24 1418
2.空指针： 指针指向 NULL (零地址)。所谓指针数组是指由若干个具有相同存储类型和数据类型的指针变量构成的集合。//指针数组名就表示该指针数组的存储首地址，即指针数组名为数组的指针。1.野指针： 指针指向不明确，被称为野指针。野指针一旦使用就段错误。注意：万能指针使用前必须强制转换为对应数据类型的指针。3.空类型指针(万能指针)：可以指向任意类型的地址。行指针 是一个指针， 指向的元素是一维数组。是一个数组，元素是一个一个的指针。存储行地址的指针变量，叫做行指针变量。例如，int a[2][4];
leetcode动态规划算法详细讲解
08-29
动态规划，英⽂：Dynamic Programming，简称DP，如果某⼀问题有很多重叠⼦问题，使⽤动态规划是最有效的。 所以动态规划中每⼀个状态⼀定是由上⼀个状态推导出来的，这⼀点就区分于贪⼼，贪⼼没有状态推导，⽽是从局部直接选最优的.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

平什么阿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值