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

选择某个下标 并将 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

思路：

有0的情况，直接把负数全变正数，

有负数：

k小于负数个数，排序将k个负数变为正数，之后与其他非负数相加，

再加上剩下的负数。

k大于负数个数，先将所有负数变为正数，最后判断k减去负数个数的值设为x

判断x是否是奇数，是奇数

且绝对值最小值为负数，则加上两倍这个最小值（负数）

且绝对值最小值为正数，则减去两倍这个最小值（正数）

无负数：

没有负数，有0情况，k的个数不影响

没有负数，无0情况，判断是否偶数个数，

偶数个数不影响，奇数个数，最小值符号变化

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;


class Solution {
public:
    int largestSumAfterKNegations(vector<int>& nums, int k) {
        int maxSum = 0;
        int absMin = INT_MAX;
        vector<int> negative;
        for(uint32_t i = 0; i < nums.size(); i++){
            if(nums[i] < 0){
                negative.push_back(nums[i]);
            }else{
                maxSum = maxSum + nums[i];
            }
            if(abs(nums[i]) < abs(absMin)){
                absMin = nums[i];
            }
        }

        if(negative.size() > 0){
            sort(negative.begin(), negative.end(), compareFunc);
            calRemainNum(negative, k, maxSum, absMin);
        }else{
            sort(nums.begin(), nums.end());           //从小到大
            if(k % 2 != 0){
                maxSum -= 2*nums[0];
            }
        }

        return maxSum;
    }

private:
    static bool compareFunc(int num1, int num2){
        return abs(num1) > abs(num2);
    }

    void calRemainNum(vector<int>& negative, int k, int& maxSum, int &absMin){
        int negativeLen = negative.size();
        if(static_cast<uint32_t>(k) <= negative.size()){
            for(int i = 0; i < negativeLen; i++){
                if(i < k){
                    negative[i] = -negative[i];
                }
                maxSum += negative[i];
            }
        }
        else{
            int remainLen  = k - negativeLen;        //遗留长度
            for(int i = 0; i < negativeLen; i++){
                negative[i] = -negative[i];
                maxSum += negative[i];
            }
            cout<<"absMin:"<<absMin<<endl;
            if(remainLen % 2 != 0){
                if(absMin < 0){
                    maxSum += 2 *absMin;
                }else{
                    maxSum -= 2 *absMin;
                }
            }
        }
    }

};