给定一个整数数组 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]。

思路：

首先考虑A中负数的个数M， 如果M 比 K 大，那么只要把最小的M个负数变成正数就可以了，

如果M 比 K 小， 说明光把负数变正还不够，还要考虑处理正数的情况，

先把M个负数都变正，然后判断一下还要做多少次 取相反数 的操作数 K - M，

如果K - M 是个偶数，就说明不用再处理了，因为当前已经没有负数了，取反的操作只会使和保持不变或者减小，直接返回sum(A)就行

如果K - M 是个奇数，就说明至少要做一个取反，就选择最小的元素进行取反。

class Solution(object):
    def largestSumAfterKNegations(self, A, K):
        """
        :type A: List[int]
        :type K: int
        :rtype: int
        """
        cnt = 0
        for i in A:
            if i < 0:
                cnt += 1
                
        if cnt >= K:
            A.sort()
            s = -1 * sum(A[:K]) + sum(A[K:])
            return s
        
        else:
            temp = K - cnt
            B = list()
            
            for item in A:
                B.append(abs(item))
            # print B   
            B.sort()
            # print sum(B), B
            if temp % 2 == 1:
                return sum(B) - 2* B[0]
            else:
                return sum(B)