[Swift]LeetCode332. 重新安排行程 | Reconstruct Itinerary

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

Given a list of airline tickets represented by pairs of departure and arrival airports [from, to], reconstruct the itinerary in order. All of the tickets belong to a man who departs from JFK. Thus, the itinerary must begin with JFK.

Note:

1. If there are multiple valid itineraries, you should return the itinerary that has the smallest lexical order when read as a single string. For example, the itinerary ["JFK", "LGA"] has a smaller lexical order than ["JFK", "LGB"].
2. All airports are represented by three capital letters (IATA code).
3. You may assume all tickets form at least one valid itinerary.

Example 1:

Input: [["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]]
Output: ["JFK", "MUC", "LHR", "SFO", "SJC"]

Example 2:

Input: [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
Output: ["JFK","ATL","JFK","SFO","ATL","SFO"]
Explanation: Another possible reconstruction is ["JFK","SFO","ATL","JFK","ATL","SFO"].
             But it is larger in lexical order.

---

给定一个机票的字符串二维数组 [from, to]，子数组中的两个成员分别表示飞机出发和降落的机场地点，对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 出发。

说明:

1. 如果存在多种有效的行程，你可以按字符自然排序返回最小的行程组合。例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前
2. 所有的机场都用三个大写字母表示（机场代码）。
3. 假定所有机票至少存在一种合理的行程。

示例 1:

输入: [["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]]
输出: ["JFK", "MUC", "LHR", "SFO", "SJC"]

示例 2:

输入: [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
输出: ["JFK","ATL","JFK","SFO","ATL","SFO"]
解释: 另一种有效的行程是 ["JFK","SFO","ATL","JFK","ATL","SFO"]。但是它自然排序更大更靠后。

---

144ms

class Solution {
    var graph: [String: [String]] = [:]
    var route: [String] = []
    func findItinerary(_ tickets: [[String]]) -> [String] {
        
        for t in tickets {
            var city = graph[t[0]] ?? []
            city.append(t[1])
            graph[t[0]] = city
        }
        
        for key in graph.keys {
            graph[key]?.sort()
        }
        self.visit("JFK")
        return self.route
    }
    
    private func visit(_ city: String) {
        if let dests = graph[city] {
            while !graph[city]!.isEmpty {
                let dest = graph[city]!.removeFirst()
                self.visit(dest)
            }
        }
        self.route.insert(city, at: 0)
    }
}

---

568ms

class Solution {
     func findItinerary(_ tickets: [[String]]) -> [String] {
        
        let graph = buildGraph(tickets)
        var res = [String]()
        dfs(graph, from: "JFK",0, &res)
        
        return res
    }

    @discardableResult func dfs(_ graph : Graph<String>, from : String ,_ visitedCount : Int, _ res : inout [String]) -> Bool {
        res.append(from)
        if visitedCount == graph.edges.count {
            return true
        }
        let edges = graph.edgesFrom(graph.createVertex(from)).sorted{$0.to.data < $1.to.data}
        for edge in edges where edge.visited == false {
            edge.visited = true
            if dfs(graph, from: edge.to.data, visitedCount+1, &res) == true {
                return true
            }
            edge.visited = false
        }
        res.removeLast()
        return false
        
    }
    
    func buildGraph(_ tickets : [[String]]) -> Graph<String> {
        let graph = Graph<String>()
        for i in 0..<tickets.count {
            let ticket = tickets[i]
            let from = graph.createVertex(ticket[0])
            let to = graph.createVertex(ticket[1])
            graph.addDirectedEdge(from, to: to, withWeight: Double(i))
        }
        return graph
    }
    //===================实现Graph的分割线======================
    struct Vertex<T> : Equatable,Hashable where T : Hashable {
        var data : T
        var index : Int
        
        public var description: String {
            return "(index):(data)"
        }
    }

    public class Edge<T>: Equatable,Hashable where T: Hashable {
        public static func == (lhs: Solution.Edge<T>, rhs: Solution.Edge<T>) -> Bool {
            return lhs.from == rhs.from && lhs.to == rhs.to && lhs.weight == rhs.weight
        }
        
        public let from: Vertex<T>
        public let to: Vertex<T>
        
        public let weight:Double?
        
        public var visited : Bool
        
        public var hashValue:Int {
            var string = "(from.description)(to.description)"
            if weight != nil{
                string.append("(weight!)")
            }
            return string.hashValue
        }
        
        init(from: Vertex<T>, to: Vertex<T>, weight: Double?, visited: Bool) {
            self.from = from
            self.to = to
            self.weight = weight
            self.visited = visited
        }
    }
    

    
    private class EdgeList<T> where T: Hashable {
        
        var vertex: Vertex<T>
        var edges: [Edge<T>]?
        
        init(vertex: Vertex<T>) {
            self.vertex = vertex
        }
        
        func addEdge(_ edge: Edge<T>) {
            edges?.append(edge)
        }
        
    }
    
    
    class Graph<T> where T : Hashable {
        var vertices : [Vertex<T>] {
            var vertices = [Vertex<T>]()
            for edgeList in adjacencyList {
                vertices.append(edgeList.vertex)
            }
            return vertices
        }
        
        private var adjacencyList: [EdgeList<T>] = []
        
        open var edges: [Edge<T>] = [Edge<T>]()

        open func addDirectedEdge(_ from: Vertex<T>, to: Vertex<T>, withWeight weight: Double?) {
            // works
            let edge = Edge(from: from, to: to, weight: weight, visited: false)
            let edgeList = adjacencyList[from.index]
            if edgeList.edges != nil {
                edgeList.addEdge(edge)
            } else {
                edgeList.edges = [edge]
            }
            edges.append(edge)
        }
        
        open func createVertex(_ data: T) -> Vertex<T> {
           
            let matchingVertices = vertices.filter { vertex in
                return vertex.data == data
            }
            
            if matchingVertices.count > 0 {
                return matchingVertices.last!
            }

            let vertex = Vertex(data: data, index: adjacencyList.count)
            adjacencyList.append(EdgeList(vertex: vertex))
            return vertex
        }
        
        open func edgesFrom(_ sourceVertex: Vertex<T>) -> [Edge<T>] {
            return adjacencyList[sourceVertex.index].edges ?? []
        }
                
    }
}