[Swift]LeetCode743. 网络延迟时间 | Network Delay Time

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

There are N network nodes, labelled 1 to N.

Given times, a list of travel times as directededges times[i] = (u, v, w), where u is the source node, v is the target node, and w is the time it takes for a signal to travel from source to target.

Now, we send a signal from a certain node K. How long will it take for all nodes to receive the signal? If it is impossible, return -1.

Note:

1. N will be in the range [1, 100].
2. K will be in the range [1, N].
3. The length of times will be in the range [1, 6000].
4. All edges times[i] = (u, v, w) will have 1 <= u, v <= N and 0 <= w <= 100.

---

有 N 个网络节点，标记为 1 到 N。

给定一个列表 times，表示信号经过有向边的传递时间。 times[i] = (u, v, w)，其中 u 是源节点，v 是目标节点， w 是一个信号从源节点传递到目标节点的时间。

现在，我们向当前的节点 K 发送了一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1。

注意:

1. N 的范围在 [1, 100] 之间。
2. K 的范围在 [1, N] 之间。
3. times 的长度在 [1, 6000] 之间。
4. 所有的边 times[i] = (u, v, w) 都有 1 <= u, v <= N 且 0 <= w <= 100。

---

Runtime: 496 ms

Memory Usage: 19.3 MB

class Solution {
    func networkDelayTime(_ times: [[Int]], _ N: Int, _ K: Int) -> Int {
        var res:Int = 0
        var edges:[Int:[(Int,Int)]] = [Int:[(Int,Int)]]()
        var dist:[Int] = [Int](repeating:Int.max,count:N + 1)
        var q:[Int] = [K]
        dist[K] = 0
        for e in times
        {
            edges[e[0],default:[(Int,Int)]()].append((e[1], e[2]))
        }
        while (!q.isEmpty)
        {
            var u:Int = q.first!
            q.removeFirst()
            var visited:Set<Int> = Set<Int>()
            for (key,val) in edges[u,default:[(Int,Int)]()]
            {
                var v:Int = key
                var w:Int = val
                if dist[u] != Int.max && dist[u] + w < dist[v]
                {
                    dist[v] = dist[u] + w
                    if visited.contains(v) {continue}
                    visited.insert(v)
                    q.append(v)
                }
            }        
        }
        for i in 1...N
        {
            res = max(res, dist[i])        
        }
        return res == Int.max ? -1 : res
    }
}

---

604ms

class Solution {
        func networkDelayTime(_ times: [[Int]], _ N: Int, _ K: Int) -> Int {
        guard  times.count > 0 else {
            return -1
        }
        
        
        var graph = [[Int]](repeating:[Int](repeating:-1, count:N + 1), count: N + 1)
        
        for t in times {
            graph[t[0]][t[1]] = t[2]
        }
        
        var memo = [Int: Int]()
        var visited = [Int: Bool]()
        //We need to use bfs
        var queue = [Int]()
        for i in 1...N {
            queue.append(i)
            memo[i] = Int.max
        }
        
        memo[K] = 0
        
        while queue.count != 0 {
            queue.sort(by:{ memo[$0]! < memo[$1]!  })
            let node = queue.removeFirst()
            visited[node] = true
            
            for i in 0..<graph[node].count {
                if visited[i] == true || graph[node][i] == -1 {
                    continue
                } else {
                    memo[i]! = min(memo[i]!, memo[node]! + graph[node][i])
                }
            }
        }
        
        var maxT = 0
        
        print(memo)
            
        
        for i in 1...N {
            if let time = memo[i] {
                if time == Int.max {
                    return -1
                } else {
                     maxT = max(maxT, time)
                }
            }
        }
        
        return maxT
    }
}

---

660ms

class Solution {
  func networkDelayTime(_ times: [[Int]], _ N: Int, _ K: Int) -> Int {
    var delayTimes = Array(repeating: Int.max, count: N + 1)
    delayTimes[K] = 0
    
    var nodeLeft = Array(repeating: 1, count: N + 1)
    
    while true {
      var closest = Int.max
      var closestIndex = -1
      for i in 1..<nodeLeft.count {
        if nodeLeft[i] != 0 && delayTimes[i] < closest {
          closest = delayTimes[i]
          closestIndex = i
        }
      }
      
      if closestIndex == -1 {
        break
      }
      
      for i in 0..<times.count {
        if times[i][0] == closestIndex {
          delayTimes[times[i][1]] = min(delayTimes[times[i][1]], delayTimes[times[i][0]] + times[i][2])
        }
      }
      
      nodeLeft[closestIndex] = 0
    }
    
    var delayTime = 0
    
    for i in 1..<delayTimes.count {
      if delayTimes[i] == Int.max {
        return -1
      } else {
        delayTime = max(delayTime, delayTimes[i])
      }
    }
    
    return delayTime
  }
}

---

680ms

class Solution {
  func networkDelayTime(_ times: [[Int]], _ N: Int, _ K: Int) -> Int {
    var delayTimes = Array(repeating: Int.max, count: N)
    delayTimes[K - 1] = 0
    
    var nodeLeft = Array(repeating: 1, count: N)
    
    while true {
      var closest = Int.max
      var closestIndex = -1
      for i in 0..<nodeLeft.count {
        if nodeLeft[i] != 0 && delayTimes[i] < closest {
          closest = delayTimes[i]
          closestIndex = i + 1
        }
      }
      
      if closestIndex == -1 {
        break
      }
      
      for i in 0..<times.count {
        if times[i][0] == closestIndex {
          delayTimes[times[i][1] - 1] = min(delayTimes[times[i][1] - 1], delayTimes[times[i][0] - 1] + times[i][2])
        }
      }
      
      nodeLeft[closestIndex - 1] = 0
    }
    
    return delayTimes.max()! == Int.max ? -1 : delayTimes.max()!
  }
}

---

712ms

class Solution {
    func networkDelayTime(_ times: [[Int]], _ N: Int, _ K: Int) -> Int {
    let graph = Graph<Int>(.undirected)
    times.forEach { (time) in
        let source = graph.createVertex(time[0])
        let destination = graph.createVertex(time[1])
        graph.addDirectedEdge(from: source, to: destination, weight: Double(time[2]))
    }
    
    var distances: [Vertex<Int>: Int] = [:]
    var parent: [Vertex<Int>: Vertex<Int>] = [:]
    dijstra(graph, source: graph.createVertex(K), distances: &distances, parent: &parent)
    if distances.count != N {
        return -1 
    }
    return distances.reduce(into: 0, { $0 = max($0, $1.value) })
}


func dijstra<T: Hashable>(_ graph: Graph<T>,
                          source: Vertex<T>,
                          distances: inout [Vertex<T>: Int],
                          parent: inout [Vertex<T>: Vertex<T>]
    ) {
    var source = source
    var inTree: Set<Vertex<T>> = []
    distances[source] = 0
    
    while !inTree.contains(source) {
        inTree.insert(source)
        
        for edge in graph.edges(of: source) {
            let destination = edge.destination
            let edgeWeight = Int(edge.weight!)
            if distances[destination] == nil ||
                distances[destination]! > edgeWeight + distances[source]! {
                distances[destination] = edgeWeight + distances[source]!
                parent[destination] = source
            }
        }
        var minDistance = Int.max
        for (vertex, distance) in distances where !inTree.contains(vertex) {
            if minDistance > distance {
                minDistance = distance
                source = vertex
            }
        }
    }
    
}
}

enum GraphType {
    case directed
    case undirected
}


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
    }
}

extension Vertex: CustomStringConvertible{
    var description: String{
        return "(val)"
    }
}


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

class Graph<T: Hashable>{
    public var vertices : [Vertex<T>] = []
    private var adjacencyList : [Vertex<T> : [Edge<T>]] = [:]
    public var type: GraphType
    public init(_ type: GraphType) {
        self.type = type
    }
    
    public func createVertex(_ val: T)->Vertex<T>{
        let vertex = Vertex<T>.init(val)
        if adjacencyList[vertex] == nil{
            adjacencyList[vertex] = []
            vertices.append(vertex)
        }
        return vertex
    }
    
    public func addDirectedEdge(from source: Vertex<T>,
                                to destination: Vertex<T>,
                                weight: Double?
        ){
        let edge = Edge<T>.init(source: source, destination: destination, weight: weight)
        adjacencyList[source]?.append(edge)
    }
    
    public func addUndirectedEdge(between source: Vertex<T>,
                                  and destination: Vertex<T>,
                                  weight: Double?
        ){
        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(of source: Vertex<T>,
                       to destination: Vertex<T>
        )->Double?{
        return adjacencyList[source]?.first(where: {$0.destination == destination})?.weight
    }
}

---

800ms

class Solution {
    typealias link = (target: Int, delay: Int)
    
    private class node {
        var distance = Int.max
        var next = [link]()
    }
    
    func networkDelayTime(_ times: [[Int]], _ N: Int, _ K: Int) -> Int {
        var dict = [Int:node]()
        var visited = Set([K])
        
        for index in 1...N {
            dict[index] = node()
        }
        
        for time in times {
            dict[time[0]]!.next.append((time[1],time[2]))
        }
        
        dict[K]!.distance = 0
        
        while (visited.count != N) {
            var shortestDist = Int.max; var shortestIndex = 0
            for index in visited {
                let tmpNode = dict[index]!
                var counter = 0
                for connectedNodes in tmpNode.next {
                    let tmpIndex = connectedNodes.target
                    if visited.contains(tmpIndex) {
                        _ = tmpNode.next.remove(at: counter)
                        continue
                    }
                    counter += 1
                    let tmpDist = connectedNodes.delay + tmpNode.distance
                    let prevDist = dict[tmpIndex]!.distance
                    
                    if (tmpDist < prevDist) {
                        dict[tmpIndex]!.distance = tmpDist
                    }
                    if (tmpDist < shortestDist) {
                        shortestDist = tmpDist
                        shortestIndex = tmpIndex
                    }
                }
            }
            if (shortestIndex == 0) {
                return -1
            }
            visited.insert(shortestIndex)
        }
        
        var maxDelay = 0
        
        for nodes in dict.values where (nodes.distance > maxDelay) {
            maxDelay = nodes.distance
        }
        
        return maxDelay
    }
}