122.买卖股票的最佳时机II 55. 跳跃游戏 45.跳跃游戏II
122.买卖股票的最佳时机II
力扣题目链接(opens new window)
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
- 输入: [7,1,5,3,6,4]
- 输出: 7
- 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例 2:
- 输入: [1,2,3,4,5]
- 输出: 4
- 解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:
- 输入: [7,6,4,3,1]
- 输出: 0
- 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
提示：
- 1 <= prices.length <= 3 * 10 ^ 4
- 0 <= prices[i] <= 10 ^ 4
思路：贪心(双指针)
获取股票的最大利润，在最低点买入，最高点售出。而股票的区间是波动的，可能存在多个递增/递减区间
需要找到连续递增区间的起始位置和终止位置，计算连续递增区间的差值.需要至少有两天才能组成一个区间
局部最优价：找到连续递增区间的起始位置和终止位置，计算递增区间的差值.可使用双指针法
整体最优解：得到最大利润
股票可能存在持平的天数，股票的利润大小没有影响，同时会加大计算利润的难度，需要对持平的天数去重。可使用双指针法时间复杂度 O(N)
空间复杂度 O(1)
代码如下
public static void main(String args[]) {
int[] prices = new int[]{3, 3, 5, 0, 0, 3, 1, 4};
maxProfit(prices);
}
public static int maxProfit(int[] prices) {
int profit = 0;// 利润
if (prices == null || prices.length == 0 || prices.length == 1)// 边缘情况校验
return profit;
int slow = 0;
int fast = 1;
while (fast < prices.length) {// 数组相邻元素去重
if (prices[slow] != prices[fast]) {
slow++;
prices[slow] = prices[fast];
}
fast++;
}
int priceLength = slow + 1;
slow = 0;
fast = 1;
while (fast < priceLength) {// 数组连续递增子序列求差值之和
if (prices[fast] > prices[fast - 1]) {
fast++;
if (fast == priceLength)
profit = profit + prices[fast - 1] - prices[slow];
} else {
profit = profit + prices[fast - 1] - prices[slow];
slow = fast;
fast++;
}
}
return profit;
}
问题
双指针法太长时间没用了，不熟练了
其中双指针法对数组连续元素去重的代码写的很复杂
复杂代码
int slow = 0;
int fast = 1;
while (fast < prices.length) {// 数组相邻元素去重
if (prices[slow] != prices[fast]) {
slow++;
fast++;
} else {
fast++;
while (fast < prices.length) {
if (prices[slow] != prices[fast]) {
slow++;
prices[slow] = prices[fast];
break;
} else {
fast++;
}
}
}
}
简化代码
int slow = 0;
int fast = 1;
while (fast < prices.length) {// 数组相邻元素去重
if (prices[slow] != prices[fast]) {
slow++;
prices[slow] = prices[fast];
}
fast++;
}
思路：贪心(另一种巧妙的方式)
上述的思路是找到递增子区间，求递增子区间的差值
其中差值可被分解
假如第 0 天买入，第 3 天卖出，那么利润为：prices[3] - prices[0]
假如第0天买入，第1天卖出.假如第1天买入，第2天卖出.假如第2天买入，第3天卖出.
那么利润为：(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])。
相当于prices[3] - prices[0]
此时就是把利润分解为每天为单位的维度，而不是从 0 天到第 3 天整体去考虑！
每天的利润有正有负，只需要收集正利润差值
时间复杂度 O(N)
空间复杂度 O(1)
代码如下
public static int maxProfit(int[] prices) {
int profit = 0;// 利润
if (prices == null || prices.length == 0)
return profit;
for (int i = 1; i < prices.length; i++) {
profit = profit + Math.max(0, prices[i] - prices[i - 1]);
}
return profit;
}
55.跳跃游戏
力扣题目链接(opens new window)
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
- 输入: [2,3,1,1,4]
- 输出: true
- 解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
示例 2:
- 输入: [3,2,1,0,4]
- 输出: false
- 解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
思路：贪心
贪心系列的算法之间没有什么关联，因为贪心算法没有套路，只能多做题目来锻炼自己的贪心思维
当前数组元素为3，我究竟是跳一步还是两步还是三步呢
此题目的关键不在于跳几步，而在于跳的范围。
跳的范围能不能覆盖到终点
每次取覆盖范围内元素的值，如果跳跃后大于当前覆盖范围，则更新，否则不更新覆盖范围
最后判断覆盖范围能否到达数组末尾
贪心算法局部最优解：取当前覆盖范围内最大的覆盖范围
贪心算法整体最优解：取最大的覆盖范围
时间复杂度O(n)
空间复杂度O(1)
代码如下
public static void main(String args[]){
int[] nums = new int[]{2,3,1,1,4};
canJump(nums);
}
public static boolean canJump(int[] nums) {
if (nums == null || nums.length == 0)
return false;
int covert = nums[0];// 覆盖范围
for (int i = 0; i < nums.length; i++){
if(covert >= nums.length-1)// 覆盖范围覆盖终点
return true;
if(i > covert)// 覆盖范围没有覆盖终点
break;
if(i + nums[i] > covert)
covert = nums[i] + i;
}
return false;
}
问题
在设置终止条件时有误
错误代码：只是考虑到覆盖范围刚刚好等于到达数组末尾，但覆盖范围大小有可能会超出数组末尾
if(covert == nums.length-1)// 覆盖范围覆盖终点
return true;
正确代码
if(covert >= nums.length-1)// 覆盖范围覆盖终点
return true;
45.跳跃游戏II
力扣题目链接(opens new window)
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
你的目标是使用最少的跳跃次数到达数组的最后一个位置。
示例:
- 输入: [2,3,1,1,4]
- 输出: 2
- 解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
说明: 假设你总是可以到达数组的最后一个位置。
思路：贪心
思路：贪心
使用最少的跳跃次数到达数组最后一个元素
那每次跳跃【覆盖范围】要为最大
首先定义for循环对数组元素遍历
不断更新覆盖范围covert = Math.max(nums[i] + i, covert);
但要注意更新count的时机，只有将覆盖范围preCovert的数组元素遍历完成后，才可以更新count
代码如下
public static void main(String args[]) {
int[] nums = new int[]{7, 0, 9, 6, 9, 6, 1, 7, 9, 0, 1, 2, 9, 0, 3};
jump(nums);
}
public static int jump(int[] nums) {
if (nums == null || nums.length == 0 || nums.length == 1)
return 0;
int count = 0;// 跳跃次数
int covert = 0; // 跳跃的覆盖范围
int maxCovert = 0; // 跳跃的最大覆盖范围
for (int i = 0; i < nums.length; i++) {
covert = Math.max(nums[i] + i, covert);// 更新覆盖范围
if (i == maxCovert) {// 遇到当前覆盖范围最远范围
count++;
maxCovert = covert;
if (maxCovert >= nums.length - 1)
break;
}
}
return count;
}