[Swift]LeetCode406. 根据身高重建队列 | Queue Reconstruction by Height

原文地址：https://www.cnblogs.com/strengthen/p/10311344.html 

Suppose you have a random list of people standing in a queue. Each person is described by a pair of integers (h, k), where h is the height of the person and k is the number of people in front of this person who have a height greater than or equal to h. Write an algorithm to reconstruct the queue.

Note:
The number of people is less than 1,100.

Example

Input:
[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]

Output:
[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]

---

假设有打乱顺序的一群人站成一个队列。 每个人由一个整数对(h, k)表示，其中h是这个人的身高，k是排在这个人前面且身高大于或等于h的人数。 编写一个算法来重建这个队列。

注意：
总人数少于1100人。

示例

输入:
[[7,0], [4,4], [7,1], [5,0], [6,1], [5,2]]

输出:
[[5,0], [7,0], [5,2], [6,1], [4,4], [7,1]]

---

128ms

class Solution {
    func reconstructQueue(_ people: [[Int]]) -> [[Int]] {
        let ps = people.sorted { p1, p2 in
          if p1[0] == p2[0] { return p1[1] < p2[1] }
          return p1[0] > p2[0]
        }
        var result: [[Int]] = []
        for p in ps {
          result.insert(p, at: p[1])
        }
        return result
    }
}

---

136ms

class Solution {
    func reconstructQueue(_ people: [[Int]]) -> [[Int]] {
        guard !people.isEmpty else { return [] }
        var sortedPeople = people.sorted { $0[0] == $1[0] ? $0[1] < $1[1] : $0[0] > $1[0] }
        var curr = sortedPeople[0][0]
        var bucket = [sortedPeople[0]]
        var peopleHeightBuckets = [[[Int]]]()
        for person in sortedPeople[1...] {
            if person[0] == curr {
                bucket.append(person)
            } else {
                peopleHeightBuckets.append(bucket)
                curr = person[0]
                bucket = [person]
            }
        }
        peopleHeightBuckets.append(bucket)
        
        var queue = [[Int]]()
        queue.reserveCapacity(people.count)
        queue.append(contentsOf: peopleHeightBuckets[0])
        for bucket in peopleHeightBuckets[1...] {
            for person in bucket {
                queue.insert(person, at: min(person[1], queue.count))
            }
        }
        return queue
    }
}

---

140ms

class Solution {
    func reconstructQueue(_ people: [[Int]]) -> [[Int]] {
        var people = people
        people.sort(by:{(a:[Int],b:[Int]) in 
        return a[0] > b[0] || (a[0] == b[0] && a[1] < b[1])})
        for i in 0..<people.count
        {
            var p:[Int] = people[i]
            if p[1] != i
            {
                people.remove(at:i)
                people.insert(p, at: p[1] )
            }
        }
        return people
    }
}

---

160ms

class Solution {
    func reconstructQueue(_ people: [[Int]]) -> [[Int]] {
        var res = [[Int]]()
        people.sorted(by: { ($0[0] == $1[0]) ? $0[1] < $1[1] : $0[0] > $1[0]                    }).forEach({res.insert($0, at: $0[1])})
        return res
    }
}

---

168ms

class Solution {
    func reconstructQueue(_ people: [[Int]]) -> [[Int]] {
        let people = people.sorted { $0[0] == $1[0] ? $0[1] < $1[1] : $0[0] > $1[0] }
        var result = [[Int]]()
        
        for person in people {
            result.insert(person, at: person[1])
        }
        
        return result
    }
}

---

368ms

class Solution {
    func reconstructQueue(_ people: [[Int]]) -> [[Int]] {
        let sorted = people.sorted {
            if $0.first! == $1.first! {
                return $0.last! < $1.last!
            } else {
                return $0.first! > $1.first!
            }
        }
        
        var res = [[Int]]()
        
        loop: for person in sorted {
            var num = 0
            for i in 0..<res.count {
                if num == person.last! {
                    res.insert(person, at: i)
                    continue loop
                }
                num += 1
            }
            
            res.append(person)
        }
        
        return res
    }
}

---

1164ms

import Foundation

class Solution {
  func reconstructQueue(_ people: [[Int]]) -> [[Int]] {
    let sortedPairArray = people.sorted { (pair1, pair2) -> Bool in
      var diff = pair1[0] - pair2[0]
      if diff == 0 {
        diff = pair1[1] - pair2[1]
      }
      return diff < 0
    }

    let peopleCount = people.count
    var outputArray = Array(repeating: [Int.max, 0], count: peopleCount)
    for pair in sortedPairArray {
      let index = findIndex(existingArray: outputArray, pair: pair)

      if index >= 0 {
        outputArray[index][0] = pair[0]
        outputArray[index][1] = pair[1]
      }
    }
    return outputArray
  }

  func findIndex(existingArray: [[Int]], pair: [Int]) -> Int {
    let peopleCount = existingArray.count
    var count = 0
    for i in 0..<peopleCount {
      if count == pair[1] {
        for j in i..<peopleCount {
          let existingPair = existingArray[i]
          if existingPair[0] == Int.max {
            return j
          }
        }
      }

      let existingPair = existingArray[i]
      if existingPair[0] >= pair[0] {
        count += 1
      }
    }
    return -1
  }
}

---

2140ms

class Solution {
    func reconstructQueue(_ people: [[Int]]) -> [[Int]] {
       var res = [[Int]](repeating: [Int](), count: people.count)
       var arr = people 
        arr.sort {$0.first! < $1.first!} 
       for item in arr {
           let number = item.last!
           let height = item.first!
           var count = 0
           for i in 0..<res.count {
               let slot = res[i]
               if slot.count == 0 || slot.first! >= height {    
                   if count == number {
                       res[i] = item
                   }
                   count += 1
               }
           }
       }
        return res
    }
}