Find Shortest Path with K Hops

Find Shortest Path with K Hops - Problem

You are given a positive integer n which is the number of nodes of a 0-indexed undirected weighted connected graph and a 0-indexed 2D array edges where edges[i] = [ui, vi, wi] indicates that there is an edge between nodes ui and vi with weight wi.

You are also given two nodes s and d, and a positive integer k. Your task is to find the shortest path from s to d, but you can hop over at most k edges. In other words, make the weight of at most k edges 0 and then find the shortest path from s to d.

Return the length of the shortest path from s to d with the given condition.

Input & Output

Example 1 — Basic Graph with 2 Free Hops

$ Input: n = 4, edges = [[0,1,10],[0,2,1],[1,2,5],[2,3,1]], s = 0, d = 3, k = 2

› Output: 1

💡 Note: Skip edges (0,1) and (1,2), then path 0→2→3 costs 1+1=2, but we can also skip (2,3) and take path 0→2→3 with cost 1+0=1

Example 2 — Linear Chain

$ Input: n = 3, edges = [[0,1,5],[1,2,5]], s = 0, d = 2, k = 1

› Output: 5

💡 Note: Skip one edge: either 0→1 (skip) + 1→2 (cost 5) = 5, or 0→1 (cost 5) + 1→2 (skip) = 5

Example 3 — No Hops Available

$ Input: n = 3, edges = [[0,1,2],[1,2,3],[0,2,10]], s = 0, d = 2, k = 0

› Output: 5

💡 Note: Cannot skip any edges, shortest path is 0→1→2 with cost 2+3=5

Constraints

2 ≤ n ≤ 1000
1 ≤ edges.length ≤ min(n×(n-1)/2, 2000)
edges[i].length == 3
0 ≤ ui, vi ≤ n-1
1 ≤ wi ≤ 10⁶
0 ≤ s, d ≤ n-1
s ≠ d
1 ≤ k ≤ n
Graph is connected

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 f Meta 29 M Microsoft 25

The key insight is to use modified Dijkstra's algorithm with 3D state tracking: (node, hops_remaining). For each edge, we can either use it normally or skip it if we have remaining hops. Best approach is modified Dijkstra with Time: O((V+E)×K×log(V×K)), Space: O(V×K).

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O(2^E × E log V) Space: O(V + E)

For each subset of edges (up to k edges), set their weights to 0 and run Dijkstra's algorithm. This explores all possible ways to use the k free hops.

Modified Dijkstra with State Tracking

⏱️ Time: O((V + E) × K × log(V × K)) Space: O(V × K)

Instead of trying all combinations, we use a modified Dijkstra where each state tracks both the current node and remaining free hops. For each edge, we can either use it normally or skip it (if hops remain).

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char solution(int* operations, int operationsSize, int k) {
    int pos = k;
    int shift = 0;
    
    for (int i = operationsSize - 1; i >= 0; i--) {
        int length = 1 << i;
        if (pos > length) {
            pos -= length;
            if (operations[i] == 1) {
                shift++;
            }
        }
    }
    
    return (char)((shift % 26) + 'a');
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    int operations[100];
    int count = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        operations[count++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    int k;
    scanf("%d", &k);
    printf("%c\n", solution(operations, count, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

~35 min Avg. Time

892 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