第八章贪心算法 part02

最新推荐文章于 2024-10-17 00:09:19 发布

C1aySec

最新推荐文章于 2024-10-17 00:09:19 发布

阅读量853

点赞数 13

分类专栏：代码随想录文章标签：贪心算法算法 leetcode 数据结构 c++

本文链接：https://blog.csdn.net/a781333978/article/details/140613834

版权

代码随想录专栏收录该内容

43 篇文章 0 订阅

订阅专栏

买卖股票的最佳时机 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。

解题思路

初始化：初始化总利润 result 为0。
遍历价格数组：从第二天开始遍历价格数组，因为需要与前一天的价格进行比较。
计算潜在利润（局部最优） ：对于每一天，计算当天的价格与前一天价格的差值，如果这个差值是正数，说明可以从前一天买入并在当天卖出获得利润。使用 max 函数确保只累加非负的差值（即潜在利润）。
累加利润（全局最优） ：将每天的潜在利润累加到总利润 result 中。
返回总利润：遍历结束后，返回累加的总利润。

代码实现

测试地址：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0; // 初始化总利润为0
        for (int i = 1; i < prices.size(); i++) {
            // 计算并累加每天的潜在利润（如果当天价格高于前一天）
            result += max(prices[i] - prices[i - 1], 0);
        }
        return result; // 返回总利润
    }
};

跳跃游戏

题目描述

给你一个非负整数数组 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 ， 所以永远不可能到达最后一个下标。

解题思路

每步尽可能覆盖更远的距离，从而达到全局最优解（即判断是否可以跳跃到数组的最后一个位置）。

局部最优：在每个位置尽可能向前跳得更远。这由 cover = max(i + nums[i], cover) 实现，意味着在当前位置 i，你可以跳跃的最远距离是 i + nums[i]，而 cover 保存了到当前位置为止可以达到的最远距离。
全局最优：通过不断更新达到的最远距离，来判断是否能够到达数组的末尾。如果在任何时点 cover 变量的值大于或等于数组的最后一个索引，则函数返回 true，表明可以跳跃到末尾。

代码实现

测试地址：https://leetcode.cn/problems/jump-game/

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int cover = 0; // 初始化可以覆盖的最远距离为0
        if (nums.size() == 1) // 如果只有一个元素，无需跳跃，直接返回true
            return true;
        for (int i = 0; i <= cover; i++) { // 遍历数组，但只遍历到当前能覆盖的最远距离
            cover = max(i + nums[i], cover); // 更新能覆盖的最远距离
            if (cover >= nums.size() - 1) // 如果覆盖距离已经超过或达到数组最后一个元素的位置，返回true
                return true;
        }
        return false; // 如果循环结束后仍未能覆盖到最后一个元素的位置，返回false
    }
};

跳跃游戏 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

解题思路

核心思想：在每个位置都尽可能向前跳跃最远，同时记录下一步可以跳到的最远距离，直到跳到终点。

局部最优策略：在每个位置，选择可以使自己跳得最远的跳跃。通过不断更新 nextDistance（下一跳可以到达的最远距离），我们保证了在每一步都尽可能跳得更远。
全局最优解：通过局部最优的选择（即每次都选择能跳得最远的选项），最终达到数组的末尾时所需要的最小跳跃次数 ans。
跳跃次数的更新：当遍历到当前跳跃可以到达的最远距离 curDistance 时，说明需要进行一次新的跳跃（因为不能再往前走了），此时将 curDistance 更新为 nextDistance（即这一跳之后可以到达的最远距离），同时跳跃次数 ans 加一。

关键代码解释：

i < nums.size() - 1：由于题目已经给出了前置条件：可以到达 nums[n-1]位置，因此我们只需要判断nextDistance是否能够到达nums[n-2]位置即可。

代码实现

测试地址：https://leetcode.cn/problems/jump-game-ii/

class Solution {
public:
    int jump(vector<int>& nums) {
        int curDistance = 0; // 当前跳跃可以到达的最远距离
        int ans = 0; // 跳跃次数
        int nextDistance = 0; // 下一跳可以到达的最远距离
        for (int i = 0; i < nums.size() - 1; i++) {
            // 更新下一跳可以到达的最远距离
            nextDistance = max(nums[i] + i, nextDistance);
            // 如果当前索引达到了当前跳跃的最远距离，进行跳跃操作
            if (i == curDistance) {
                curDistance = nextDistance; // 更新当前跳跃可以到达的最远距离
                ans++; // 跳跃次数加一
            }
        }
        return ans; // 返回最小跳跃次数
    }
};

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] 。

解题思路

局部最优解法： 将所有的绝对值较大的负数变成正数，尽可能地增加数组的和，因为正数对总和有直接增加的效果。如果剩余操作次数（k）为奇数的话，将数组绝对值最小的数进行取反，减少对总和的影响。
全局最优解： 通过局部最优解法后，将数组中的元素进行依次相加，得到最优的数组和。

代码实现

测试地址：https://leetcode.cn/problems/maximize-sum-of-array-after-k-negations/

// 定义比较函数，根据元素的绝对值从大到小排序
static bool cmp(int a, int b) { return abs(a) > abs(b); }

public:
    int largestSumAfterKNegations(vector<int> &nums, int k) {
        // 利用自定义比较函数cmp，对nums数组进行排序
        sort(nums.begin(), nums.end(), cmp);

        // 遍历数组，优先将负数变为正数，每变一次，k减1
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] < 0 && k > 0) {
                nums[i] *= -1; // 将当前负数变为正数
                k--; // 更新剩余可操作次数
            }
        }

        // 如果k还剩奇数次操作，将数组中绝对值最小的数（排序后的最后一个数）取反
        if (k % 2 == 1)
            nums[nums.size() - 1] *= -1; // 对最后一个元素取反

        // 计算并返回数组所有元素的和
        int result = 0;
        for (int num : nums)
            result += num; // 累加数组中的每个元素
        return result;
    }
};