[Swift]LeetCode945. 使数组唯一的最小增量 | Minimum Increment to Make Array Unique

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

Given an array of integers A, a move consists of choosing any A[i], and incrementing it by 1.

Return the least number of moves to make every value in A unique.

 Example 1:

Input: [1,2,2]
Output: 1
Explanation:  After 1 move, the array could be [1, 2, 3].

Example 2:

Input: [3,2,1,2,1,7]
Output: 6
Explanation:  After 6 moves, the array could be [3, 4, 1, 2, 5, 7].
It can be shown with 5 or less moves that it is impossible for the array to have all unique values.

 Note:

1. 0 <= A.length <= 40000
2. 0 <= A[i] < 40000

---

给定整数数组 A，每次 move 操作将会选择任意 A[i]，并将其递增 1。

返回使 A 中的每个值都是唯一的最少操作次数。

示例 1:

输入：[1,2,2]
输出：1
解释：经过一次 move 操作，数组将变为 [1, 2, 3]。

示例 2:

输入：[3,2,1,2,1,7]
输出：6
解释：经过 6 次 move 操作，数组将变为 [3, 4, 1, 2, 5, 7]。
可以看出 5 次或 5 次以下的 move 操作是不能让数组的每个值唯一的。

提示：

1. 0 <= A.length <= 40000
2. 0 <= A[i] < 40000

---

424ms

class Solution {
    func minIncrementForUnique(_ A: [Int]) -> Int {
        var dp = [Int](repeating: 0, count: 40001)
        for a in A {
            dp[a] += 1
        }
        var ans = 0
        for i in 0 ..< 40000 {
            let a = dp[i]
            guard a > 1 else {
                continue
            }
            dp[i] = 1
            ans += a-1
            dp[i+1] += a-1
        }
        if dp[40000] > 1 {
            let a = dp[40000] - 1
            for i in 1 ... a {
                ans += i
            }
        }
        return ans
    }
}

---

440ms

class Solution {
    func minIncrementForUnique(_ A: [Int]) -> Int {
        guard A.count > 1 else {
            return 0
        }
        let upperBound = 80001
        var freqArray = Array<Int>(repeating: 0, count: upperBound)
        for val in A {
            freqArray[val] += 1
        }
        
        var ans = 0
        var numsOfDupTaken = 0
        for i in 0 ..< upperBound {
            let count = freqArray[i]
            if count > 1 {
                numsOfDupTaken += count - 1
                ans -= i * (count - 1)
            } else if numsOfDupTaken > 0 && freqArray[i] == 0 {
                ans += i
                numsOfDupTaken -= 1
            }
        }
        
        return ans
    }
}

---

460ms

class Solution {
    func minIncrementForUnique(_ A: [Int]) -> Int {
        var count = [Int](repeating: 0, count:100000)
        for x in A {
            count[x] += 1
        }
        var ans = 0, taken = 0
        for x in 0..<100000 {
            if (count[x] >= 2) {
                taken += count[x] - 1;
                ans -= x * (count[x] - 1);
            }
            else if (taken > 0 && count[x] == 0) {
                taken -= 1;
                ans += x;
            }
        }
        return ans;
    }
}

---

476ms

class Solution {
    func minIncrementForUnique(_ A: [Int]) -> Int {
        guard A.count > 1 else {
            return 0
        }
        let sortedA = A.sorted()
        var result = 0, prev = sortedA[0]
        for i in 1..<sortedA.count {
            if sortedA[i] <= prev {
                prev += 1
                result += (prev - sortedA[i])
            } else {
                prev = sortedA[i]
            }
        }
        return result
    }
}

---

484ms

class Solution {
    func minIncrementForUnique(_ A: [Int]) -> Int {
        guard A.count > 1 else {
            return 0
        }
        var sortedA = A.sorted()
        var counter = 0
        for i in 1...sortedA.count - 1 {
            if sortedA[i] <= sortedA[i-1] {
                counter += sortedA[i-1] + 1 - sortedA[i]
                sortedA[i] = sortedA[i-1] + 1
            }
        }
        return counter
    }
}

---

508ms

class Solution {
    func minIncrementForUnique(_ A: [Int]) -> Int {
        var arr:[Int] = A.sorted(by:<)
        var r:Int = -1
        var ret:Int = 0
        for i in 0..<arr.count
        {
            var to:Int = max(r,arr[i])
            ret += abs(to - arr[i])
            r = to + 1
        }
        return ret
    }
}

---

 552ms

class Solution {
    func minIncrementForUnique(_ A: [Int]) -> Int {
    
        var counts = A.reduce(into: [:]) { dict, val in
            dict[val, default: 0] += 1
        }

        var increments = 0
        var nextPossibleSlot = -1
        for key in counts.keys.sorted() {
            var keyCount = counts[key]!
            while keyCount > 1 {
                nextPossibleSlot = max(key, nextPossibleSlot) + 1
                while counts[nextPossibleSlot] != nil {
                    nextPossibleSlot += 1
                }
                //Now nextPossibleSlot is available
                counts[nextPossibleSlot] = 1 //not actually necessary
                increments += nextPossibleSlot - key
                keyCount -= 1
            }
        }

        return increments
    }
}

---

592ms

class Solution {
    func minIncrementForUnique(_ A: [Int]) -> Int {
        guard A.count > 0 else { return 0 }
        guard A.count > 1 else { return 0 }
        
        var sortA = A.sorted()
        var mapA: [Int: Int] = [:]
        for a in A {
            mapA[a] = (mapA[a] ?? 0) + 1
        }
        var res = 0
        var emptIter = sortA.first! - 1
        for (index, a) in sortA.enumerated() {
            if a > emptIter + 1 {
                emptIter = emptIter + 1
                break
            }
            emptIter = a
        }
        if emptIter == sortA.last! {
            emptIter += 1
        }
        
        //print(sortA, emptIter)
        var prev = -1
        for (index, a) in sortA.enumerated() {
            if prev == a {
                if emptIter <= a {
                    emptIter = a
                    while mapA[emptIter] != nil {
                        emptIter += 1
                    } 
                }
                res += (emptIter - a)
                emptIter += 1
                while mapA[emptIter] != nil {
                    emptIter += 1
                } 
                //print(res, emptIter)
            }
            prev = a
        }
        
        return res
    }
}

---

608ms

class Solution {
    
    func minIncrementForUnique(_ arr: [Int]) -> Int {
        guard arr.count > 1 else {
            return 0
        }        

        let arr = arr.sorted()
        var nextHighestValue = arr[0] + 1
        var result = 0
        for i in 1..<arr.count {
            let value = arr[i]
            result += max(nextHighestValue - value, 0)
            nextHighestValue = max(value, nextHighestValue) + 1
        }

        return result
    }
}

---

612ms

class Solution {
    func minIncrementForUnique(_ A: [Int]) -> Int {

        if A.count <= 1 {
            return 0
        }
        let a = A.sorted()
        var ind0 = 1
        var curMin = a[0]
        var counter = 0
        while ind0 < a.count {
            if a[ind0] <= curMin {
                curMin += 1
                counter += curMin - a[ind0]
            } else {
                curMin = max(a[ind0], curMin)
            }
            ind0 += 1
        }
        return counter
    }
}

---

772ms

class Solution {
     func minIncrementForUnique(_ A: [Int]) -> Int {
        var dict: [Int:Node] = [:]
        var count = 0
        
        for num in A {
            if dict[num] == nil {
                let node = Node(num + 1)
                dict[num] = node
            } else {
                // Duplicate
                var nextVal = num
                let newNode = Node(nextVal + 1)
                while dict[nextVal] != nil {
                    if let node = dict[nextVal] {
                        dict[nextVal] = newNode
                        nextVal = node.val
                    }
                }
                dict[nextVal] = newNode
                newNode.val = nextVal + 1
                count += (nextVal - num)
            }
        }
        
        return count
    }
    
    class Node {
        var val: Int
        init(_ a: Int) {
            self.val = a
        }
    }
}