Last Updated : 23 Jul, 2025
Try it on GfG Practice
Given a matrix dist[][] of size n x n, where dist[i][j] represents the weight of the edge from node i to node j. If there is no direct edge, dist[i][j] is set to a large value (e.g., 10⁸) to represent infinity. The diagonal entries dist[i][i] are 0, since the distance from a node to itself is zero. The graph may contain negative edge weights, but it does not contain any negative weight cycles.
Your task is to determine the shortest path distance between all pair of nodes i and j in the graph.
Example:
Floyd Warshall Algorithm:Input: dist[][] = [[0, 4, 10⁸, 5, 10⁸],
[10⁸, 0, 1, 10⁸, 6],
[2, 10⁸, 0, 3, 10⁸],
[10⁸, 10⁸, 1, 0, 2],
[1, 10⁸, 10⁸, 4, 0]]Output:[[0, 4, 5, 5, 7],
[3, 0, 1, 4, 6],
[2, 6, 0, 3, 5],
[3, 7, 1, 0, 2],
[1, 5, 5, 4, 0]]
Explanation:Each cell
dist[i][j]in the output shows the shortest distance from nodeito nodej, computed by considering all possible intermediate nodes using the Floyd-Warshall algorithm.
The Floyd–Warshall algorithm works by maintaining a two-dimensional array that represents the distances between nodes. Initially, this array is filled using only the direct edges between nodes. Then, the algorithm gradually updates these distances by checking if shorter paths exist through intermediate nodes.
This algorithm works for both the directed and undirected weighted graphs and can handle graphs with both positive and negative weight edges.
Note: It does not work for the graphs with negative cycles (where the sum of the edges in a cycle is negative).
Idea Behind Floyd Warshall Algorithm:Why Floyd Warshall Works (Correctness Proof)?Suppose we have a graph dist[][] with V vertices from 0 to V-1. Now we have to evaluate a dist[][] where dist[i][j] represents the shortest path between vertex i to j.
Let us assume that vertices i to j have intermediate nodes. The idea behind Floyd Warshall algorithm is to treat each and every vertex k from 0 to V-1 as an intermediate node one by one. When we consider the vertex k, we must have considered vertices from 0 to k-1 already. So we use the shortest paths built by previous vertices to build shorter paths with vertex k included.
The following figure shows the above optimal substructure property in Floyd Warshall algorithm:
The algorithm relies on the principle of optimal substructure, meaning:
By the end of the algorithm, all shortest paths are computed optimally because each possible intermediate vertex has been considered.
Why Floyd-Warshall Algorithm better for Dense Graphs and not for Sparse Graphs?Dense Graph: A graph in which the number of edges are significantly much higher than the number of vertices.
Sparse Graph: A graph in which the number of edges are very much low.No matter how many edges are there in the graph the Floyd Warshall Algorithm runs for O(V3) times therefore it is best suited for Dense graphs. In the case of sparse graphs, Johnson's Algorithm is more suitable.
Step-by-step implementation
k, attempt to improve the shortest paths that pass through it.k until all intermediate possibilities have been considered.Illustration:
C++
#include <iostream>
#include <vector>
#include <climits>
using namespace std;
// Solves the all-pairs shortest path
// problem using Floyd Warshall algorithm
void floydWarshall(vector<vector<int>> &dist) {
int V = dist.size();
// Add all vertices one by one to
// the set of intermediate vertices.
for (int k = 0; k < V; k++) {
// Pick all vertices as source one by one
for (int i = 0; i < V; i++) {
// Pick all vertices as destination
// for the above picked source
for (int j = 0; j < V; j++) {
// shortest path from
// i to j
if(dist[i][k] != 1e8 && dist[k][j]!= 1e8)
dist[i][j] = min(dist[i][j],dist[i][k] + dist[k][j]);
}
}
}
}
int main() {
int INF = 100000000;
vector<vector<int>> dist = {
{0, 4, INF, 5, INF},
{INF, 0, 1, INF, 6},
{2, INF, 0, 3, INF},
{INF, INF, 1, 0, 2},
{1, INF, INF, 4, 0}
};
floydWarshall(dist);
for(int i = 0; i<dist.size(); i++) {
for(int j = 0; j<dist.size(); j++) {
cout<<dist[i][j]<<" ";
}
cout<<endl;
}
return 0;
}
Java
import java.util.*;
class GfG {
// Solves the all-pairs shortest path
// problem using Floyd Warshall algorithm
static void floydWarshall(int[][] dist){
int V = dist.length;
// Add all vertices one by one to
// the set of intermediate vertices.
for (int k = 0; k < V; k++) {
// Pick all vertices as source one by one
for (int i = 0; i < V; i++) {
// Pick all vertices as destination
// for the above picked source
for (int j = 0; j < V; j++) {
// shortest path from
// i to j
if(dist[i][k] != 1e8 && dist[k][j]!= 1e8)
dist[i][j] = Math.min(dist[i][j],dist[i][k] + dist[k][j]);
}
}
}
}
public static void main(String[] args)
{
int INF = 100000000;
int[][] dist = { { 0, 4, INF, 5, INF },
{ INF, 0, 1, INF, 6 },
{ 2, INF, 0, 3, INF },
{ INF, INF, 1, 0, 2 },
{ 1, INF, INF, 4, 0 } };
floydWarshall(dist);
for (int i = 0; i < dist.length; i++) {
for (int j = 0; j < dist.length; j++) {
System.out.print(dist[i][j] + " ");
}
System.out.println();
}
}
}
Python
# Solves the all-pairs shortest path
# problem using Floyd Warshall algorithm
def floydWarshall(dist):
V = len(dist)
# Add all vertices one by one to
# the set of intermediate vertices.
for k in range(V):
# Pick all vertices as source one by one
for i in range(V):
# Pick all vertices as destination
# for the above picked source
for j in range(V):
#shortest path from
#i to j
if(dist[i][k] != 100000000 and dist[k][j]!= 100000000):
dist[i][j] = min(dist[i][j],dist[i][k] + dist[k][j]);
if __name__ == "__main__":
INF = 100000000;
dist = [
[0, 4, INF, 5, INF],
[INF, 0, 1, INF, 6],
[2, INF, 0, 3, INF],
[INF, INF, 1, 0, 2],
[1, INF, INF, 4, 0]
]
floydWarshall(dist)
for i in range(len(dist)):
for j in range(len(dist)):
print(dist[i][j], end=" ")
print()
C#
using System;
class GfG
{
static void floydWarshall(int[,] dist)
{
int V = dist.GetLength(0);
for (int k = 0; k < V; k++)
{
for (int i = 0; i < V; i++)
{
for (int j = 0; j < V; j++)
{
// shortest path from
// i to j
if(dist[i,k] != 1e8 && dist[k, j]!= 1e8)
dist[i,j] = Math.Min(dist[i, j], dist[i, k] + dist[k, j]);
}
}
}
}
// large number as "infinity"
const int INF = 100000000;
static void Main()
{
int[,] dist = {
{0, 4, INF, 5, INF},
{INF, 0, 1, INF, 6},
{2, INF, 0, 3, INF},
{INF, INF, 1, 0, 2},
{1, INF, INF, 4, 0}
};
floydWarshall(dist);
for (int i = 0; i < dist.GetLength(0); i++)
{
for (int j = 0; j < dist.GetLength(1); j++)
{
Console.Write(dist[i, j] + " ");
}
Console.WriteLine();
}
}
}
JavaScript
// Solves the all-pairs shortest path
// problem using Floyd Warshall algorithm
function floydWarshall(dist)
{
let V = dist.length;
// Add all vertices one by one to
// the set of intermediate vertices.
for (let k = 0; k < V; k++) {
// Pick all vertices as source one by one
for (let i = 0; i < V; i++) {
// Pick all vertices as destination
// for the above picked source
for (let j = 0; j < V; j++) {
// shortest path from
// i to j
if (dist[i][k] != INF && dist[k][j] != INF) {
dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
}
}
let INF = 100000000;
// Driver Code
let dist = [
[0, 4, INF, 5, INF],
[INF, 0, 1, INF, 6],
[2, INF, 0, 3, INF],
[INF, INF, 1, 0, 2],
[1, INF, INF, 4, 0]
];
floydWarshall(dist);
for (let i = 0; i < dist.length; i++) {
console.log(dist[i].join(" "));
}
0 4 5 5 7 3 0 1 4 6 2 6 0 3 5 3 7 1 0 2 1 5 5 4 0
Time Complexity: O(V3), where V is the number of vertices in the graph and we run three nested loops each of size V.
Auxiliary Space: O(1).
Read here for detailed analysis: complexity analysis of the Floyd Warshall algorithm
Note: The above program only prints the shortest distances. We can modify the solution to print the shortest paths also by storing the predecessor information in a separate 2D matrix.
Real World Applications of Floyd-Warshall AlgorithmSDE Sheet - Floyd Warshall
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4