GEEKSFORGEEKS

Floyd Warshall Algorithm

The Floyd-Warshall algorithm, named after its
creators Robert Floyd and Stephen Warshall, is
a fundamental algorithm in computer science and
graph theory. It is used to find the shortest paths
between all pairs of nodes in a weighted graph.
This algorithm is highly efficient and can handle
graphs with both positive and negative edge
weights, making it a versatile tool for solving a
wide range of network and connectivity problems.

Floyd Warshall Algorithm:

The Floyd Warshall Algorithm is an all pair

shortest path algorithm unlike Dijkstra and
Bellman Ford which are single source
shortest path algorithms. This algorithm
works for both the directed and undirected
weighted graphs. But, it does not work for
the graphs with negative cycles (where the
sum of the edges in a cycle is negative). It
follows Dynamic Programming approach to
check every possible path going via every
possible node in order to calculate shortest
distance between every pair of nodes.

Idea Behind Floyd Warshall Algortihm:

Suppose we have a graph G[][] with V

vertices from 1 to N. Now we have to
evaluate a shortestPathMatrix[][] where
shortestPathMatrix[i][j] represents the
shortest path between vertices i and j.

Obviously the shortest path between i to j will

have some k number of intermediate nodes.
The idea behind floyd warshall algorithm is to
treat each and every vertex from 1 to N as an
intermediate node one by one.

The following figure shows the above optimal

substructure property in floyd warshall
algorithm:

allintermediatevertices0,1,2.....k-1} allintermediatevertices(0,1,2....k-1}

X2

Floyd Warshall Algorithm Algorithm:

Initialize the solution matrix same as the input

graph matrix as a first step.
Then update the solution matrix by considering
all vertices as an intermediate vertex.
The idea is to pick all vertices one by one and
updates all shortest paths which include the
picked vertex as an intermediate vertex in the
shortest path.
When we pick vertex number k as an
intermediate vertex, we already have
considered vertices {0, 1, 2, .. k-1} as
intermediate vertices.
For every pair (i, j) of the source and destination
vertices respectively, there are two possible
cases.
k is not an intermediate vertex in shortest
path from i to j. We keep the value of dist[i][j]
as it is.
k is an intermediate vertex in shortest path
from i to j. We update the value of dist[i][j] as
dist[i][k] + dist[k][j], if dist[i][j] > dist[i][k] +
dist[k][j]

Pseudo-Code of Floyd Warshall

Algorithm :

For k = 0 to n – 1
For i = 0 to n – 1
For j = 0 to n – 1
Distance[i, j] = min(Distance[i, j], Distance[i,
k] + Distance[k, j])

where i = source Node, j = Destination Node,

k = Intermediate Node

Illustration of Floyd Warshall Algorithm

:

Suppose we have a graph as shown in the

image:

ExampleGraph

Step 1: Initialize the Distance[][] matrix using

the input graph such that Distance[i][j]=
weight of edge from i to j, also Distance[i][j] =
Infinity if there is no edge from i to j.

Step 2: Treat node A as an intermediate

node and calculate the Distance[][] for every
{i,j} node pair using the formula:

= Distance[i][j] = minimum (Distance[i][j],

(Distance from i to A) + (Distance from A to j
))
= Distance[i][j] = minimum (Distance[i][j],
Distance[i][A] + Distance[A][j])

Step 3: Treat node B as an intermediate

node and calculate the Distance[][] for every
{i,j} node pair using the formula:

= Distance[i][j] = minimum (Distance[i][j],

(Distance from i to B) + (Distance from B to j
))
= Distance[i][j] = minimum (Distance[i][j],
Distance[i][B] + Distance[B][j])

Step3:UsingNodeBastheIntermediatenode

Distance[i]U]=min(Distance[i]Dl,Distance[i][B]+Distance[B]ü])

ABCDE ABCDE

A ? 4?? A 5 510

00 010 6 B 010 6

C ? 6?? C 60312

? 10I2
mO

E ? ??? 1 5 640

Step 4: Treat node C as an intermediate

node and calculate the Distance[][] for every
{i,j} node pair using the formula:

= Distance[i][j] = minimum (Distance[i][j],

(Distance from i to C) + (Distance from C to j
))
= Distance[i][j] = minimum (Distance[i][j],
Distance[i][C] + Distance[C][j])

Step 5: Treat node D as an intermediate

node and calculate the Distance[][] for every
{i,j} node pair using the formula:

= Distance[i][j] = minimum (Distance[i][j],

(Distance from i to D) + (Distance from D to j
))
= Distance[i][j] = minimum (Distance[i][j],
Distance[i][D] + Distance[D][j])

Step 6: Treat node E as an intermediate

node and calculate the Distance[][] for every
{i,j} node pair using the formula:

= Distance[i][j] = minimum (Distance[i][j],

(Distance from i to E) + (Distance from E to j
))
= Distance[i][j] = minimum (Distance[i][j],
Distance[i][E] + Distance[E][j])

Step 7: Since all the nodes have been

treated as an intermediate node, we can now
return the updated Distance[][] matrix as our
answer matrix.

Recommended Practice
Floyd Warshall
Try It!
Below is the implementation of the above
approach:

C++ C Java Python3 C# Javascript PHP

// C++ Program for Floyd Warshall Alg

#include <bits/stdc++.h>
using namespace std;
// Number of vertices in the graph
#define V 4
/* Define Infinite as a large enough
value.This value will be used for
vertices not connected to each other
#define INF 99999
// A function to print the solution m
void printSolution(int dist[][V]);
// Solves the all-pairs shortest path
// problem using Floyd Warshall algor
void floydWarshall(int dist[][V])
{

int i, j, k;

/* Add all vertices one by one to

the set of intermediate vertices.
---> Before start of an iteration
we have shortest distances betwee
pairs of vertices such that the
shortest distances consider only
vertices in set {0, 1, 2, .. k-1}
intermediate vertices.
----> After the end of an iterati
vertex no. k is added to the set
intermediate vertices and the set
k} */
for (k = 0; k < V; k++) {
// Pick all vertices as sourc
for (i = 0; i < V; i++) {
// Pick all vertices as d
// above picked source
for (j = 0; j < V; j++) {
// If vertex k is on
// i to j, then updat
// dist[i][j]
if (dist[i][j] > (dis
&& (dist[k][j] !=
&& dist[i][k]
dist[i][j] = dist
}
}
}

// Print the shortest distance ma

printSolution(dist);
}
/* A utility function to print soluti
void printSolution(int dist[][V])
{
cout << "The following matrix sho
"distances"
" between every pair of v
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
if (dist[i][j] == INF)
cout << "INF"
<< " ";
else
cout << dist[i][j] <<
}
cout << endl;
}
}
// Driver's code
int main()
{
/* Let us create the following we
10
(0)------->(3)
| /|\
5 | |
| | 1
\|/ |
(1)------->(2)
3 */
int graph[V][V] = { { 0, 5, INF,
{ INF, 0, 3,
{ INF, INF, 0
{ INF, INF, I

// Function call
floydWarshall(graph);
return 0;
}
// This code is contributed by Mythri

Output

The following matrix shows the shortest distanc

0 5 8 9

INF 0 3 4

INF INF 0 1

INF INF INF 0

Complexity Analysis:

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(V2), to create a 2-D matrix

in order to store the shortest distance for each
pair of nodes.

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.

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.

Important Interview questions

related to Floyd-Warshall:
How to Detect Negative Cycle in a graph using
Floyd Warshall Algorithm?
How is Floyd-warshall algorithm different from
Dijkstra’s algorithm?
How is Floyd-warshall algorithm different from
Bellman-Ford algorithm?

Real World Applications of

Floyd-Warshall Algorithm:
In computer networking, the algorithm can be
used to find the shortest path between all pairs
of nodes in a network. This is termed as
network routing.
Flight Connectivity In the aviation industry to
find the shortest path between the airports.
GIS(Geographic Information Systems)
applications often involve analyzing spatial data,
such as road networks, to find the shortest
paths between locations.
Kleene’s algorithm which is a generalization of
floyd warshall, can be used to find regular
expression for a regular language.

Article Tags : DSA Dynamic Programming Graph

Floyd-Warshall Samsung Shortest Path

Recommended Articles
1. Finding shortest path between any two nodes using
Floyd Warshall Algorithm
2. Transitive closure of a graph using Floyd Warshall
Algorithm
3. Bellman-Ford vs Floyd-Warshall's algorithm: A
Comparative Analysis
4. Comparison of Dijkstra’s and Floyd–Warshall
algorithms
5. Detecting negative cycle using Floyd Warshall
6. Floyd-Rivest Algorithm
7. Floyd’s Cycle Finding Algorithm
8. Program to print Reverse Floyd's triangle
9. How does Floyd's slow and fast pointers approach
work?
10. Program to Print Floyd's Triangle
11. Edge Relaxation Property for Dijkstra’s Algorithm
and Bellman Ford's Algorithm
12. Difference between Greedy Algorithm and Divide
and Conquer Algorithm
13. Z algorithm (Linear time pattern searching
Algorithm)
14. Algorithm Library | C++ Magicians STL Algorithm
15. Karatsuba algorithm for fast multiplication using
Divide and Conquer algorithm
16. Reversal algorithm for Array rotation
17. Block swap algorithm for array rotation
18. Which sorting algorithm makes minimum number
of memory writes?
19. Boruvka's algorithm for Minimum Spanning Tree
20. Rabin-Karp Algorithm for Pattern Searching
21. Optimized Algorithm for Pattern Searching
22. Introduction to Push Relabel Algorithm
23. Finite Automata algorithm for Pattern Searching
24. Shuffle a given array using Fisher–Yates shuffle
Algorithm
25. An in-place algorithm for String Transformation

Read Full Article

A-143, 9th Floor, Sovereign Corporate

Tower, Sector-136, Noida, Uttar Pradesh -
201305

[email protected]

Company
About Us

Legal

Careers

In Media

Contact Us

Advertise with us

GFG Corporate Solution

Placement Training Program

Apply for Mentor

Explore
Job-A-Thon Hiring Challenge

Hack-A-Thon

GfG Weekly Contest

Offline Classes (Delhi/NCR)

DSA in JAVA/C++

Master System Design

Master CP

GeeksforGeeks Videos

Languages

Python

Java

C++

PHP

GoLang

SQL

R Language

Android Tutorial

DSA Concepts

Data Structures

Arrays

Strings

Linked List

Algorithms

Searching

Sorting

Mathematical

Dynamic Programming

DSA Roadmaps
DSA for Beginners

Basic DSA Coding Problems

DSA Roadmap by Sandeep Jain

DSA with JavaScript

Top 100 DSA Interview Problems

All Cheat Sheets

Web Development

HTML

CSS

JavaScript

Bootstrap

ReactJS

AngularJS

NodeJS

Express.js

Lodash

Web Design

Computer Science

GATE CS Notes

Operating Systems

Computer Network

Database Management System

Software Engineering

Digital Logic Design

Engineering Maths

Python

Python Programming Examples

Django Tutorial
Open In App