Floyd-Warshall All Pairs - Problem

The Floyd-Warshall algorithm is a fundamental dynamic programming approach for finding shortest paths between all pairs of vertices in a weighted graph. Unlike Dijkstra's algorithm which finds shortest paths from a single source, Floyd-Warshall computes the shortest distance between every pair of vertices in one execution.

Given a weighted directed graph represented as an adjacency matrix, implement the Floyd-Warshall algorithm to:

Find shortest distances between all pairs of vertices
Reconstruct the actual path between any two specified nodes

The graph may contain negative edge weights, but no negative cycles. Use infinity to represent no direct edge between vertices.

Input & Output

Example 1 — Basic 4-Node Graph

$ Input: graph = [[0,4,2,1000000],[1000000,0,1000000,3],[1000000,1000000,0,1],[1000000,1000000,1000000,0]], start = 0, end = 3

› Output: [0,2,3]

💡 Note: Direct path 0→3 doesn't exist (cost 1000000). Path 0→2→3 has cost 2+1=3, which is shorter than 0→1→3 (cost 4+3=7). Floyd-Warshall finds this optimal route.

Example 2 — Direct Path Available

$ Input: graph = [[0,5,1000000,10],[1000000,0,3,1000000],[1000000,1000000,0,1],[1000000,1000000,1000000,0]], start = 0, end = 1

› Output: [0,1]

💡 Note: Direct path 0→1 with cost 5 exists and is optimal. No intermediate path through other vertices provides improvement.

Example 3 — No Path Exists

$ Input: graph = [[0,1000000,1000000,1000000],[1000000,0,2,1000000],[1000000,1000000,0,1000000],[1000000,1000000,1000000,0]], start = 0, end = 3

› Output: []

💡 Note: Node 0 is disconnected from node 3. No path exists between them, so return empty array.

Constraints

1 ≤ n ≤ 100 (where n is number of vertices)
-1000 ≤ graph[i][j] ≤ 1000 for valid edges
graph[i][j] = 1000000 represents no edge (infinity)
0 ≤ start, end < n
No negative cycles in the graph

Visualization

Tap to expand

Asked in

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

The Floyd-Warshall algorithm systematically considers each vertex as a potential intermediate point to find shortest paths between all pairs. The key insight is using dynamic programming with the recurrence: dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]). Best approach: Floyd-Warshall with path reconstruction. Time: O(n³), Space: O(n²).

Common Approaches

✓ All-Paths Enumeration

⏱️ Time: O(n! × n) Space: O(n³)

Generate all possible paths between every pair of vertices using DFS/backtracking, calculate the total distance for each path, and select the minimum. This approach explores the entire solution space exhaustively.

Floyd-Warshall Algorithm

⏱️ Time: O(n³) Space: O(n²)

Build a distance matrix using dynamic programming. For each possible intermediate vertex k, check if going through k provides a shorter path between any pair of vertices i and j. Maintain a next matrix for path reconstruction.

All-Paths Enumeration — Algorithm Steps

For each vertex pair (i,j), use DFS to find all paths
Calculate total distance for each path
Track the minimum distance path
Store path reconstruction information

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin at source node, explore all neighbors

Branch & Track

For each path, calculate distance and continue exploring

Find Minimum

Compare all complete paths and select shortest

Code -

solution.c — C

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

#define INF 999999
#define MAX_N 100

int graph[MAX_N][MAX_N];
int visited[MAX_N];
int path[MAX_N];
int bestPath[MAX_N];
int minDist = INF;
int bestPathLen = 0;
int n;

void dfs(int curr, int target, int pathLen, int dist) {
    if (curr == target) {
        if (dist < minDist) {
            minDist = dist;
            bestPathLen = pathLen;
            for (int i = 0; i < pathLen; i++) {
                bestPath[i] = path[i];
            }
        }
        return;
    }
    
    if (dist >= minDist) return;
    
    for (int nextNode = 0; nextNode < n; nextNode++) {
        if (!visited[nextNode] && graph[curr][nextNode] != INF) {
            visited[nextNode] = 1;
            path[pathLen] = nextNode;
            dfs(nextNode, target, pathLen + 1, dist + graph[curr][nextNode]);
            visited[nextNode] = 0;
        }
    }
}

int* solution(int start, int end, int* returnSize) {
    minDist = INF;
    bestPathLen = 0;
    
    // Convert infinity markers
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (graph[i][j] >= 999999) {
                graph[i][j] = INF;
            }
        }
    }
    
    memset(visited, 0, sizeof(visited));
    visited[start] = 1;
    path[0] = start;
    
    dfs(start, end, 1, 0);
    
    if (minDist == INF) {
        *returnSize = 0;
        return NULL;
    }
    
    int* result = (int*)malloc(bestPathLen * sizeof(int));
    for (int i = 0; i < bestPathLen; i++) {
        result[i] = bestPath[i];
    }
    *returnSize = bestPathLen;
    return result;
}

int main() {
    // Simple parsing for small test cases
    n = 4; // Assuming 4x4 graph for this implementation
    
    // Read graph (simplified parsing)
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &graph[i][j]);
        }
    }
    
    int start, end;
    scanf("%d %d", &start, &end);
    
    int returnSize;
    int* result = solution(start, end, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

For each of n² pairs, we potentially explore n! different paths through all vertices

⚠ Quadratic Growth

Space Complexity

O(n³)

Need to store all paths during DFS exploration plus distance matrix

⚠ Quadratic Space

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

Floyd-Warshall All Pairs - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

All-Paths Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler