[Swift]LeetCode1005. K 次取反后最大化的数组和 | Maximize Sum Of Array After K Negations

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10504835.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given an array A of integers, we must modify the array in the following way: we choose an i and replace A[i] with -A[i], and we repeat this process K times in total.  (We may choose the same index i multiple times.)

Return the largest possible sum of the array after modifying it in this way. 

Example 1:

Input: A = [4,2,3], K = 1
Output: 5
Explanation: Choose indices (1,) and A becomes [4,-2,3].

Example 2:

Input: A = [3,-1,0,2], K = 3
Output: 6
Explanation: Choose indices (1, 2, 2) and A becomes [3,1,0,2].

Example 3:

Input: A = [2,-3,-1,5,-4], K = 2
Output: 13
Explanation: Choose indices (1, 4) and A becomes [2,3,-1,5,4]. 

Note:

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

---

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

---

Runtime: 24 ms

Memory Usage: 19 MB

class Solution {
    func largestSumAfterKNegations(_ A: [Int], _ K: Int) -> Int {
        var A = A.sorted()
        var K = K
        var minValue = Int.max
        var minIndex = 0
        for i in 0..<A.count {
            if K > 0 && A[i] < 0
            {
                A[i] = -A[i]
                K -= 1                
            }
            if A[i] < minValue {
                minValue = A[i]
                minIndex = i
            }
        }
        
        if K % 2 == 1 {
            A[minIndex] = -A[minIndex]
        }
        return A.reduce(0,+)
    }
}

---

28ms

class Solution {
    func largestSumAfterKNegations(_ A: [Int], _ K: Int) -> Int {
        var aS = A.sorted()
        
        for i in 0 ..< A.count {
            if i < K && aS[i] <= 0 {
                aS[i] = -aS[i]
                if aS[i] == 0 {
                    break
                }
            } else if i < K && aS[i] > 0 {
                if i == 0 {
                    aS[0] = K % 2 == 0 ? aS[0] : -aS[0]
                    break
                } else {
                    if aS[i - 1] < aS[i] {
                        aS[i - 1] = (K - i) % 2 == 0 ? aS[i-1] : -aS[i-1]
                    } else {
                        aS[i] = (K - i) % 2 == 0 ? aS[i] : -aS[i]
                    }
                    break
                }
            }
        }
        
        return aS.reduce(0, { $0 + $1 })
    }
}

---

32ms

class Solution {
    func largestSumAfterKNegations(_ A: [Int], _ K: Int) -> Int {
        var A = A
        var K = K
        A.sort()
        for i in 0..<A.count
        {
            if K > 0 && A[i] < 0
            {
                A[i] = -A[i]
                K -= 1                
            }
        }
        A.sort()
        if K % 2 == 1
        {
            A[0] = -A[0]
        }
        return A.reduce(0,+)
    }
}

---

52ms

class Solution {
    func largestSumAfterKNegations(_ A: [Int], _ K: Int) -> Int {
        var ACopy = A.sorted()
        for _ in 0..<K {
            let (minNum, minIndex) = getMinNumAndIndex(ACopy)
            ACopy[minIndex] = -minNum
        }
        return ACopy.reduce(0, +)
    }
    
    func getMinNumAndIndex(_ A: [Int]) -> (Int, Int) {
        var minNum = Int.max
        var minIndex = Int.max
        for index in 0..<A.count {
            let num = A[index]
            if num < minNum {
                minNum = num
                minIndex = index
            }
        }
        return (minNum, minIndex)
    }
}

---

72ms

class Solution {
    func largestSumAfterKNegations(_ A: [Int], _ K: Int) -> Int {
        var AA = A
        for _ in 0..<K {
            let tuple = findWhatToNegate(AA)
            AA[tuple.1] = -tuple.0
        }
        return AA.reduce(0, +)
    }
    private func findWhatToNegate(_ arr: [Int]) -> (Int, Int) {
        var smallestPositiveNumber : Int = -1
        var smallestPositiveNumberIndex : Int = -1
        var smallestNegativeNumber: Int = 1
        var smallestNegativeNumberIndex: Int = -1

        for index in 0..<arr.count {
            let value = arr[index]
            if value >= 0 {
                if smallestPositiveNumber == -1 {
                    smallestPositiveNumber = value
                    smallestPositiveNumberIndex = index
                } else if value <= smallestPositiveNumber {
                    smallestPositiveNumber = value
                    smallestPositiveNumberIndex = index
                }
            } else {
                if smallestNegativeNumber == 1 {
                    smallestNegativeNumber = value
                    smallestNegativeNumberIndex = index
                } else if value <= smallestNegativeNumber {
                    smallestNegativeNumber = value
                    smallestNegativeNumberIndex = index
                }
            }
        }
        if smallestNegativeNumber < 1 {
            return (smallestNegativeNumber, smallestNegativeNumberIndex)
        } else {
            return (smallestPositiveNumber, smallestPositiveNumberIndex)
        }
    }
}