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

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

题目描述

给定一个整数数组 A，我们只能用以下方法修改该数组：我们选择某个索引 i 并将 A[i] 替换为 -A[i]，然后总共重复这个过程 K 次。(可多次选择一个索引i的值)

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

示例1:

输入：A = [4,2,3], K = 1
输出：5
解释：选择索引 (1,) ，然后 A 变为 [4,-2,3]。

示例2:

输入：A = [2,-3,-1,5,-4], K = 2
输出：13
解释：选择索引 (1, 4) ，然后 A 变为 [2,3,-1,5,4]。

约束条件

• 1 <= A.length <= 10000
• 1 <= K <= 10000
• -100 <= A[i] <= 100

解题方法1

1. 该题使用贪婪算法可解

2. 定义一个for循环，从0到K进行遍历；

3. 每次对数组进行排序Arrays.sort(A); 使得A[0] = -A[0]

4. 循环结束后，对数组求和，即可得数组最大和。

解题方法2

1. 先对数组进行排序Arrays.sort(A);

2. 定义min = Integer.MAX_VALUE;保留数组中最小值；

3. 定义int sum = 0;便于数组求和；

4. 对数组进行遍历，对数组中小于0的个数和K进行判断

5. 若(A[i]<0 && K–>0)成立

   a. 则A[i] = -A[i], 且记录当前最小值min = Math.min(min, A[i])

   b. 将sum = sum + A[i];

6. 循环完成后，判断K是否大于0

   a. 若K>0 且 K%2 == 0 return sum；

   b. 若K>0 且K%2 == 1 return sum -2*min;

7. 求的数组最大和。

方法1代码实现

class Solution {
    public int largestSumAfterKNegations(int[] A, int K) {
        int res=0;
        for(int i=0;i<K;i++){
            Arrays.sort(A);
            A[0]=-A[0];
        }
        for(int j:A)
            res=res+j;
        return res;
    }
}

方法2代码实现

class Solution {
    public int largestSumAfterKNegations(int[] A, int K) {
        Arrays.sort(A);
        int sum = 0, min = Integer.MAX_VALUE;
        for (int i = 0; i < A.length; i++) {
            if (A[i] < 0 && K-- > 0) 
                A[i] = -1 * A[i];
            sum += A[i];
            min = Math.min(min, A[i]);
        }
        if (K > 0 && K % 2 == 1)
            sum = sum -2*min;
        return sum;
    }
}