贪心算法：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

思路：

        我们只需每次遍历数组，找到数组中的最小值，将其取反即可。

/**
思路：
    找到数组中最小的值，将其取反
 */
class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        int sum = 0;//用于对数组中元素求和
        for(int i = 0; i < k; i++){//重复k次取反，因此进行k次循环
            //每进行一次循环，要对最小值进行一次初始化，找出数组中的最小元素。注意：这一步不能放在for循环外面，不然后面取反时最小值得不到更新
            int min = nums[0];
            int index = 0;//最小元素的下标，每次循环都要更新一次，不要放在for循环外面
            for(int j = 1; j < nums.length; j++){
                if(nums[j] < min){//这里体现贪心算法，每次都找最小的那个来进行取反
                    min = nums[j];//将最小值更新
                    index = j;//得到数组中最小值的下标
                }
            }
            nums[index] = -nums[index];//一次循环结束后，找到最小值，将该值取反
        }

        for(int i = 0; i < nums.length; i++){
            sum += nums[i];
        }
        return sum;
    }
}

方法二：

/**
思路：
    因为题目并没有要求我们返回最小值的下标，因此我们只需将数组升序排列，找到数组中最小的值，将其取反即可
 */
class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        int sum = 0;//用于对数组中元素求和
        
        for(int i = 0; i < k; i++){
            Arrays.sort(nums);//每进行一次循环，将nums数组进行一次升序排列，则nums[0]一定是最小值
            nums[0] = -nums[0];
        }

        for(int i = 0; i < nums.length; i++){
            sum += nums[i];
        }
        return sum;
    }
}