[Swift]LeetCode1030. 距离顺序排列矩阵单元格 | Matrix Cells in Distance Order

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

We are given a matrix with R rows and C columns has cells with integer coordinates (r, c), where 0 <= r < R and 0 <= c < C.

Additionally, we are given a cell in that matrix with coordinates (r0, c0).

Return the coordinates of all cells in the matrix, sorted by their distance from (r0, c0) from smallest distance to largest distance.  Here, the distance between two cells (r1, c1) and (r2, c2) is the Manhattan distance, |r1 - r2| + |c1 - c2|.  (You may return the answer in any order that satisfies this condition.)

Example 1:

Input: R = 1, C = 2, r0 = 0, c0 = 0
Output: [[0,0],[0,1]]
Explanation: The distances from (r0, c0) to other cells are: [0,1]

Example 2:

Input: R = 2, C = 2, r0 = 0, c0 = 1
Output: [[0,1],[0,0],[1,1],[1,0]]
Explanation: The distances from (r0, c0) to other cells are: [0,1,1,2]
The answer [[0,1],[1,1],[0,0],[1,0]] would also be accepted as correct.

Example 3:

Input: R = 2, C = 3, r0 = 1, c0 = 2
Output: [[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
Explanation: The distances from (r0, c0) to other cells are: [0,1,1,2,2,3]
There are other answers that would also be accepted as correct, such as [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]].

Note:

1. 1 <= R <= 100
2. 1 <= C <= 100
3. 0 <= r0 < R
4. 0 <= c0 < C

---

给出 R 行 C 列的矩阵，其中的单元格的整数坐标为 (r, c)，满足 0 <= r < R 且 0 <= c < C。

另外，我们在该矩阵中给出了一个坐标为 (r0, c0) 的单元格。

返回矩阵中的所有单元格的坐标，并按到 (r0, c0) 的距离从最小到最大的顺序排，其中，两单元格(r1, c1) 和 (r2, c2) 之间的距离是曼哈顿距离，|r1 - r2| + |c1 - c2|。（你可以按任何满足此条件的顺序返回答案。）

示例 1：

输入：R = 1, C = 2, r0 = 0, c0 = 0
输出：[[0,0],[0,1]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1]

示例 2：

输入：R = 2, C = 2, r0 = 0, c0 = 1
输出：[[0,1],[0,0],[1,1],[1,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2]
[[0,1],[1,1],[0,0],[1,0]] 也会被视作正确答案。

示例 3：

输入：R = 2, C = 3, r0 = 1, c0 = 2
输出：[[1,2],[0,2],[1,1],[0,1],[1,0],[0,0]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1,1,2,2,3]
其他满足题目要求的答案也会被视为正确，例如 [[1,2],[1,1],[0,2],[1,0],[0,1],[0,0]]。

提示：

1. 1 <= R <= 100
2. 1 <= C <= 100
3. 0 <= r0 < R
4. 0 <= c0 < C

---

264ms

lass Solution {
    
    func allCellsDistOrder(_ R: Int, _ C: Int, _ r0: Int, _ c0: Int) -> [[Int]] {
        var distances = [Int: [[Int]]]()
        var q = Queue<(Int, Int)>()
        var visited = Set<Int>()
        q.push((r0 * C + c0, 0))
        visited.insert(r0 * C + c0)
        while !q.isEmpty {
            let (node, dist) = q.pop()
            let row = node / C
            let col = node % C
            distances[dist, default: []].append([row, col])
            if row > 0 && !visited.contains( (row - 1) * C + col ) {
                q.push(((row - 1) * C + col, dist + 1))
                visited.insert((row - 1) * C + col)
            }
            if row + 1 < R && !visited.contains( (row + 1) * C + col ) {
                q.push(((row + 1) * C + col, dist + 1))
                visited.insert((row + 1) * C + col)
            }
            
            if col > 0 && !visited.contains( row * C + col - 1) {
                q.push((row * C + col - 1, dist + 1))
                visited.insert(row * C + col - 1)
            }
            if col + 1 < C && !visited.contains( row * C + col + 1) {
                q.push((row * C + col + 1, dist + 1))
                visited.insert(row * C + col + 1)
            }
        }
        let keys = distances.keys.sorted()
        var res = [[Int]]()
        for key in keys {
            res += distances[key]!
        }
        return res
    }
}

struct Queue<T> {
    var arr: [T] = []
    var head = 0
    
    mutating func push(_ val: T) {
        arr.append(val)
    }
    
    mutating func pop() -> T {
        let res = arr[head]
        head += 1
        return res
    }
    
    var isEmpty: Bool {
        return head == arr.count
    }
}

---

300ms

class Solution {
    func allCellsDistOrder(_ R: Int, _ C: Int, _ r0: Int, _ c0: Int) -> [[Int]] {
        var res: [([Int], Int)] = []
        for r in (0..<R) {
            for c in (0..<C) {
                res.append(([r,c],abs(r - r0)+abs(c - c0)))
            }
        }
         
        var tt = res.sorted{$0.1<$1.1}
        var rr: [[Int]] = []
        for r in tt {
            rr.append(r.0)
        }
        
        return rr
    }
}

---

316ms

class Solution {
    
    func allCellsDistOrder(_ R: Int, _ C: Int, _ r0: Int, _ c0: Int) -> [[Int]] {
        if R == 0 || C == 0{
            return [[Int]]()
        }
        
        var ar = [[Int]]()
        
        for r in 0..<R{
            for c in 0..<C{
                var left = abs(r0 - r)
                var right = abs(c0 - c)
                var sum = left + right
                ar.append([sum, r, c])
            }
        }
        var res = [[Int]]()
        ar = ar.sorted{$0[0] < $1[0]}
        for i in ar{
            res.append(Array(i[1...2]))
        }
        return res
    }
}

---

320ms

class Solution {
    struct Node {
        var distance: Int
        var coordinate: [Int]
        init(_ distance: Int, _ coordinate: [Int]) {
            self.distance = distance
            self.coordinate = coordinate
        }
    }
    
    func allCellsDistOrder(_ R: Int, _ C: Int, _ r0: Int, _ c0: Int) -> [[Int]] {
        
        var nodes = [Node]()
        for i in 0..<R {
            for j in 0..<C {
                let distance = abs(r0-i) + abs(c0-j)
                nodes.append(Node(distance, [i, j]))
            }
        }
        
        nodes.sort(by: { $0.distance <= $1.distance})
        return nodes.map { $0.coordinate }
    }
}

---

364ms

class Solution {
    func allCellsDistOrder(_ R: Int, _ C: Int, _ r0: Int, _ c0: Int) -> [[Int]] {
        let maxRDist = max(R - r0, r0 - 0)
        let maxCDist = max(C - c0, c0 - 0)
        let maxDist = maxRDist + maxCDist
        var dist = 0
        var allCoors = [[Int]]()
        var set = Set<[Int]>()
        set.insert([r0, c0])
        allCoors += Array(set)

        while dist < maxDist {
            var s = Set<[Int]>()
//            print("====================(set)")
            for coor in set {
                s.formUnion(coors(R, C, r0, c0, coor[0], coor[1], dist))
            }
//            print("==========>>>>>>>>>>>>(s)")
            allCoors += Array(s)
            set = s
            dist += 1
        }
        return allCoors
    }

    func coors(_ R: Int, _ C: Int, _ r0: Int, _ c0: Int, _ r: Int, _ c: Int, _ dist: Int) -> Set<[Int]> {
        let vr = r - r0
        let vc = c - c0
        let dr = vr != 0 ? vr / abs(vr) : 0
        let dc = vc != 0 ? vc / abs(vc) : 0
        var set = Set<[Int]>()
        var newRs: [Int] = []
        var newCs: [Int] = []
        if dr == 0 {
            if r + 1 < R, abs(r + 1 - r0) > abs(vr) {
                newRs.append(r + 1)
            }
            if r - 1 >= 0, abs(r - 1 - r0) > abs(vr) {
                newRs.append(r - 1)
            }
        } else if r + dr < R, r + dr >= 0 {
            newRs.append(r + dr)
        }
        for newR in newRs {
            set.insert([newR, c])
        }
        if dc == 0 {
            if c + 1 < C, abs(c + 1 - c0) > abs(vc) {
                newCs.append(c + 1)
            }
            if c - 1 >= 0, abs(c - 1 - c0) > abs(vc) {
                newCs.append(c - 1)
            }
        } else if c + dc < C, c + dc >= 0 {
            newCs.append(c + dc)
        }
        for newC in newCs {
            set.insert([r, newC])
        }
        return set
    }
}

---

384ms

class Solution {
    func allCellsDistOrder(_ R: Int, _ C: Int, _ r0: Int, _ c0: Int) -> [[Int]] {
        var distances: [[Int]] = Array(repeating: Array(repeating: 0, count: C), count: R)
        var result: [[Int]] = []
        for r in 0...(R - 1) {
            for c in 0...(C - 1) {
                let distance = (c - c0).magnitude + (r - r0).magnitude
                distances[r][c] = Int(distance)
                result.append([r,c])
            }
        }
        
        return result.sorted { distances[$0[0]][$0[1]] < distances[$1[0]][$1[1]] }
    }
}

---

400ms

class Solution {
    func allCellsDistOrder(_ R: Int, _ C: Int, _ r0: Int, _ c0: Int) -> [[Int]] {
        var result = [[Int]]()
        
        for i in 0..<R {
            for j in 0..<C {
                result.append([i,j])
            }
        }
        
        return result.sorted { distance($0[0], $0[1], r0, c0) < distance($1[0], $1[1], r0, c0 )}
    }
    
    private func distance(_ R1: Int, _ C1: Int, _ R0: Int, _ C0: Int) -> Int {
        return abs(R0-R1) + abs(C0-C1)
    }
}

---

Runtime: 480 ms

Memory Usage: 20.5 MB

class Solution {
    func allCellsDistOrder(_ R: Int, _ C: Int, _ r0: Int, _ c0: Int) -> [[Int]] {
        //优先队列
        var q = Heap<(Int,[Int])>.init { (f, s) -> Bool in
            return f.0 < s.0
        }

        for i in 0..<R
        {
            for j in 0..<C
            {
                q.insert((getManhattan([r0,c0],[i,j]),[i,j]))
            }
        }
        var res:[[Int]] = [[Int]]()
        while(!q.isEmpty)
        {
            res.append(q.remove()!.1)
        }
        return res     
    }
    
    func getManhattan(_ p1:[Int],_ p2:[Int]) -> Int
    {
        return Int(abs(Double(p1[0] - p2[0])) + abs(Double(p1[1] - p2[1])))
    }
}

public struct Heap<T> {
    public var nodes = [T]()
    private var orderCriteria: (T, T) -> Bool
    
    public init(sort: @escaping (T, T) -> Bool) {
        orderCriteria = sort
    }
    
    public init(array: [T], sort: @escaping (T, T) -> Bool) {
        self.orderCriteria = sort
        configureHeap(from: array)
    }
    
    public var isEmpty: Bool {
        return nodes.isEmpty
    }
    
    public var count: Int {
        return nodes.count
    }
    
    public mutating func configureHeap(from array: [T]) {
        nodes = array
        for i in stride(from: nodes.count / 2 - 1, through: 0, by: -1) {
            shiftDown(i)
        }
    }
    
    public mutating func reset() {
        for i in stride(from: nodes.count / 2 - 1, through: 0, by: -1) {
            shiftDown(i)
        }
    }
    
    @inline(__always) internal func parentIndex(ofIndex index: Int) -> Int {
        return (index - 1) / 2
    }
    
    @inline(__always) internal func leftChildIndex(ofIndex index: Int) -> Int {
        return index * 2 + 1
    }
    
    @inline(__always) internal func rightChildIndex(ofIndex index: Int) -> Int {
        return index * 2 + 2
    }
    
    public func peek() -> T? {
        return nodes.first
    }
    
    internal mutating func shiftUp(_ index: Int) {
        var childIndex = index
        let child = nodes[childIndex]
        var parentIndex = self.parentIndex(ofIndex: index)
        while childIndex > 0 && orderCriteria(child, nodes[parentIndex]) {
            nodes[childIndex] = nodes[parentIndex]
            childIndex = parentIndex
            parentIndex = self.parentIndex(ofIndex: childIndex)
        }
        nodes[childIndex] = child
    }
    
    internal mutating func shiftDown(from index: Int, until endIndex: Int) {
        let leftChildIndex = self.leftChildIndex(ofIndex: index)
        let rightChildIndex = self.rightChildIndex(ofIndex: index)
        
        var first = index
        if leftChildIndex < endIndex && orderCriteria(nodes[leftChildIndex], nodes[first]) {
            first = leftChildIndex
        }
        if rightChildIndex < endIndex && orderCriteria(nodes[rightChildIndex], nodes[first]) {
            first = rightChildIndex
        }
        if first == index {
            return
        }
        nodes.swapAt(index, first)
        shiftDown(from: first, until: endIndex)
    }
    
    internal mutating func shiftDown(_ index: Int) {
        shiftDown(from: index, until: nodes.count)
    }
    
    public mutating func insert(_ value: T) {
        nodes.append(value)
        shiftUp(nodes.count - 1)
    }
    
    public mutating func insert<S: Sequence>(_ sequence:S) where S.Iterator.Element == T {
        for value in sequence {
            insert(value)
        }
    }
    
    public mutating func replace(index i: Int, value: T) {
        guard i < nodes.count else {
            return
        }
        remove(at: i)
        insert(value)
    }
    
    @discardableResult
    public mutating func remove() -> T? {
        guard !nodes.isEmpty else {
            return nil
        }
        if nodes.count == 1 {
            return nodes.removeLast()
        } else {
            let value = nodes[0]
            nodes[0] = nodes.removeLast()
            shiftDown(0)
            return value
        }
    }
    
    @discardableResult
    public mutating func remove(at index: Int) -> T? {
        guard index < nodes.count else { return nil}
        let size = nodes.count - 1
        if index != size {
            nodes.swapAt(index, size)
            shiftDown(from: index,  until: size)
            shiftUp(index)
        }
        return nodes.removeLast()
    }
    
    public mutating func sort() -> [T] {
        for i in stride(from: self.nodes.count - 1, to: 0, by: -1) {
            nodes.swapAt(0, i)
            shiftDown(from: 0, until: i)
        }
        return nodes
    }    
}