题目描述：

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

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

示例 1：

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

示例 2：

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

示例 3：

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

提示：

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

解法：

class Solution {
public:
    int largestSumAfterKNegations(vector<int>& A, int K) {
        vector<int> pos, neg;
        for(int val : A){
            if(val <= 0){
                neg.push_back(val);
            }else{
                pos.push_back(val);
            }
        }
        sort(pos.begin(), pos.end());
        sort(neg.begin(), neg.end());
        int neg_sz = neg.size();
        int pos_sz = pos.size();
        cout<<neg_sz<<", "<<pos_sz<<endl;
        int res = 0;
        if(pos_sz == 0){
            // all negative
            if(K <= neg_sz){
                // flip the first K numbers
                for(int i = 0; i < K; i++){
                    res -= neg[i];
                }
                for(int i = K; i < neg_sz; i++){
                    res += neg[i];
                }
            }else{
                for(int val : neg){
                    res -= val;
                }
                if((K - neg_sz)%2 != 0){
                    res += 2*neg.back();
                }
            }
        }else if(neg_sz == 0){
            // all positive
            for(int val : pos){
                res += val;
            }
            if(K%2 != 0){
                res -= 2*pos[0];
            }
        }else{
            for(int val : pos){
                res += val;
            }
            if(K <= neg_sz){
                // flip the first K negative numbers
                for(int i = 0; i < K; i++){
                    res -= neg[i];
                }
                for(int i = K; i < neg_sz; i++){
                    res += neg[i];
                }
            }else{
                for(int val : neg){
                    res -= val;
                }
                if((K - neg_sz)%2 != 0){
                    if(neg.back() + pos[0] >= 0){
                        // positive number is larger
                        res += 2*neg.back();
                    }else{
                        res -= 2*pos[0];
                    }
                } 
            }
        }
        return res;
    }
};