[Swift]LeetCode863. 二叉树中所有距离为 K 的结点 | All Nodes Distance K in Binary Tree

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

We are given a binary tree (with root node root), a targetnode, and an integer value K.

Return a list of the values of all nodes that have a distance Kfrom the target node.  The answer can be returned in any order.

Example 1:

Input: root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, K = 2

Output: [7,4,1]

Explanation: 
The nodes that are a distance 2 from the target node (with value 5)
have values 7, 4, and 1.



Note that the inputs "root" and "target" are actually TreeNodes.
The descriptions of the inputs above are just serializations of these objects.

Note:

1. The given tree is non-empty.
2. Each node in the tree has unique values 0 <= node.val <= 500.
3. The target node is a node in the tree.
4. 0 <= K <= 1000.

---

给定一个二叉树（具有根结点 root）， 一个目标结点 target ，和一个整数值 K 。

返回到目标结点 target 距离为 K 的所有结点的值的列表。 答案可以以任何顺序返回。

示例 1：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, K = 2

输出：[7,4,1]

解释：
所求结点为与目标结点（值为 5）距离为 2 的结点，
值分别为 7，4，以及 1

注意，输入的 "root" 和 "target" 实际上是树上的结点。
上面的输入仅仅是对这些对象进行了序列化描述。

提示：

1. 给定的树是非空的，且最多有 K 个结点。
2. 树上的每个结点都具有唯一的值 0 <= node.val <= 500 。
3. 目标结点 target 是树上的结点。
4. 0 <= K <= 1000.

---

16ms

class Solution {
    func distanceK(_ root: TreeNode?, _ target: TreeNode?, _ K: Int) -> [Int] {
        guard let root = root else { return [] }
        guard let target = target else { return [] }
        
        let result = dfs(root, 0, target: target)
        let path = result.paths.reversed()
        let level = result.level
        
        var results = [Int]()
        var node = root
        
        for (currentLevel, step) in path.enumerated() {
            let t = K - (level - currentLevel) - 1
            if t == -1 {
                results.append(node.val)
            }
            if step {
                if let right = node.right, t >= 0 {
                    results += bfs(right, t)
                }
                node = node.left!
            } else {
                if let left = node.left, t >= 0 {
                    results += bfs(left, t)
                }
                node = node.right!
            }
        }
        
        results += bfs(node, K)
        
        return results
    }
    
    func bfs(_ root: TreeNode, _ targetLevel: Int) -> [Int] {
        var queue = [root]
        var level = 0
        
        while !queue.isEmpty && level < targetLevel {
            var nextQueue = [TreeNode]()
            
            for node in queue {
                if let n = node.left {
                    nextQueue.append(n)
                }
                
                if let n = node.right {
                    nextQueue.append(n)
                }
            }
            
            queue = nextQueue
            level += 1
        }
        
        if level == targetLevel {
            return queue.map { $0.val }
        } else {
            return []
        }
    }
    
    func dfs(_ root: TreeNode, _ level: Int, target: TreeNode) -> (paths: [Bool], level: Int) {
        if root.left === target {
            return ([true], level + 1)
        } else if root.right === target {
            return ([false], level + 1)
        }
        
        if let left = root.left {
            let result = dfs(left, level + 1, target: target)
            if result.level > 0 {
                return (result.paths + [true], result.level)
            }
        }
        
        if let right = root.right {
            let result = dfs(right, level + 1, target: target)
            if result.level > 0 {
                return (result.paths + [false], result.level)
            }
        }
        
        return ([], -1)
    }
}

---

24ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func distanceK(_ root: TreeNode?, _ target: TreeNode?, _ K: Int) -> [Int] {
        guard let root = root, let target = target else { return [] }
        guard K != 0 else { return [target.val] }
        
        var graph: [Int : [Int]] = [:]
        toGraph(&graph, parent: nil, child: root)
        var distances: [Int : Int] = [:]
        distances[target.val] = 0
        var queue: [Int] = [target.val]
        var status: [Int : Bool] = [:]
        var result: [Int] = []
     
        while !queue.isEmpty {
            let current = queue.removeFirst()
            status[current] = true
            guard let connectedV = graph[current] else { break }
            for v in connectedV {
                guard (status[v] ?? false) == false else { continue }
                queue.append(v)
                let distanceV = distances[current]! + 1
                distances[v] = distanceV
                if distanceV == K {
                    result.append(v)
                }
            }
        }
        
        return result
    }
    
    func toGraph(_ result: inout [Int : [Int]], parent: TreeNode?, child: TreeNode) {
        if let parent = parent {
            if result[child.val] == nil {
                result[child.val] = [parent.val]
            }else{
                result[child.val]?.append(parent.val)
            }
            if result[parent.val] == nil {
                result[parent.val] = [child.val]
            }else{
                result[parent.val]?.append(child.val)
            }
        }
        if let left = child.left {
            toGraph(&result, parent: child, child: left)
        }
        if let right = child.right {
            toGraph(&result, parent: child, child: right)
        }
    }
}

---

32ms

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    func distanceK(_ root: TreeNode?, _ target: TreeNode?, _ K: Int) -> [Int] {
        guard let root = root else {
            return []
        }
        
        guard K != 0 else {
            return [target!.val]
        }
        
        let graph = Graph<Int>()
        inorderTraversal(root) {
            node in 
            let source = graph.createVertex(node.val)
            if node.left != nil {
                let destination = graph.createVertex(node.left!.val)
                graph.addUndirectedEdge(between: source, to: destination)
            }
            
            if node.right != nil {
                let destination = graph.createVertex(node.right!.val)
                graph.addUndirectedEdge(between: source, to: destination)
            }
        }
        return breathFirstTraversal(graph, Vertex(target!.val), K)
    }

}

func breathFirstTraversal<T: Hashable>(_ graph: Graph<T>, 
                                       _ source: Vertex<T>, 
                                       _ k: Int     
                                      ) -> [T] {
    var discovered: Set<Vertex<T>> = [source]
    var stack: [Vertex<T>] = [source]
    var k = k 
    while k > 0 {
        var tmp: [Vertex<T>] = []
        while let source = stack.popLast() {
            for edge in graph.edges(of: source) {
                let destination = edge.destination 
                if !discovered.contains(destination) {
                    tmp.append(destination)
                    discovered.insert(destination)
                }
            }
        }
        k -= 1 
        if k == 0 {
            return tmp.map { $0.val }
        }
        if tmp.isEmpty { break }
        stack = tmp
    }
    
    return []
}

func inorderTraversal(_ root: TreeNode?, _ visit: (TreeNode) -> Void) {
    guard let root = root else {
        return 
    }
    inorderTraversal(root.left, visit)
    visit(root)
    inorderTraversal(root.right, visit)
}

struct Vertex<T: Hashable> : Hashable {
    public var val: T 
    public init(_ val: T) {
        self.val = val 
    }
    
    public var hashValue: Int {
        return val.hashValue 
    }
    
    public static func ==(lhs: Vertex<T>, rhs: Vertex<T>) -> Bool {
        return lhs.val == rhs.val
    }
}

struct Edge<T: Hashable> {
    public let source: Vertex<T>
    public let destination: Vertex<T>
    public let weight: Double? 

    public init(source: Vertex<T>, destination: Vertex<T>, weight: Double? = nil) {
        self.source = source 
        self.destination = destination 
        self.weight = weight 
    }
}

class Graph<T: Hashable> {
    public var vertice: [Vertex<T>] = []
    private var adjacencyList: [Vertex<T>: [Edge<T>]] = [:]
    
    public func createVertex(_ val: T) -> Vertex<T> {
        let source = Vertex(val)
        if adjacencyList[source] == nil {
            adjacencyList[source] = []
            vertice.append(source)
        }
        return source
    }
    
    public func addDirectedEdge(from source: Vertex<T>, 
                                to destination: Vertex<T>,
                                weight: Double? = nil 
                               ) {
        let edge = Edge(source: source, destination: destination, weight: weight)
        adjacencyList[source]?.append(edge)
    }
    
    public func addUndirectedEdge(between source: Vertex<T>, 
                                  to destination: Vertex<T>, 
                                  weight: Double? = nil
                                 ) {
        addDirectedEdge(from: source, to: destination, weight: weight)
        addDirectedEdge(from: destination, to: source, weight: weight)
    }
    
    public func edges(of source: Vertex<T>) -> [Edge<T>] {
        return adjacencyList[source] ?? []
    }
    
    public func weight(from source: Vertex<T>, to destination: Vertex<T>) -> Double? {
        return adjacencyList[source]?.first{ $0.destination == destination }?.weight
    }
}

---

Runtime: 32 ms

Memory Usage: 19.2 MB

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.left = nil
 *         self.right = nil
 *     }
 * }
 */
class Solution {
    var map:[(TreeNode,String)] = [(TreeNode,String)]()
    var path:String = String()
    func distanceK(_ root: TreeNode?, _ target: TreeNode?, _ K: Int) -> [Int] {
        var list:[Int] = [Int]()
        getNodeDist(root,target,"")
        var i:Int = 0
        for ele in map
        {
            var s:String = ele.1
            var i:Int = 0
            var arrS:[Character] = Array(s)
            var arrP:[Character] = Array(path)
            while(i<s.count && i<path.count && arrS[i] == arrP[i])
            {
                i += 1
            }
            if s.count - i + path.count - i == K
            {
                list.append(ele.0.val)
            }
        }
        return list        
    }

    func getNodeDist(_ root: TreeNode?,_ target: TreeNode?,_ p:String)
    {
        if root != nil
        {
            path = root!.val == target!.val ? p : path
            map.append((root!, p))
            getNodeDist(root?.left,target,p+"0")
            getNodeDist(root?.right,target,p+"1")
        }
    }    
}