(贪心) LeetCode 1005. 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 次,但是可以选择同一元素多次操作。

(1)聪明的小伙伴已经猜到了,只要我每次将最小的一个数选择置反,然后操作k 次,就可以得到最大的和了。没错,这种做法完全正确,我们直接使用优先队列小根堆来存储数组元素,然后每次取出堆头元素置反再添加回去,这样k 次即可。

(2)我们再来看看再原数组中如何操作,细心的同学可以发现,我们只需要在有限的k 次操作中将绝对值大的负数置反,这样就能使得最终结果尽可能的大一些,如果在将所有负数置反之后发现k 任有剩余,那么我们只需要选择一个最小的元素操作k 次就可以了,这样就能使得答案最大,那么我们怎么操作数组呢,难不成每操作一个元素就排序一次吗?这样的做法还不如使用优先队列呢,其实不然,我们只需要在排序的时候做一些操作即可,按照数组中数的绝对值从大到小排序即可 ,例如(1,5, 2, -8,-4, k = 5),这样排序之后就可以得到(-8,5,-4,2,1,k = 5);然后我们只需要从头遍历数组,优先处理负数,在k 次范围内将绝对值最大的负数置反即可,遍历结束之后,如果k 任有剩余,只需要将数组末尾的元素(排序之后末尾的就是最小的)执行k 次操作即可,有些同学想要使用while(k--)来操作,然后反复将最后一位元素进行置反,完全没必要,如果剩余的k 是偶数的话,就不用管了,因为在k 次操作之后值是不会变的,如果是奇数,只需要将值 *-1 即可。

最后遍历优先队列或者数组将总和求出返回即可。

话不多说!!!上代码!!

三. 代码

1. 使用优先队列:

class Solution {
public:
    int largestSumAfterKNegations(vector& nums, int k) {
        priority_queue, greater<>> que;
        for(int i = 0; i < nums.size(); i++){
            que.push(nums[i]);
        }
        while(k--){
            int node = que.top(); que.pop();
            que.push(-node);
        }
        int res = 0;
        while(!que.empty()){
            int node = que.top(); que.pop();
            res += node;
        }
        return res;
    }
};

2. 在原数组中操作:

class Solution {
public:
    static bool com(int a, int b){
        return abs(a) > abs(b);
    }
    int largestSumAfterKNegations(vector& nums, int k) {
        sort(nums.begin(), nums.end(), com);
        for(int i = 0 ; i< nums.size(); i++){
            if(nums[i] < 0 && k > 0){
                nums[i] *= -1;
                k--;
            }
        }
        if(k % 2 == 1) nums[nums.size() - 1] *= -1; 
        int res = 0;
        for(int i = 0; i < nums.size(); i++){
            res += nums[i];
        }
        return res;
    }
};

四. 总结

本题两种做法都能通过,但是我们更将以使用后面的做法,因为在时间以及空间复杂度上都简洁了很多,贪心本就是需要自己锻炼的一种思想,如果使用库函数的话,就没有很好的贪心思想体现了。

(1). 优先队列时间复杂度:O(nlogn) ;空间复杂度:O(n)。

(2). 原数组操作时间复杂度:O(nlogn); 空间复杂度:O(1)。

喜欢的话给个关注吧!!

你可能感兴趣的:(LeetCode,贪心算法,数据结构,leetcode,算法,c++)