Cheapest Flights Within K Stops - Practice Coding Problems

Cheapest Flights Within K Stops - Problem

Dynamic Programming Depth-First Search Breadth-First Search Graph Heap (Priority Queue) Shortest Path Medium

Imagine you're a travel agent trying to find the most budget-friendly flight route for your client. You have access to a network of n cities connected by various flights, where each flight has a specific cost.

You're given an array flights where flights[i] = [from_i, to_i, price_i] represents a direct flight from city from_i to city to_i costing price_i dollars. Your client wants to travel from a source city src to a destination city dst, but here's the catch: they can make at most k stops along the way.

Your mission: Find the cheapest possible price for this journey. If no valid route exists within the stop limit, return -1.

Example: If there are flights [0,1,100], [1,2,100], [0,2,500] and you want to go from city 0 to city 2 with at most 1 stop, you should choose the route 0→1→2 (cost: 200) instead of the direct flight 0→2 (cost: 500).

Input & Output

example_1.py — Basic Flight Network

$ 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

💡 Note: With at most 1 stop, the optimal path is 0→1→3 with cost 100+600=700. The path 0→2→3 costs 100+200=300 but requires going through city 2, which would need the expensive flight from 0→2.

example_2.py — Multiple Path Options

$ Input: n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 1

› Output: 200

💡 Note: We can go directly 0→2 for $500, or via 1 stop: 0→1→2 for $100+$100=$200. Since k=1 allows 1 stop, we choose the cheaper route with cost 200.

example_3.py — No Valid Route

$ Input: n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 0

› Output: 500

💡 Note: With k=0 (no stops allowed), we can only take direct flights. The only direct flight from 0→2 costs $500, so that's our answer.

Time & Space Complexity

Time Complexity

⏱️

O(k * E)

We iterate k+1 times, and for each iteration process all E flights

✓ Linear Growth

Space Complexity

O(k * n)

DP table stores costs for each (stops, city) combination

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 100
0 ≤ flights.length ≤ n * (n - 1) / 2
flights[i].length == 3
0 ≤ from_i, to_i < n
from_i ≠ to_i
1 ≤ price_i ≤ 10⁴
There will not be any multiple flights between two cities
0 ≤ src, dst, k < n
src ≠ dst

Asked in

The optimal approach uses Dijkstra's algorithm with modified state tracking. Instead of just tracking (cost, city), we track (cost, stops, city) as our state. This ensures we explore the cheapest paths first while respecting the stop constraint. The key insight is treating this as a shortest path problem in a graph with an additional dimension for the number of edges traversed.

Common Approaches

Approach	Time	Space	Notes
✓ Bellman-Ford Algorithm (Dynamic Programming)	O(k * E)	O(k * n)	Use dynamic programming to find shortest path with at most k+1 edges
Dijkstra's Algorithm with Priority Queue (Optimal)	O((V + E) * k * log(V * k))	O(V * k)	Use modified Dijkstra's algorithm with (cost, stops, city) state tracking
Brute Force (DFS with Backtracking)	O(k^n)	O(k)	Explore all possible paths using depth-first search with pruning

Bellman-Ford Algorithm (Dynamic Programming) — Algorithm Steps

Initialize DP table: dp[stops][city] = minimum cost with 'stops' flights
Set dp[0][src] = 0 (no cost to start at source)
For each number of stops from 1 to k+1:
For each flight, update destination city cost
dp[stops][to] = min(dp[stops][to], dp[stops-1][from] + price)
Return minimum cost among all dp[i][dst] where i ≤ k+1

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[0][src] = 0, all others to infinity

1 Stop

Fill costs reachable with exactly 1 flight

2 Stops

Fill costs reachable with exactly 2 flights

Continue

Repeat until k+1 stops

Result

Take minimum cost to destination across all stops

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int findCheapestPrice(int n, int** flights, int flightsSize, int* flightsColSize, int src, int dst, int k) {
    // Allocate DP table
    int** dp = (int**)malloc((k + 2) * sizeof(int*));
    for (int i = 0; i <= k + 1; i++) {
        dp[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            dp[i][j] = INT_MAX;
        }
    }
    
    dp[0][src] = 0;
    
    for (int stops = 1; stops <= k + 1; stops++) {
        dp[stops][src] = 0;
        
        for (int i = 0; i < flightsSize; i++) {
            int from = flights[i][0];
            int to = flights[i][1];
            int price = flights[i][2];
            
            if (dp[stops - 1][from] != INT_MAX) {
                int newCost = dp[stops - 1][from] + price;
                if (newCost < dp[stops][to]) {
                    dp[stops][to] = newCost;
                }
            }
        }
    }
    
    int result = INT_MAX;
    for (int i = 0; i <= k + 1; i++) {
        if (dp[i][dst] < result) {
            result = dp[i][dst];
        }
    }
    
    // Free memory
    for (int i = 0; i <= k + 1; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result == INT_MAX ? -1 : result;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k * E)

We iterate k+1 times, and for each iteration process all E flights

✓ Linear Growth

Space Complexity

O(k * n)

DP table stores costs for each (stops, city) combination

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 100
0 ≤ flights.length ≤ n * (n - 1) / 2
flights[i].length == 3
0 ≤ from_i, to_i < n
from_i ≠ to_i
1 ≤ price_i ≤ 10⁴
There will not be any multiple flights between two cities
0 ≤ src, dst, k < n
src ≠ dst

25.0K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Bellman-Ford Algorithm (Dynamic Programming) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler