Day28-贪心算法，leetcode122，55，45，1005

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

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

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

  • 返回 你能获得的 最大 利润 。

  • 示例 1：

    • 输入：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 。

  • 示例 2：

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

  • 示例 3：

    • 输入：prices = [7,6,4,3,1]
    • 输出：0
    • 解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。

  • 提示：

    • 1 <= prices.length <= 3 * 104
    • 0 <= prices[i] <= 104
  • 思路
  • 选一个第的买入，高的卖出，循环反复，只收集每天正利润。利润是可以拆分的，整体利润拆分为每天的利润
/**
 * 遍历价格数组，从第2天开始，计算今天和前一天的差价。
 * 如果今天比昨天贵（prices[i] - prices[i-1] > 0），就把这部分利润加到总利润里。
 * 如果今天比昨天便宜或持平，不操作（加0）。
 * 最终 result 就是所有上涨区间的利润之和。
 * 
 * 只要有利润就赚，不管买卖多少次，把所有上涨的部分都加起来，就是最大利润。
 * 这等价于每次低买高卖，把所有正利润都收集起来。
 */
var maxProfit = function(prices) {
    let result = 0
    for(let i = 1; i < prices.length; i++) {
        result += Math.max(prices[i] - prices[i - 1], 0)
    }
    return result
};
  1. 跳跃游戏

  • 给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。

  • 判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。

  • 示例 1：

    • 输入：nums = [2,3,1,1,4]
    • 输出：true
    • 解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。

  • 示例 2：

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

  • 提示：

    • 1 <= nums.length <= 104
    • 0 <= nums[i] <= 105
  • 思路
  • 跳跃后的覆盖范围能否覆盖到终点。每次移动取最大跳跃步数得到最大的覆盖范围，每移动一个单位，就更小最大覆盖范围。
/**
 * cover 表示当前能跳到的最远下标。
 * 遍历每个位置 i，只要 i 在 cover 范围内，就尝试用 i + nums[i] 更新最远能到达的位置。
 * 如果在遍历过程中，cover 已经大于等于最后一个下标，说明可以到达终点，直接返回 true。
 * 如果遍历结束都没到终点，返回 false。

 * 每次都跳到能到的最远处，只要能覆盖到终点就返回 true，否则返回 false。
 */
var canJump = function(nums) {
    // 只有一个元素，直接能到终点
    if(nums.length === 1) return true
    // 当前能覆盖到的最远下标
    let cover = 0
    // 只遍历能覆盖到的范围
    for(let i = 0; i <= cover; i++) {
        // 更新最远覆盖范围
        // i + nums[i]：从当前位置出发能跳到的最远下标。如果 i = 2，nums[2] = 3，那么从下标 2 最远能跳到下标 5（2 + 3 = 5）。每到一个位置，都要用 i + nums[i] 和当前最远能到达的位置 cover 比较，取更大值，保证记录的是目前能到达的最远下标。
        cover = Math.max(cover, i + nums[i])
        // 如果能覆盖到终点
        if(cover >= nums.length - 1) {
            return true
        }
    }
    // 遍历完都没到终点，返回false
    return false
};
  1. 跳跃游戏 II

  • 给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

  • 每个元素 nums[i] 表示从索引 i 向后跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:

  • 0 <= j <= nums[i]

  • i + j < n

  • 返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

  • 示例 1:

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

  • 示例 2:

    • 输入: nums = [2,3,0,1,4]
    • 输出: 2

  • 提示:

    • 1 <= nums.length <= 104
    • 0 <= nums[i] <= 1000
    • 题目保证可以到达 nums[n-1]

  • 思路

  • 每一步尽可能的去增加覆盖范围，用最少的步数增加覆盖范围，一旦覆盖范围覆盖到了终点，输出步数

  • 变量：当前覆盖范围 下一步覆盖范围 最少步数

  • 如果当前覆盖最远距离下标不是是集合终点，步数就加一，还需要继续走

  • 如果当前覆盖最远距离下标就是是集合终点，步数不用加一，因为不能再往后走了

/**
 * 都是用curIndex 表示当前覆盖的最远下标，nextIndex 表示下一步能覆盖的最远下标，steps 记录跳跃次数。
 * 每次遍历到当前覆盖范围的边界（i === curIndex）时，必须跳一步，更新 curIndex 和 steps。
 * for 循环只到 nums.length - 2，最后一步跳到终点时就不需要再跳了。
 */
var jump = function(nums) {
    if (nums.length === 1) return 0;
    let curDistance = 0;    // 当前覆盖最远距离下标
    let ans = 0;            // 记录跳跃次数
    let nextDistance = 0;   // 下一步覆盖最远距离下标
    for (let i = 0; i < nums.length; i++) {
        nextDistance = Math.max(nums[i] + i, nextDistance); // 更新下一步覆盖最远距离下标
        if (i === curDistance) { // 遇到当前覆盖最远距离下标
            ans++; // 需要跳一步
            curDistance = nextDistance; // 更新当前覆盖最远距离下标
            if (nextDistance >= nums.length - 1) break; // 已经可以到终点，直接结束
        }
    }
    return ans;
};
  1. K 次取反后最大化的数组和

  • 给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：

  • 选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。

  • 重复这个过程恰好 k 次。可以多次选择同一个下标 i 。

  • 以这种方式修改数组后，返回数组 可能的最大和 。

  • 示例 1：

    • 输入：nums = [4,2,3], k = 1
    • 输出：5
    • 解释：选择下标 1 ，nums 变为 [4,-2,3] 。

  • 示例 2：

    • 输入：nums = [3,-1,0,2], k = 3
    • 输出：6
    • 解释：选择下标 (1, 2, 2) ，nums 变为 [3,1,0,2] 。

  • 示例 3：

    • 输入：nums = [2,-3,-1,5,-4], k = 2
    • 输出：13
    • 解释：选择下标 (1, 4) ，nums 变为 [2,3,-1,5,4] 。

  • 提示：

    • 1 <= nums.length <= 104
    • -100 <= nums[i] <= 100
    • 1 <= k <= 104
  • 思路
  • 贪心，第一次贪心，取绝对值最大的负数优先取反，数组里全是正数后；第二次贪心，k次取反操作还没用完，则取数组里最小的非负整数值取反，把剩下的k消耗掉，可以多次对同一个数取反k次，这里可以考虑剩余取反次数k是奇数还是偶数，奇数只要一次取反操作和k次取反效果一样，但性能要好，偶数不用操作和操作偶数次效果一样，但性能要好。
  • （1）对数组按绝对值最大的进行排序，遍历数组，遇到负数，如果k大于0，则将对应负数进行取反操作。（2）如果剩余的k是奇数，则将数组中最小的正数进行取反，如果k是偶数，不用取反，因为取反偶数次还是之前的数。（3）最后遍历一边数组，把数组里的所有元素累加起来，返回结果。
/**
 * 第一步：将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小。这样每次操作都优先处理绝对值最大的数，保证贪心最优。
 * 第二步：从前向后遍历，遇到负数将其变为正数，同时K--
 * 第三步：如果K还大于0，那么反复转变数值最小的元素，将K用完。绝对值最小，排序后在末尾。奇数取反一次，偶数次取反等于没变。
 * 第四步：求和
 */
var largestSumAfterKNegations = function(nums, k) {
    // 第一步：按绝对值从大到小排序
    nums.sort((a, b) => Math.abs(b) - Math.abs(a));
    // 第二步：遇到负数且k>0就取反
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] < 0 && k > 0) {
            nums[i] = -nums[i];
            k--;
        }
    }
    // 第三步：如果k还有剩余且为奇数，把最小的数再取反一次
    if (k % 2 === 1) {
        // 因为已经倒序排列，所以最后一个数最小
        nums[nums.length - 1] = -nums[nums.length - 1];
    }
    // // 若k还大于0,则寻找最小的数进行不断取反，性能逊于判断奇偶数后再取反
    // while( k > 0 ){
    //     nums[nums.length-1] = - nums[nums.length-1]
    //     k--;
    // }
    // 第四步：求和
    return nums.reduce((sum, num) => sum + num, 0);
};

参考&感谢各路大神

posted @ 2025-06-24 09:03  安静的嘶吼  阅读(5)  评论(0)    收藏  举报