[Swift]LeetCode787. K 站中转内最便宜的航班 | Cheapest Flights Within K Stops

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

There are n cities connected by m flights. Each fight starts from city u and arrives at v with a price w.

Now given all the cities and flights, together with starting city src and the destination dst, your task is to find the cheapest price from src to dst with up to k stops. If there is no such route, output -1.

Example 1:
Input: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 1
Output: 200
Explanation: 
The graph looks like this:

0
2

Example 2:
Input: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 0
Output: 500
Explanation: 
The graph looks like this:

0
2

Note:

• The number of nodes n will be in range [1, 100], with nodes labeled from 0 to n - 1.
• The size of flights will be in range [0, n * (n - 1) / 2].
• The format of each flight will be (src, dst, price).
• The price of each flight will be in the range [1, 10000].
• k is in the range of [0, n - 1].
• There will not be any duplicated flights or self cycles.

---

有 n 个城市通过 m 个航班连接。每个航班都从城市 u 开始，以价格 w 抵达 v。

现在给定所有的城市和航班，以及出发城市 src 和目的地 dst，你的任务是找到从 src 到 dst 最多经过 k 站中转的最便宜的价格。 如果没有这样的路线，则输出 -1。

示例 1:
输入: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 1
输出: 200
解释: 
城市航班图如下

从城市 0 到城市 2 在 1 站中转以内的最便宜价格是 200，如图中红色所示。

示例 2:
输入: 
n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
src = 0, dst = 2, k = 0
输出: 500
解释: 
城市航班图如下

从城市 0 到城市 2 在 0 站中转以内的最便宜价格是 500，如图中蓝色所示。

提示：

• n 范围是 [1, 100]，城市标签从 0 到 n - 1.
• 航班数量范围是 [0, n * (n - 1) / 2].
• 每个航班的格式 (src, dst, price).
• 每个航班的价格范围是 [1, 10000].
• k 范围是 [0, n - 1].
• 航班没有重复，且不存在环路

---

68ms

class Solution {    
        func findCheapestPrice(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ K: Int) -> Int {
        var grid = [[Int]](repeating: [Int](repeating: 0, count: n), count: n)
        for flight in flights {
            grid[flight[1]][flight[0]] = flight[2]
        }
        var k = K
        var dsts = [(dst, 0)], nextDst = [(Int, Int)]()
        var ans = Int.max
        while dsts.count > 0 && k >= 0 {
            let (validDst, v) = dsts.removeFirst()
            for i in grid[validDst].indices {
                if grid[validDst][i] != 0 {
                    if i == src { ans = min(ans, grid[validDst][i] + v) }
                    else {
                        if ans >= grid[validDst][i] + v  {
                            nextDst.append((i, grid[validDst][i] + v))
                        }
                    }
                }
            }
            if dsts.count == 0 {
                dsts = nextDst
                nextDst.removeAll()
                k -= 1
            }
        }
        return ans == Int.max ? -1 : ans
    }
    
    func mainBFS(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ K: Int) -> Int {
        
        var queue = Queue<City>()
        queue.enqueue(src)
        
        var visited = Set<City>()
        var stops = 0
        var cheapestPrice = 0
        
        let graph = genGraph(flights)
        
        while let fromCity = queue.dequeue() {
            
            if fromCity == dst {
                return cheapestPrice
            }
            
            if stops == K {
                // check if we can make it to the destination 
                // or return -1 since we will have exceeded max layovers
                var priceToDst = -1
                if let nextCities = graph[fromCity] {
                    var i = 0
                    var foundDst = false
                    while i < nextCities.count && !foundDst {
                        if nextCities[i] == dst {
                            priceToDst = cheapestPrice + price(flights, from: fromCity, to: nextCities[i])
                            foundDst = true
                        }
                        i += 1
                    }
                }
                return priceToDst
            }
            
            // Look ahead and choose the next cheapest flight (Dijkstra's algorithm)
            // Important! This only works with positive edge values.
            if let toCity = nextCheapestCity(from: fromCity, graph: graph, flights: flights) {

                // Don't revisit a city we have already traveled to
                if !visited.contains(toCity) {
                   // visited.insert(toCity)

                    // Cheapest prices so far
                    cheapestPrice += price(flights, from: fromCity, to: toCity)

                    // Stops
                    stops += 1

                    // Enqueue next city
                    queue.enqueue(toCity)
                }
            }
        }
        print("returned here with cheapest price -> \(cheapestPrice)")
        return -1
    }
    
    func mainDFS(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ K: Int) -> Int {
        var minPrice = Int.max
        var curPrice = 0
        var curLayovers = 0
        var visited = Set<Int>()
        var found = false
        let graph = genGraph(flights)
        visited.insert(src)
        dfs(flights, dst: dst, k: K, graph: graph, vertex: src, curPrice: &curPrice, curLayovers: &curLayovers, visited: &visited, found: &found, minPrice: &minPrice)
        return found ? minPrice : -1
    }
    
    func dfs(_ flights: [[Int]], dst: Int, k: Int, graph: [City: [City]], vertex: Int, curPrice: inout Int, curLayovers: inout Int, visited: inout Set<Int>, found: inout Bool, minPrice: inout Int) {
        if vertex == dst {
            found = true
            if curPrice < minPrice {
                minPrice = curPrice
            }
            return
        }
        if curLayovers > k {
            return
        }
        
        if let destinations = graph[vertex] {
            destinations.forEach { neighbor in
            if !visited.contains(neighbor) {
                var toPrice = price(flights, from: vertex, to: neighbor)
                curPrice += toPrice
                curLayovers += 1
                dfs(flights, dst: dst, k: k, graph: graph, vertex: neighbor, curPrice: &curPrice, curLayovers: &curLayovers, visited: &visited, found: &found, minPrice: &minPrice)
                visited.remove(neighbor)
                curPrice -= toPrice
                curLayovers -= 1
            }
        }
        }

    }
    
    // Helpers
    
    typealias City = Int
    typealias Price = Int
        
    struct Queue<Element> {
        var storage = [Element]()
        mutating func enqueue(_ element: Element) {
            self.storage.append(element)
        }
        mutating func dequeue() -> Element? {
            guard self.storage.count > 0 else { return nil }
            return self.storage.removeFirst()
        }
    }
    
    func genGraph(_ flights: [[Int]]) -> [City: [City]] {
        var graph = [Int: [Int]]()
        flights.forEach { flight in 
            let from = flight[0]
            let to = flight[1]
            if var edges = graph[from] {
                edges.append(to)
                graph[from] = edges
            } else {
                graph[from] = [to]
            }
        }
        return graph
    }
    
    func price(_ flights: [[Int]], from: Int, to: Int) -> Int {
        var i = 0
        while i < flights.count {
            let flight = flights[i]
            if from == flight[0], to == flight[1] {
                return flight[2]
            }
            i += 1
        }
        return -1
    }
    
    // Note: This can be done when creating the graph instead for the BFS solution to improve performance
    func nextCheapestCity(from city: City, graph: [City: [City]], flights: [[Int]]) -> City? {
        var nextCity: City?
        var minPrice = Int.max
        if let toCities = graph[city] {
            toCities.forEach { toCity in
                let priceToCity = price(flights, from: city, to: toCity)
                if priceToCity < minPrice {
                    minPrice = priceToCity
                    nextCity = toCity
                }
            }
        }
        return nextCity
    }    
    // Helpers - end
}

---

76ms

class Solution {
    func findCheapestPrice(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ K: Int) -> Int {
        var grid = [[Int]](repeating: [Int](repeating: 0, count: n), count: n)
        for flight in flights {
            grid[flight[1]][flight[0]] = flight[2]
        }
        var k = K
        var dsts = [(dst, 0)], nextDst = [(Int, Int)]()
        var ans = Int.max
        while dsts.count > 0 && k >= 0 {
            let (validDst, v) = dsts.removeFirst()
            for i in grid[validDst].indices {
                if grid[validDst][i] != 0 {
                    if i == src { ans = min(ans, grid[validDst][i] + v) }
                    else {
                        if ans >= grid[validDst][i] + v  {
                            nextDst.append((i, grid[validDst][i] + v))
                        }
                    }
                }
            }

            if dsts.count == 0 {
                dsts = nextDst
                nextDst.removeAll()
                k -= 1
            }
        }
        return ans == Int.max ? -1 : ans
    }
}

---

Runtime: 96 ms

Memory Usage: 18.9 MB

class Solution {
    func findCheapestPrice(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ K: Int) -> Int {
        var dp:[Double] = [Double](repeating:1e9,count:n)
        dp[src] = 0
        for i in 0...K
        {
            var t:[Double] = dp
            for x in flights
            {
                t[x[1]] = min(t[x[1]], dp[x[0]] + Double(x[2]))
            }
            dp = t
        }
        return (dp[dst] >= 1e9) ? -1 : Int(dp[dst])
    }
}

---

96ms

class Solution {
    func findCheapestPrice(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ K: Int) -> Int {
        
        
        let maxValue = 2147483647
        
        var ShortestPath = [Int](repeating: maxValue, count: n)
        ShortestPath[src] = 0
        
        for _ in 0...K{
            var currentShortestPath = ShortestPath
            
            for i in 0..<flights.count{
                let flight = flights[i]
                let originCity      = flight[0]
                let destinationCity = flight[1]
                let flightCost      = flight[2]
                
          
                
                currentShortestPath[destinationCity] = min(currentShortestPath[destinationCity],
                                                          ShortestPath[originCity] + flightCost)
                
            } 
            ShortestPath = currentShortestPath
        }
        
        
        if ShortestPath[dst] == maxValue{
            return -1
        }else{
            return ShortestPath[dst]
        }
    }
}

---

100ms

class Solution {
    typealias Flight = (dst: Int, cost: Int)
    func findCheapestPrice(_ n: Int, _ flights: [[Int]], _ start: Int, _ end: Int, _ k: Int) -> Int {
        guard flights.isEmpty == false else {
            return 0
        }
        var dict: [Int: [Flight]] = [:]
        for flight in flights {
            dict[flight[0], default: []].append((flight[1], flight[2]))
        }
        
        var res = Int.max
        var queue: [Flight] = []
        queue.append((start, 0))
        var stops = -1

        while queue.isEmpty == false {
            let n = queue.count
            for _ in 0..<n {
                let curFlight = queue.removeFirst()
                let curStop = curFlight.dst
                let cost = curFlight.cost
                if curStop == end {
                    res = min(res, cost)
                    continue
                }
                for flight in (dict[curStop] ?? []) {
                    if cost + flight.cost > res {
                        continue
                    }
                    queue.append((flight.dst, cost + flight.cost))
                }
            }
            stops += 1
            if stops > k {
                break
            }
        }
        return (res == Int.max) ? -1 : res
    }
}

---

136ms

class Solution {
  func findCheapestPrice(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ K: Int) -> Int {
    var flightsMap = Dictionary<Int, Array<Flight>>()
    var cache = Dictionary<CacheState, Int>()  
    for flight in flights {
      let stFlight = Flight(destination: flight[1], cost: flight[2])
      if var array = flightsMap[flight[0]] {
        array.append(stFlight)
        flightsMap[flight[0]] = array
      } else {
        flightsMap[flight[0]] = [stFlight]
      }
    }
    let ans = dfs(K, src, dst, flightsMap, &cache)
    if ans == Int.max { return -1 }
    return ans
  }
  func dfs(
    _ remainingK: Int,
    _ currentNode: Int,
    _ dst: Int,
    _ flightsMap: Dictionary<Int, Array<Flight>>,
    _ cache: inout Dictionary<CacheState, Int>) -> Int {
    if currentNode == dst { return 0 }
    guard remainingK >= 0 else { return Int.max }
    var cacheState = CacheState(source: currentNode, K: remainingK)  
    if let val = cache[cacheState] { return val } 
    var ans = Int.max
    guard let array = flightsMap[currentNode] else { return Int.max }
    for flight in array {
      let curAns = dfs(remainingK - 1, flight.destination, dst, flightsMap, &cache)
      if curAns != Int.max {
        ans = min(ans, curAns + flight.cost)
      }
    }
    cache[cacheState] = ans
    return ans
  }
}

struct Flight {
  let destination: Int
  let cost: Int
}
struct CacheState: Hashable {
  let source: Int
  let K: Int
}

---

152ms

class Solution {
    func findCheapestPrice(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ K: Int) -> Int {
        let dict =  flights.reduce(into: [Int: [(Int, Int)]]()) {
            $0[$1[0], default:[]].append(($1[1], $1[2]))
        }
        var cache: [[Int?]] = Array(repeating: Array(repeating: nil, count: K+1), count: n)
        let c = dfs(dict, src, dst, K, &cache)
        return c 
    }
    
    func dfs(_ flights: [Int: [(Int, Int)]], _ src: Int, _ dst: Int, _ K: Int, _ cache: inout [[Int?]]) -> Int {
        guard src != dst else { return 0 }
        guard K >= 0 else { return -1 }
        var m : Int?
        if let dests = flights[src] { 
            for f in dests {
                let c = cache[f.0][K] ?? dfs(flights, f.0, dst, K-1, &cache)
                if c != -1 {
                   cache[f.0][K] = c
                   m = min(m ?? Int.max, c+f.1) 
                }  else {
                    cache[f.0][K] = -1
                }
            }
        }
        return m ?? -1
    }
}

---

156ms

class Solution {
    var res = Int.max
    func findCheapestPrice(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ K: Int) -> Int {
        var graph: [Int: [(Int, Int)]] = [:]

        for f in flights {
            let start = f[0], end = f[1], price = f[2]
            graph[start, default: []].append((end, price))
        }
        var visited = Set<Int>()
        var dp: [Int: Int] = [:]
        dfs(graph, &dp, 0, &visited, src, dst, K)
        return res == Int.max ? -1 : res
    }

    private func dfs(_ graph: [Int: [(Int, Int)]], _ dp: inout [Int: Int], _ cost: Int, _ visited: inout Set<Int>, _ start: Int, _ end: Int, _ remaining: Int) {
        if start == end {
            res = min(cost, res)
        }

        if remaining < 0 || cost >= res {
            return
        }

        if let lowest = dp[start] {
            if lowest < cost {
                return
            }
        }
        dp[start] = cost

        var forwardCost = Int.max
        if let outgoing = graph[start] {
            for edge in outgoing {
                dfs(graph, &dp, cost + edge.1, &visited, edge.0, end, remaining - 1)
            }
        }
    }
}

---

288ms

class Solution {
    var dp = [[Int]]()
    var graph = [[Int]]()
    
    func find(_ flights: [[Int]], _ src: Int, _ dst: Int, _ k: Int, _ n: Int) -> Int {
        if src == dst {
            dp[src][k] = 0
            return dp[src][k]
        }
        if k == 0 {
            dp[dst][k] = graph[dst][src]
            return dp[dst][k]
        }
        if dp[dst][k] != Int.max {
            return dp[dst][k]
        }
        
        for i in 0..<n {
            if graph[dst][i] != Int.max && find(flights, src, i, k-1, n) != Int.max {
                dp[dst][k] = min(dp[dst][k], graph[dst][i] + find(flights, src, i, k-1, n))
            }
        }
        return dp[dst][k]
    }
    
    func findCheapestPrice(_ n: Int, _ flights: [[Int]], _ src: Int, _ dst: Int, _ K: Int) -> Int {
        dp = [[Int]](repeating: [Int](repeating: Int.max, count: K+1), count: n)
        graph = [[Int]](repeating: [Int](repeating: Int.max, count: n), count: n)
        for f in flights {
            graph[f[1]][f[0]] = f[2]
        }
        return find(flights, src, dst, K, n) == Int.max ? -1 : dp[dst][K]
    }
}