122

买卖股票的最佳时机问题：

题目：

给定一个数组，它的第 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

思路 ：

题目中要求的是最大利润。 通过贪心算法的思路 ，我们可以通过局部的最大利润从而得到全局的最大利润。 把利润分解为每天为单位的维度，而不是从 0 天到第 3 天整体去考虑！

比如：

假如第 0 天买入，第 3 天卖出，那么利润为：prices[3] - prices[0]。

相当于(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])。

这就相当于得到相邻两天的利润，然后逐个相加得到的就是最大的利润。 当然对于利润为负数也就是我们亏损的交易不做不就完了，那么问题实现就简单多了。

因为可以实现多笔交易 ， 所以我们可以将每次交易（买入卖出）所的的金额全部列出来 ，然后将不满足条件的剔除。比如示例1中

[7,1,5,3,6,4] ： 如果我们第i天将买入，然后i + 1 天继续卖出 。依次类推， 就可以得到最大的利润为：

[-6,4,-2,3,-2] ： 这样我们得到的最大化利润就可以通过 0 + 4 + 0 + 3 + 0 = 7得到。 因为我们对于亏本的交易不做， 所以利润为0

实现

1
2
3
4
5
6
7
8
9
10
// 贪心思路
class Solution {
    public int maxProfit(int[] prices) {
        int result = 0;
        for (int i = 1; i < prices.length; i++) {
            result += Math.max(prices[i] - pricjaves[i - 1], 0);
        }
        return result;
    }
}

55

题目：

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个位置。

示例 1:

  • 输入: [2,3,1,1,4]
  • 输出: true
  • 解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。

示例 2:

  • 输入: [3,2,1,0,4]
  • 输出: false
  • 解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。

思路：

首先， 排除只有一个元素的因素 ，因为我们本身刚开始就在第一个元素的位置， 所以一定为true

其次，数组中的每个元素代表你在该位置可以跳跃的最大长度。

那么我们可以通过判断当前位置可以跳跃的最大范围能否覆盖到最后一个元素所在的位置， 如果能覆盖到， 那么直接范围 true 即可。如果不能 ， 那么就是false

所以， 每移动一次索引的下标， 就需要更新一次最大范围。 同时索引 也一定小于当前元素可以跳跃的最大范围。

实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
    public boolean canJump(int[] nums) {
        if (nums.length == 1) {
            return true;
        }
        //覆盖范围, 初始覆盖范围应该是0，因为下面的迭代是从下标0开始的
        int range = 0;
        //在覆盖范围内更新最大的覆盖范围
        for (int i = 0; i <= range; i++) {
            range = Math.max(range, i + nums[i]);
            if (range >= nums.length - 1) {
                return true;
            }
        }
        return false;
    }
}

45

题目 ：

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

你的目标是使用最少的跳跃次数到达数组的最后一个位置。

示例:

  • 输入: [2,3,1,1,4]
  • 输出: 2
  • 解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

说明: 假设你总是可以到达数组的最后一个位置。

思路

本题是衔接上道题实现的，但是他要我们的出的却是最少跳跃次数 。（已经假设一定能够达到最后一个位置了）

所以我们就需要两个指针， 前一个指针负责判断是否达到最后一个元素的位置， 后一个指针专门负责移动位置以及记录跳跃数。

next指针作为判断是否达到最后一个位置的指针， 如果他覆盖的最大范围能够覆盖到最后一个元素， 那么就可以停止跳跃了， 返回跳跃数即可。

后一个指针作为辅助指针 ，它指向的是当前索引能够指向的最大范围位置。 如果索引已经到达当前指针指向的最大范围了（i == curRange ）， 但是还是没有指向最后一个元素， 那么就需要移动指针，步数加1 ，继续向前走。

实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
    public int jump(int[] nums) {
        if(nums.length == 1 ){
            return 0;
        }
        //要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最小步数！
        int range = 0 ; //覆盖范围
        int count = 0;
        int nextRange = 0;
        for(int i = 0; i<= range ;i++){
            nextRange = Math.max(i + nums[i], nextRange); //下一个指针覆盖范围
            //判断覆盖范围是否覆盖了终点
            if(range == i){
                count++;
                range = nextRange ; // 移动当前指针的覆盖范围
                if(nextRange >= nums.length - 1)break;
            }
        }
        return count;
    }
}