Shortest Path (Dijkstra) - Problem

Given a weighted graph represented as an adjacency list and a source vertex, implement Dijkstra's algorithm to find the shortest path from the source to all other vertices.

The graph is represented as a list of edges where each edge is [from, to, weight]. Return an array where result[i] is the shortest distance from the source to vertex i. If a vertex is unreachable, use -1.

Note: All edge weights are non-negative integers. Vertices are numbered from 0 to n-1.

Input & Output

Example 1 — Basic Graph

$ Input: n = 4, edges = [[0,1,4],[0,2,2],[1,3,3],[2,3,1]], source = 0

› Output: [0,4,2,3]

💡 Note: From vertex 0: distance to 0 is 0, to 1 is 4 (direct), to 2 is 2 (direct), to 3 is 3 (via 2→3 path costs 2+1=3, better than 1→3 path costs 4+3=7)

Example 2 — Disconnected Vertex

$ Input: n = 3, edges = [[0,1,5]], source = 0

› Output: [0,5,-1]

💡 Note: From vertex 0: distance to 0 is 0, to 1 is 5 (direct edge), to 2 is -1 (unreachable since no path exists)

Example 3 — Single Vertex

$ Input: n = 1, edges = [], source = 0

› Output: [0]

💡 Note: Only one vertex exists, distance from vertex 0 to itself is 0

Constraints

1 ≤ n ≤ 100
0 ≤ edges.length ≤ n × (n-1)
0 ≤ source < n
0 ≤ weight ≤ 100

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Meta 32 M Microsoft 28

The key insight is using a priority queue to always process the vertex with minimum distance first, guaranteeing optimal subpaths. Best approach is Dijkstra's algorithm with priority queue. Time: O((V + E) log V), Space: O(V).

Common Approaches

✓ Brute Force with All Paths

⏱️ Time: O(V! × E) Space: O(V)

Generate all possible paths from source to each vertex and compare their total weights to find the minimum distance.

Classic Dijkstra with Priority Queue

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

Maintain a priority queue of vertices ordered by distance. Always process the vertex with minimum distance first, guaranteeing optimal substructure.

Brute Force with All Paths — Algorithm Steps

Generate all possible paths from source to each vertex using DFS
Calculate total weight for each path
Select minimum weight path for each destination

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin path exploration from source vertex

Try All Paths

Recursively explore every possible route to target

Compare Costs

Track minimum cost among all valid paths

Code -

solution.c — C

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

#define MAX_VERTICES 100
#define MAX_EDGES 1000

int graph[MAX_VERTICES][MAX_VERTICES];
int n_global;

int dfs(int node, int target, int currentDist, int* visited) {
    if (node == target) {
        return currentDist;
    }
    
    int minDist = INT_MAX;
    for (int i = 0; i < n_global; i++) {
        if (graph[node][i] != -1 && !visited[i]) {
            visited[i] = 1;
            int dist = dfs(i, target, currentDist + graph[node][i], visited);
            if (dist < minDist) {
                minDist = dist;
            }
            visited[i] = 0;
        }
    }
    
    return minDist;
}

int* solution(int n, int edges[][3], int edgeCount, int source) {
    n_global = n;
    
    // Initialize adjacency matrix
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            graph[i][j] = -1;
        }
    }
    
    // Build graph
    for (int i = 0; i < edgeCount; i++) {
        graph[edges[i][0]][edges[i][1]] = edges[i][2];
    }
    
    int* result = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        result[i] = -1;
    }
    result[source] = 0;
    
    // Find shortest path to each vertex
    for (int target = 0; target < n; target++) {
        if (target != source) {
            int visited[MAX_VERTICES] = {0};
            visited[source] = 1;
            int dist = dfs(source, target, 0, visited);
            result[target] = (dist == INT_MAX) ? -1 : dist;
        }
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    // Simple parsing - read edges
    int edges[MAX_EDGES][3];
    int edgeCount = 0;
    
    char line[1000];
    fgets(line, sizeof(line), stdin); // consume newline
    fgets(line, sizeof(line), stdin);
    
    // Parse edges (simplified)
    char* token = strtok(line, "[],");
    while (token != NULL && edgeCount < MAX_EDGES) {
        if (strlen(token) > 0 && token[0] >= '0' && token[0] <= '9') {
            edges[edgeCount / 3][edgeCount % 3] = atoi(token);
            if (edgeCount % 3 == 2) edgeCount = (edgeCount / 3) + 1;
            else edgeCount++;
        }
        token = strtok(NULL, "[],");
    }
    edgeCount = edgeCount / 3 + (edgeCount % 3 > 0 ? 1 : 0);
    
    int source;
    scanf("%d", &source);
    
    int* result = solution(n, edges, edgeCount, source);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("%d", result[i]);
        if (i < n - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V! × E)

In worst case, we explore V! possible paths, checking E edges for each path

⚡ Linearithmic

Space Complexity

O(V)

Recursion stack depth up to V vertices for path exploration

✓ Linear Space

34.5K Views

High Frequency

~25 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

Shortest Path (Dijkstra) - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with All Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler