leetcode1005

func largestSumAfterKNegations(A []int, K int) int {
    sort.Ints(A)
    var negatives int
    var zeros int
    var positives int
    var negativeAry []int
    var positiveAry []int
    for n := range A {
        if A[n] < 0 {
            negatives++
            negativeAry = append(negativeAry, A[n])
        } else if A[n] == 0 {
            zeros++
        } else {
            positives++
            positiveAry = append(positiveAry, A[n])
        }
    }
    var sum int
    if K <= negatives { //只需要把负数变正数，把最小的（绝对值大的）K个负数变正数
        for i := 0; i < K; i++ {
            sum += negativeAry[i] * -1
        }
        for i := K; i < negatives; i++ {
            sum += negativeAry[i]
        }
        for i := 0; i < positives; i++ {
            sum += positiveAry[i]
        }
    } else { //将全部的负数都变成正数，还不够
        if zeros > 0 || (K-negatives)%2 == 0 {
            //剩下的变化次数，全变0，或者反复的变偶数次同一个正数（也可以是一个已经变成正数的负数）
            for i := 0; i < negatives; i++ {
                sum += negativeAry[i] * -1
            }
            for i := 0; i < positives; i++ {
                sum += positiveAry[i]
            }
        } else {
            //先把负数的绝对值累加
            for i := 0; i < negatives; i++ {
                sum += negativeAry[i] * -1
            } //再把正数的绝对值累加
            for i := 0; i < positives; i++ {
                sum += positiveAry[i]
            } //判断全部已经都变成正数的数组中，绝对值最小的数字
            //将绝对值最小的这个数字，减2次
            if (negatives == 0 && positives > 0) || (positives > 0 && negatives > 0 && positiveAry[0] <= negativeAry[negatives-1]*-1) {
                sum += positiveAry[0] * -2
                return sum
            }
            if (positives == 0 && negatives > 0) || (positives > 0 && negatives > 0 && positiveAry[0] > negativeAry[negatives-1]*-1) {
                sum += negativeAry[negatives-1] * 2
                return sum
            }
        }

    }
    return sum
}

上面这个一定觉得很啰嗦，那就来个简单的：

func largestSumAfterKNegations(A []int, K int) int {
    sort.Ints(A)
    i := 0
    for i < len(A) && K > 0 && A[i] < 0 {
        A[i] = -A[i]
        i++
        K--
    }
    sum := 0
    sort.Ints(A)
    for j := range A {
        sum += A[j]
    }
    if K > 0 && K%2 == 1 {
        min := A[0]
        sum -= min * 2
    }
    return sum
}

思想是一样的，但是简洁了很多。而且由于没有使用新数组保存正和负数，所以空间占用更小。

第一部分代码是思维的过程，第二部分代码是提炼之后的。leetcode上面的题目，大部分都可以用20，30行就搞定。如果代码特别长，那应该是没有抓住问题的本质，这样的代码思维可能把自己绕进去，别人看不懂，甚至自己也会看迷糊。

最后，go的效率的确是棒棒的：