贪心算法在LeetCode问题中的应用

贪心算法是一种在每一步选择中都采取在当前状态下最好或最优的选择，从而希望导致结果是全局最好或最优的算法策略。它在解决一些优化问题时非常有效，尤其是在那些具有最优子结构特性的问题上。本文将通过LeetCode上的三个问题来展示贪心算法的应用。

1. 1005. K 次取反后最大化的数组和

这个问题要求我们通过最多K次取反操作来最大化数组的和。取反操作即将数组中的某个元素从正数变为负数，或者从负数变为正数。贪心算法的思想是，我们应该首先将数组中的最小负数取反，然后是次小的负数，依此类推，直到没有负数或者K次操作用完。

import java.util.Arrays;
import java.util.stream.IntStream;

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        nums = IntStream.of(nums)
                .boxed()
                .sorted((o1, o2) -> Math.abs(o2) - Math.abs(o1))
                .mapToInt(Integer::intValue)
                .toArray();
        int len = nums.length;
        for (int i = 0; i < len; i++) {
            if (nums[i] < 0 && k > 0) {
                nums[i] = -nums[i];
                k--;
            }
        }
        if (k % 2 == 1) {
            nums[len - 1] = -nums[len - 1];
        }
        return Arrays.stream(nums).sum();
    }
}

2. 134. 加油站

这个问题是关于在一个环形道路上的加油站和消耗油量的问题。我们需要找出从哪个加油站出发，可以绕一圈回到起点，且油量刚好用完。贪心算法在这里的应用是，我们首先计算出整个环形道路上油的净增量，如果净增量小于0，那么无法完成一圈。然后，我们从左到右计算出最小油量需求，并从这个点开始向右寻找能够完成一圈的起点。

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int sum = 0, min = 0;
        for (int i = 0; i < gas.length; i++) {
            sum += (gas[i] - cost[i]);
            min = Math.min(sum, min);
        }
        if (sum < 0) {
            return -1;
        }
        if (min >= 0) {
            return 0;
        }
        for (int i = gas.length - 1; i > 0; i--) {
            min += (gas[i] - cost[i]);
            if (min >= 0) {
                return i;
            }
        }
        return -1;
    }
}

3. 135. 分发糖果

这个问题要求我们给孩子们分发糖果，每个孩子至少得到1颗糖果，并且如果两个孩子是相邻的，且右边的孩子的评分比左边的孩子的评分高，则右边的孩子会得到更多的糖果。贪心算法在这里的应用是，我们首先从左到右给每个孩子分配糖果，确保每个孩子至少有1颗。然后，如果一个孩子的评分比他左边的孩子高，我们就给他额外的糖果。接着，我们从右向左遍历，如果一个孩子的评分比他右边的孩子高，我们就确保他得到的糖果不少于他右边的孩子。

class Solution {
    public int candy(int[] ratings) {
        int len = ratings.length;
        int[] candyVec = new int[len];
        candyVec[0] = 1;
        for (int i = 1; i < len; i++) {
            if (ratings[i] > ratings[i - 1]) {
                candyVec[i] = candyVec[i - 1] + 1;
            } else {
                candyVec[i] = 1;
            }
        }
        for (int i = len - 2; i >= 0; i--) {
            if (ratings[i] > ratings[i + 1]) {
                candyVec[i] = Math.max(candyVec[i], candyVec[i + 1] + 1);
            }
        }
        int ans = 0;
        for (int num : candyVec) {
            ans += num;
        }
        return ans;
    }
}

通过这三个问题，我们可以看到贪心算法在解决实际问题中的有效性和实用性。它通过局部最优选择来达到全局最优解，是一种简单而强大的算法策略。

✅作者简介：热爱科研的嵌入式开发者，修心和技术同步精进

❤欢迎关注我的知乎：对error视而不见

代码获取、问题探讨及文章转载可私信。

☁ 愿你的生命中有够多的云翳,来造就一个美丽的黄昏。

🍎获取更多嵌入式资料可点击链接进群领取，谢谢支持！👇

点击领取更多详细资料