羊羊刷题笔记Day34/60 | 第八章 贪心算法P3 | 1005. K次取反后最大化的数组和、134. 加油站、135. 分发糖果

95 阅读6分钟

今天的第二第三题都有一定难度,充分体现贪心的思想

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

本题思路其实比较好想了,只需思考如何可以让数组和最大?但也藏着许多细枝末节的问题

思路

贪心的思路:
局部最优:让绝对值大的负数变为正数,当前数值达到最大。
整体最优:整个数组和达到最大。
局部最优可以推出全局最优。


那么如果将负数都转变为正数了,K依然大于0,此时的问题是一个有序正整数序列,如何转变K次正负,让 数组和 达到最大。
那么又是一个贪心:
局部最优:只找数值最小的正整数进行反转,当前数值和可以达到最大(例如正整数数组{5, 3, 1},反转1 得到-1 比 反转5得到的-5 大多了)
全局最优:整个 数组和 达到最大。


这么一道简单题,就用了两次贪心!
那么本题的解题步骤为:

  • 第一步:将数组按照绝对值大小从大到小排序,注意要按照绝对值的大小
  • 第二步:从前向后遍历,遇到负数将其变为正数,同时K--
  • 第三步:如果K还大于0,那么反复转变数值最小的元素,将K用完
  • 第四步:求和

整体代码如下:

public int largestSumAfterKNegations(int[] nums, int k) {
    // 将数组按绝对值排序
    nums = IntStream.of(nums)// 将数组转换为流
        .boxed() // int转换为Integer类型
        .sorted((o1, o2) -> Math.abs(o2) - Math.abs(o1)) // 按绝对值排序
        .mapToInt(Integer::intValue).toArray(); // 将Integer类型转换回int类型并输出数组

    // 取反
    for (int i = 0;i <= nums.length - 1;i++){
        if (k > 0 && nums[i] < 0){
            nums[i] *= - 1;
            k--;
        }
    }

    // 剩下k 还没用完 - 两种情况:奇数 - 取绝对值最低变负数 偶数 - 不用变
    if (k % 2 == 1) nums[nums.length - 1] *= -1;

    // 求和
    int sum = 0;
    for (int num : nums) {
        sum += num;
    }
    return sum;

}
  • 时间复杂度: O(nlogn)
  • 空间复杂度: O(1)

总结

贪心的题目如果简单起来,会让人简单到开始怀疑:本来不就应该这么做么?这也算是算法?我认为这不是贪心?
本题其实很简单,不会贪心算法的都可以做出来,但是还是全程用贪心的思路来讲解。
因为贪心的思考方式一定要有
如果没有贪心的思考方式(局部最优,全局最优),很容易陷入贪心简单题凭感觉做,贪心难题直接不会做,其实这样就锻炼不了贪心的思考方式了
所以明知道是贪心简单题,也要靠贪心的思考方式来解题,这样对培养解题感觉很有帮助。

134 加油站

难度开始上来了,想懂这道题还用了一阵子时间

思路

可以换一个思路,首先如果总油量减去总消耗大于等于零那么一定可以跑完一圈,说明 各个站点的加油站 剩油量rest[i]相加一定是大于等于零的。
每个加油站的剩余量rest[i]为gas[i] - cost[i]。
i从0开始累加rest[i],和记为curSum,一旦curSum小于零,说明[0, i]区间都不能作为起始位置,因为这个区间选择任何一个位置作为起点,到i这里都会断油,那么起始位置从i+1算起,再从0计算curSum。
如图:
image.png
那么为什么一旦[0,i] 区间和为负数,起始位置就可以是i+1呢,i+1后面就不会出现更大的负数?
如果出现更大的负数,就是更新i,那么起始位置又变成新的i+1了。

⭕那有没有可能 [0,i] 区间 选某一个作为起点,累加到 i这里 curSum是不会小于零呢?

如图:
image.png
如果 curSum<0 说明 区间和1 + 区间和2 < 0, 那么 假设从上图中的位置开始计数curSum不会小于0的话,就是 区间和2>0。
区间和1 + 区间和2 < 0 同时 区间和2>0,只能说明区间和1 < 0, 那么就会从假设的箭头初就开始从新选择其实位置了。但实际小于零的情况只发生在了i位置上,与实际不符,假设不成立。


**局部最优:**当前累加rest[i]的和curSum一旦小于0,起始位置至少要是i+1,因为从i之前开始一定不行。
**全局最优:**找到可以跑一圈的起始位置。
局部最优可以推出全局最优,找不出反例,试试贪心!
整体代码如下:

public int canCompleteCircuit(int[] gas, int[] cost) {
    // 初始量
    int curSum = 0;
    int totalSum = 0;
    int index = 0;

    // 遍历数组
    for (int i = 0;i < gas.length; i++){
        // 记录当前油量
        curSum += gas[i] - cost[i];
        totalSum += gas[i] - cost[i];
        if (curSum < 0){
            // 不够油了 从下一位开始,归零,继续遍历
            index = (i + 1) % gas.length;
            curSum = 0;
        }
    }

    // 遍历完之后总和本身为负数则没有
    if (totalSum < 0) return -1;
    return index;
}
  • 时间复杂度:O(n)
  • 空间复杂度:O(1)

说这种解法为贪心算法,才是有理有据的,因为全局最优解是根据局部最优推导出来的

135 分发糖果

一次顾两边就容易混乱,所以一个一个来~

思路

这道题目一定是要确定一边之后,再确定另一边,最后合在一起。例如比较每一个孩子的左边,然后再比较右边,如果两边一起考虑一定会顾此失彼
先确定右边评分大于左边的情况(也就是从前向后遍历)
此时局部最优:只要右边评分比左边大,右边的孩子就多一个糖果。
全局最优:相邻的孩子中,评分高的右孩子获得比左边孩子更多的糖果
局部最优可以推出全局最优。
如果ratings[i] > ratings[i - 1] 那么[i]的糖 一定要比[i - 1]的糖多一个,所以贪心:candy[i] = candy[i - 1] + 1
代码如下:

// 右孩子比左孩子大
for (int i = 1;i < len; i++){
    if (ratings[i - 1] < ratings[i]){
        candy[i] = candy[i - 1] + 1;
    }
    else candy[i] = 1;
}

如图:
image.png
再确定左孩子大于右孩子的情况(从后向前遍历)
遍历顺序这里有同学可能会有疑问,为什么不能从前向后遍历呢?
因为 rating[5]与rating[4]的比较 要利用上 rating[5]与rating[6]的比较结果,所以 要从后向前遍历。
如果从前向后遍历,rating[5]与rating[4]的比较 就不能用上 rating[5]与rating[6]的比较结果了 。如图:
image.png
所以确定左孩子大于右孩子的情况一定要从后向前遍历!
如果 ratings[i] > ratings[i + 1],此时candy[i](第i个小孩的糖果数量)就有两个选择了。
一个是candy[i + 1] + 1(从右边这个加1得到的糖果数量),一个是candy[i](之前比较右孩子大于左孩子得到的糖果数量)。
那么又要贪心了,局部最优:取candy[i + 1] + 1 和 candy[i] 最大的糖果数量,保证第i个小孩的糖果数量既大于左边的也大于右边的。
全局最优:相邻的孩子中,评分高的孩子获得更多的糖果。
局部最优可以推出全局最优。
所以就取candy[i + 1] + 1 和 candy[i] 最大的糖果数量,candy[i]只有取最大的才能既保持对左边candyVec[i - 1]的糖果多,也比右边candyVec[i + 1]的糖果多
如图:
image.png
所以该过程代码如下:

// 左孩子比右孩子大
for (int i = len - 2;i >= 0; i--){
    if (ratings[i] > ratings[i + 1]){
        candy[i] = Math.max(candy[i + 1] + 1,candy[i]);
    }
}

整体代码如下:

public int candy(int[] ratings) {
    int len = ratings.length;
    int[] candy = new int[len];
    candy[0] = 1;

    // 右孩子比左孩子大
    for (int i = 1;i < len; i++){
        if (ratings[i - 1] < ratings[i]){
            candy[i] = candy[i - 1] + 1;
        }
        else candy[i] = 1;
    }

    // 左孩子比右孩子大
    for (int i = len - 2;i >= 0; i--){
        if (ratings[i] > ratings[i + 1]){
            candy[i] = Math.max(candy[i + 1] + 1,candy[i]);
        }
    }

    int sum = 0;
    for (int i : candy) {
        sum += i;
    }
    return sum;
}
  • 时间复杂度: O(n)
  • 空间复杂度: O(n)

总结

这在leetcode上是一道困难的题目,其难点就在于贪心的策略,如果在考虑局部的时候想两边兼顾,就会顾此失彼。
那么本题我采用了两次贪心的策略:

  • 一次是从左到右遍历,只比较右边孩子评分比左边大的情况。
  • 一次是从右到左遍历,只比较左边孩子评分比右边大的情况。

这样从局部最优推出了全局最优,即:相邻的孩子中,评分高的孩子获得更多的糖果。

学习资料:

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

134. 加油站

135. 分发糖果