Cheapest Flights Within K Stops

Cheapest Flights Within K Stops - Problem

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

There are n cities connected by some number of flights. You are given an array flights where flights[i] = [from_i, to_i, price_i] indicates that there is a flight from city from_i to city to_i with cost price_i.

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.

Input & Output

Example 1 — Basic Case

$ 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: The optimal path is 0→1→3 with cost 100+600=700. We can't use 0→2→3 (cost 300) because it requires 2 stops but k=1.

Example 2 — No Valid Path

$ 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 (direct flight only), we must take the direct route 0→2 with cost 500. Path 0→1→2 requires 1 stop which exceeds k=0.

Example 3 — Multiple Options

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

› Output: 6

💡 Note: Best path with at most 1 stop is 0→2→3 with cost 5+1=6. Path 0→1→2→3 would cost only 3 but requires 2 stops.

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 F Facebook 8 M Microsoft 6

The key insight is to model this as a shortest path problem with an additional constraint on the number of stops. The Dynamic Programming approach works best by tracking minimum cost to reach each city with exactly i stops. Time: O(k × E), Space: O(k × n).

Common Approaches

✓ BFS with Priority Queue

⏱️ Time: O(E × k × log(E × k)) Space: O(E × k)

Use a priority queue (min-heap) to always process the cheapest path first. Each state contains current city, cost, and number of stops used. This guarantees we find the optimal solution early.

DFS with All Paths

⏱️ Time: O(k^n) Space: O(k)

Use depth-first search to explore every possible path from source to destination. Keep track of the current cost and number of stops, pruning paths that exceed k stops or current minimum cost.

Dynamic Programming (Bellman-Ford)

⏱️ Time: O(k × E) Space: O(k × n)

Create a 2D DP table where dp[stops][city] represents the minimum cost to reach city with exactly 'stops' number of stops. Iterate through stops and update costs using relaxation.

BFS with Priority Queue — Algorithm Steps

Step 1: Initialize priority queue with (cost=0, src, stops=0)
Step 2: While queue not empty, pop cheapest state
Step 3: If reached destination, return cost
Step 4: If stops < k, add all neighbors to queue

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Add (cost=0, src, stops=0) to queue

Process

Pop cheapest state, add neighbors

Continue

Repeat until destination found

Code -

solution.c — C

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

#define MAX_FLIGHTS 1000
#define MAX_CITIES 100
#define MAX_QUEUE 10000

typedef struct {
    int cost;
    int city;
    int stops;
} State;

typedef struct {
    State data[MAX_QUEUE];
    int size;
} PriorityQueue;

void swap(State* a, State* b) {
    State temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(PriorityQueue* pq, int idx) {
    if (idx == 0) return;
    int parent = (idx - 1) / 2;
    if (pq->data[parent].cost > pq->data[idx].cost) {
        swap(&pq->data[parent], &pq->data[idx]);
        heapifyUp(pq, parent);
    }
}

void heapifyDown(PriorityQueue* pq, int idx) {
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;
    int smallest = idx;
    
    if (left < pq->size && pq->data[left].cost < pq->data[smallest].cost) {
        smallest = left;
    }
    if (right < pq->size && pq->data[right].cost < pq->data[smallest].cost) {
        smallest = right;
    }
    if (smallest != idx) {
        swap(&pq->data[idx], &pq->data[smallest]);
        heapifyDown(pq, smallest);
    }
}

void push(PriorityQueue* pq, State state) {
    if (pq->size >= MAX_QUEUE) return;
    pq->data[pq->size] = state;
    heapifyUp(pq, pq->size);
    pq->size++;
}

State pop(PriorityQueue* pq) {
    State top = pq->data[0];
    pq->data[0] = pq->data[pq->size - 1];
    pq->size--;
    heapifyDown(pq, 0);
    return top;
}

int isEmpty(PriorityQueue* pq) {
    return pq->size == 0;
}

typedef struct {
    int to;
    int price;
} Edge;

typedef struct {
    Edge edges[MAX_CITIES];
    int count;
} AdjList;

int parseFlights(char* flightsStr, int flights[][3]) {
    int count = 0;
    char* ptr = flightsStr + 1; // Skip first '['
    
    while (*ptr && count < MAX_FLIGHTS) {
        if (*ptr == '[') {
            ptr++;
            int from = strtol(ptr, &ptr, 10);
            ptr++; // Skip ','
            int to = strtol(ptr, &ptr, 10);
            ptr++; // Skip ','
            int price = strtol(ptr, &ptr, 10);
            
            flights[count][0] = from;
            flights[count][1] = to;
            flights[count][2] = price;
            count++;
            
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
        } else {
            ptr++;
        }
    }
    
    return count;
}

int solution(int n, int flights[][3], int flightCount, int src, int dst, int k) {
    AdjList graph[MAX_CITIES];
    for (int i = 0; i < MAX_CITIES; i++) {
        graph[i].count = 0;
    }
    
    for (int i = 0; i < flightCount; i++) {
        int from = flights[i][0];
        int to = flights[i][1];
        int price = flights[i][2];
        graph[from].edges[graph[from].count].to = to;
        graph[from].edges[graph[from].count].price = price;
        graph[from].count++;
    }
    
    PriorityQueue pq = {.size = 0};
    State start = {0, src, 0};
    push(&pq, start);
    
    int visited[MAX_CITIES][102]; // cities x (k+1) stops
    for (int i = 0; i < MAX_CITIES; i++) {
        for (int j = 0; j < 102; j++) {
            visited[i][j] = 0;
        }
    }
    
    while (!isEmpty(&pq)) {
        State current = pop(&pq);
        int cost = current.cost;
        int city = current.city;
        int stops = current.stops;
        
        if (city == dst) {
            return cost;
        }
        
        if (visited[city][stops]) continue;
        visited[city][stops] = 1;
        
        if (stops < k + 1) {
            for (int i = 0; i < graph[city].count; i++) {
                int nextCity = graph[city].edges[i].to;
                int price = graph[city].edges[i].price;
                if (!visited[nextCity][stops + 1]) {
                    State next = {cost + price, nextCity, stops + 1};
                    push(&pq, next);
                }
            }
        }
    }
    
    return -1;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char flightsStr[10000];
    scanf("%s", flightsStr);
    
    int src, dst, k;
    scanf("%d %d %d", &src, &dst, &k);
    
    int flights[MAX_FLIGHTS][3];
    int flightCount = parseFlights(flightsStr, flights);
    
    int result = solution(n, flights, flightCount, src, dst, k);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(E × k × log(E × k))

Each edge can be relaxed up to k times, priority queue operations are log(size)

✓ Linear Growth

Space Complexity

O(E × k)

Priority queue can store up to E×k states in worst case

✓ Linear Space

89.0K Views

Medium Frequency

~35 min Avg. Time

3.5K 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

Constraints

Visualization

Related Problems

Common Approaches

BFS with Priority Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler