[Swift]LeetCode870. 优势洗牌 | Advantage Shuffle

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

Given two arrays A and B of equal size, the advantage of A with respect to B is the number of indices i for which A[i] > B[i].

Return any permutation of A that maximizes its advantage with respect to B. 

Example 1:

Input: A = [2,7,11,15], B = [1,10,4,11]
Output: [2,11,7,15]

Example 2:

Input: A = [12,24,8,32], B = [13,25,32,11]
Output: [24,32,8,12] 

Note:

1. 1 <= A.length = B.length <= 10000
2. 0 <= A[i] <= 10^9
3. 0 <= B[i] <= 10^9

---

给定两个大小相等的数组 A 和 B，A 相对于 B 的优势可以用满足 A[i] > B[i] 的索引 i 的数目来描述。

返回 A 的任意排列，使其相对于 B 的优势最大化。

示例 1：

输入：A = [2,7,11,15], B = [1,10,4,11]
输出：[2,11,7,15]

示例 2：

输入：A = [12,24,8,32], B = [13,25,32,11]
输出：[24,32,8,12]

提示：

1. 1 <= A.length = B.length <= 10000
2. 0 <= A[i] <= 10^9
3. 0 <= B[i] <= 10^9

---

Runtime: 552 ms

Memory Usage: 20.3 MB

class Solution {    
    func advantageCount(_ A: [Int], _ B: [Int]) -> [Int] {
        var A = A
        A.sort()
        var n:Int = A.count
        var res:[Int] = [Int](repeating:0,count:n)
        var pq:[[Int]] = [[Int]]()
        for i in 0..<n
        {
            pq.append([B[i], i])            
        }
        pq.sort(){$0[0] < $1[0]}
        var lo:Int = 0
        var hi:Int = n - 1
        while(!pq.isEmpty)
        {
            var cur:[Int] = pq.removeLast()
            var idx:Int = cur[1]
            var val:Int = cur[0]
            if A[hi] > val
            {
                res[idx] = A[hi]
                hi -= 1
            }
            else
            {
                res[idx] = A[lo]
                lo += 1
            }
        }
        return res
    }
}

---

616ms

class Solution {
    func advantageCount(_ A: [Int], _ B: [Int]) -> [Int] {
        var leftArr = [Int]()
        var ans = [Int](repeating: Int.min, count: A.count)
        var tupleArrB = [(Int, Int)]()
        for i in 0..<B.count {
            tupleArrB.append((i, B[i]))
        }
        tupleArrB.sort { $0.1 < $1.1}
        var sorteA = A.sorted()
        var aIndex = 0
        for (bi, v) in tupleArrB {
            if aIndex >= sorteA.count { break }
            while aIndex < sorteA.count {
                let a = sorteA[aIndex]
                aIndex += 1
                if a > v { ans[bi] = a; break}
                leftArr.append(a)
            }
        }

        for i in 0..<ans.count {
            if ans[i] == Int.min {
                ans[i] = leftArr.removeFirst()
            }
        }
        return ans
    }
}

---

624ms

class Solution {
    func advantageCount(_ A: [Int], _ B: [Int]) -> [Int] {
        var res = Array(repeating: 0, count: A.count)

        var A = A.sorted()
        var i = 0, e = A.count - 1
        for (idx, n) in B.enumerated().sorted(by: { $0.1 >= $1.1 }) {
            if A[e] > n {
                res[idx] = A[e]
                e -= 1
            } else {
                res[idx] = A[i]
                i += 1
            }
        }
        return res
    }
}

---

628ms

class Solution {
    func advantageCount(_ A: [Int], _ B: [Int]) -> [Int] {
        var sorted = A.sorted(by: >)
        var sortedB = B.enumerated().sorted {
            $0.1 > $1.1
        }
        var i = 0
        var j = sorted.count - 1
        var result = [Int](repeating: 0, count: sorted.count)
        for b in sortedB {
            if sorted[i] > b.1 {
                result[b.0] = sorted[i]
                i += 1
            } else {
                result[b.0] = sorted[j]
                j -= 1
            }
        }
        return result
    }
}

---

772ms

class Solution {
    func advantageCount(_ A: [Int], _ B: [Int]) -> [Int] {
        var sortedA = A.sorted(by: <)
        let sortedB = B.enumerated().map { ($0, $1) }.sorted { $0.1 < $1.1 }
        
        var hash = [Int:Int]()
        sortedB.forEach { (index, b) in
            let idx = sortedA.index(where: { $0 > b }) ?? 0
            hash[index] = sortedA.remove(at: idx)
        }
        
        return (0 ..< B.count).map { hash[$0]! }
    }
}

---

976ms

class Solution {
    func advantageCount(_ A: [Int], _ B: [Int]) -> [Int] {
        let sortedA = A.sorted()
        let sortedB = B.sorted()
        
        var i = 0
        var results = [Int]()
        var wastes = [Int]()
        
        for b in sortedB {
            while i < sortedA.count && sortedA[i] <= b {
                wastes.append(sortedA[i])
                i += 1
            }
            
            if i == sortedA.count {
                results += wastes
                break
            } else {
                results.append(sortedA[i])
                i += 1
            }
        }
        
        var map = [Int: [Int]]()
        
        for i in 0..<sortedB.count {
            let b = sortedB[i]
            let r = results[i]
            
            if var row = map[b] {
                row.append(r)
                map[b] = row
            } else {
                map[b] = [r]
            }
        }
        
        var realResults = [Int]()
        
        for b in B {
            var row = map[b]!
            realResults.append(row.removeLast())
            map[b] = row
        } 
        return realResults
    }
}

---

7176ms

class Solution {
    func advantageCount(_ A: [Int], _ B: [Int]) -> [Int] {
        var sortedA = A.sorted(by: <)
        
        var hash = [Int:Int]()
        
        return B.map { b in
            let idx = sortedA.index(where: { $0 > b }) ?? 0
            return sortedA.remove(at: idx)
        }
    }
}