{每日一道算法题21/12/3}

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

难度 简单

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

选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。
重复这个过程恰好 k 次。可以多次选择同一个下标 i 。

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

提示：

• 1 <= nums.length <= 104
• -100 <= nums[i] <= 100
• 1 <= k <= 104

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

转载——力扣

算法题不单单是求解，尽量以最优的算法为主（最短的运行时间，最小占用的内存）

---

解:

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        // Arrays.sort(nums);
        // int a = 0;
        // for (int i = 0; i < nums.length; i++) {
        //     if (nums[i] < 0 && k > 0) {
        //         nums[i] = -1 * nums[i];
        //         k--;
        //     }
        //     a += nums[i];
        // }
        // Arrays.sort(nums);
        // return a - (k % 2 == 0 ? 0 : 2 * nums[0]); 

        int xiao=100000;
        int ling=0;
        List fu=new ArrayList();
        int a=0;

        for(int i:nums){
            xiao=Math.min(Math.abs(i),xiao);
            a+=Math.abs(i);
            if(i<0){
                fu.add(i);
            }else if(i==0){
                ling++;
            }
        }
        Collections.sort(fu);

        if(k>fu.size()){     //直接返回全部总和的情况有   去掉所有的负数后，还是最后转换的值是偶数   数组里有0
            if(ling!=0||(k-fu.size())%2!=0){
                 a-=xiao*2;
            }
        }else if(k<fu.size()){
            for (int i= k;i<fu.size();i++){
                a-=Math.abs((Integer) fu.get(i))*2;
            }
        }
        return a;

    }
}

我能想到的只有这两个解法，算是两个不同的思路吧，整体来说还是上面那个解法比较好，无论是效率还是简洁性来说都要比下面那个的思路高出一截