Introduction

In this blog post, we will explore how to solve the LeetCode problem "787" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

There are n cities connected by some number of flights. You are given an array flights where flights[i] = [fromi, toi, pricei] indicates that there is a flight from city fromi to city toi with cost pricei. You are also given three integers src, dst, and k, return the cheapest price from src to dst with at most k stops. If there is no such route, return -1. Example 1: Input: n = 4, flights = [[0,1,100],[1,2,100],[2,0,100],[1,3,600],[2,3,200]], src = 0, dst = 3, k = 1 Output: 700 Explanation: The graph is shown above. The optimal path with at most 1 stop from city 0 to 3 is marked in red and has cost 100 + 600 = 700. Note that the path through cities [0,1,2,3] is cheaper but is invalid because it uses 2 stops. Example 2: Input: n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 1 Output: 200 Explanation: The graph is shown above. The optimal path with at most 1 stop from city 0 to 2 is marked in red and has cost 100 + 100 = 200. Example 3: Input: n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 0 Output: 500 Explanation: The graph is shown above. The optimal path with no stops from city 0 to 2 is marked in red and has cost 500. Constraints: 1 <= n <= 100 0 <= flights.length <= (n * (n - 1) / 2) flights[i].length == 3 0 <= fromi, toi < n fromi != toi 1 <= pricei <= 104 There will not be any multiple flights between two cities. 0 <= src, dst, k < n src != dst

Explanation

• Bellman-Ford Adaptation: Adapt the Bellman-Ford algorithm to find the shortest path with a limited number of stops. Iterate up to k+1 times, relaxing edges in each iteration to find the minimum cost to reach each city with at most i stops.

• Dynamic Programming: Use dynamic programming to store the minimum cost to reach each city with a certain number of stops. Update the costs iteratively, considering all possible flights.

• Optimization: Instead of updating the distances in place, maintain a temporary array to store the updated distances in each iteration. This prevents incorrect updates based on already updated values within the same iteration.

• Runtime Complexity: O(k*|E|), where k is the maximum number of stops and |E| is the number of flights (edges). Storage Complexity: O(n), where n is the number of cities.

Code

    def findCheapestPrice(n: int, flights: list[list[int]], src: int, dst: int, k: int) -> int:
    """
    Finds the cheapest price from src to dst with at most k stops.

    Args:
        n: The number of cities.
        flights: A list of flights, where flights[i] = [fromi, toi, pricei].
        src: The source city.
        dst: The destination city.
        k: The maximum number of stops.

    Returns:
        The cheapest price from src to dst with at most k stops. If there is no such route, return -1.
    """

    distances = [float('inf')] * n
    distances[src] = 0

    for _ in range(k + 1):
        temp_distances = distances[:]  # Create a copy to avoid incorrect updates
        for u, v, price in flights:
            if distances[u] != float('inf'):
                temp_distances[v] = min(temp_distances[v], distances[u] + price)
        distances = temp_distances

    if distances[dst] == float('inf'):
        return -1
    else:
        return distances[dst]