GFG App
Open App
Browser
Continue

# Floyd Warshall Algorithm | DP-16

The Floyd Warshall Algorithm is for solving all pairs of shortest-path problems. The problem is to find the shortest distances between every pair of vertices in a given edge-weighted directed Graph.

It is an algorithm for finding the shortest path between all the pairs of vertices in a weighted graph. This algorithm follows the dynamic programming approach to find the shortest path.

A C-function for a N x N graph is given below. The function stores the all pair shortest path in the matrix cost [N][N]. The cost matrix of the given graph is available in cost Mat [N][N].

Example:

Input:  graph[][] = { {0,   5,  INF, 10},
{INF,  0,  3,  INF},
{INF, INF, 0,   1},
{INF, INF, INF, 0} }
which represents the following graph
10
(0)——->(3)
|              /|\
5 |               |  1
|               |
\|/             |
(1)——->(2)
3
Output: Shortest distance matrix
0        5      8       9
INF       0      3       4
INF     INF    0       1
INF     INF    INF    0

Recommended Practice

## Floyd Warshall Algorithm:

```# define N 4

void floydwarshall()
{
int cost [N][N];
int i, j, k;
for(i=0; i<N; i++)
for(j=0; j<N; j++)
cost [i][j]= cost Mat [i] [i];
for(k=0; k<N; k++)
{
for(i=0; i<N; i++)
for(j=0; j<N; j++)
if(cost [i][j]> cost [i] [k] + cost [k][j];
cost [i][j]=cost [i] [k]+'cost [k] [i]:
}

//display the matrix cost [N] [N]
}```
• 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 one by one pick all vertices 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]

The following figure shows the above optimal substructure property in the all-pairs shortest path problem.

Below is the implementation of the above approach:

## C++

 `// C++ Program for Floyd Warshall Algorithm` `#include ` `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 matrix` `void` `printSolution(``int` `dist[][V]);`   `// Solves the all-pairs shortest path` `// problem using Floyd Warshall algorithm` `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 between all` `    ``pairs of vertices such that the` `    ``shortest distances consider only the` `    ``vertices in set {0, 1, 2, .. k-1} as` `    ``intermediate vertices.` `    ``----> After the end of an iteration,` `    ``vertex no. k is added to the set of` `    ``intermediate vertices and the set becomes {0, 1, 2, ..` `    ``k} */` `    ``for` `(k = 0; k < V; k++) {` `        ``// Pick all vertices as source one by one` `        ``for` `(i = 0; i < V; i++) {` `            ``// Pick all vertices as destination for the` `            ``// above picked source` `            ``for` `(j = 0; j < V; j++) {` `                ``// If vertex k is on the shortest path from` `                ``// i to j, then update the value of` `                ``// dist[i][j]` `                ``if` `(dist[i][j] > (dist[i][k] + dist[k][j])` `                    ``&& (dist[k][j] != INF` `                        ``&& dist[i][k] != INF))` `                    ``dist[i][j] = dist[i][k] + dist[k][j];` `            ``}` `        ``}` `    ``}`   `    ``// Print the shortest distance matrix` `    ``printSolution(dist);` `}`   `/* A utility function to print solution */` `void` `printSolution(``int` `dist[][V])` `{` `    ``cout << ``"The following matrix shows the shortest "` `            ``"distances"` `            ``" between every pair of vertices \n"``;` `    ``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 weighted graph` `            ``10` `    ``(0)------->(3)` `        ``|     /|\` `    ``5 |     |` `        ``|     | 1` `    ``\|/     |` `    ``(1)------->(2)` `            ``3     */` `    ``int` `graph[V][V] = { { 0, 5, INF, 10 },` `                        ``{ INF, 0, 3, INF },` `                        ``{ INF, INF, 0, 1 },` `                        ``{ INF, INF, INF, 0 } };`   `    ``// Function call` `    ``floydWarshall(graph);` `    ``return` `0;` `}`   `// This code is contributed by Mythri J L`

## C

 `// C Program for Floyd Warshall Algorithm` `#include `   `// 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 matrix` `void` `printSolution(``int` `dist[][V]);`   `// Solves the all-pairs shortest path` `// problem using Floyd Warshall algorithm` `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 between all` `      ``pairs of vertices such that the shortest` `      ``distances consider only the` `      ``vertices in set {0, 1, 2, .. k-1} as` `      ``intermediate vertices.` `      ``----> After the end of an iteration,` `      ``vertex no. k is added to the set of` `      ``intermediate vertices and the set` `      ``becomes {0, 1, 2, .. k} */` `    ``for` `(k = 0; k < V; k++) {` `        ``// Pick all vertices as source one by one` `        ``for` `(i = 0; i < V; i++) {` `            ``// Pick all vertices as destination for the` `            ``// above picked source` `            ``for` `(j = 0; j < V; j++) {` `                ``// If vertex k is on the shortest path from` `                ``// i to j, then update the value of` `                ``// dist[i][j]` `                ``if` `(dist[i][k] + dist[k][j] < dist[i][j])` `                    ``dist[i][j] = dist[i][k] + dist[k][j];` `            ``}` `        ``}` `    ``}`   `    ``// Print the shortest distance matrix` `    ``printSolution(dist);` `}`   `/* A utility function to print solution */` `void` `printSolution(``int` `dist[][V])` `{` `    ``printf``(` `        ``"The following matrix shows the shortest distances"` `        ``" between every pair of vertices \n"``);` `    ``for` `(``int` `i = 0; i < V; i++) {` `        ``for` `(``int` `j = 0; j < V; j++) {` `            ``if` `(dist[i][j] == INF)` `                ``printf``(``"%7s"``, ``"INF"``);` `            ``else` `                ``printf``(``"%7d"``, dist[i][j]);` `        ``}` `        ``printf``(``"\n"``);` `    ``}` `}`   `// driver's code` `int` `main()` `{` `    ``/* Let us create the following weighted graph` `            ``10` `       ``(0)------->(3)` `        ``|         /|\` `      ``5 |          |` `        ``|          | 1` `       ``\|/         |` `       ``(1)------->(2)` `            ``3           */` `    ``int` `graph[V][V] = { { 0, 5, INF, 10 },` `                        ``{ INF, 0, 3, INF },` `                        ``{ INF, INF, 0, 1 },` `                        ``{ INF, INF, INF, 0 } };`   `    ``// Function call` `    ``floydWarshall(graph);` `    ``return` `0;` `}`

## Java

 `// Java program for Floyd Warshall All Pairs Shortest` `// Path algorithm.` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;`   `class` `AllPairShortestPath {` `    ``final` `static` `int` `INF = ``99999``, V = ``4``;`   `    ``void` `floydWarshall(``int` `dist[][])` `    ``{`   `        ``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 between all pairs` `               ``of vertices such that` `               ``the shortest distances consider` `               ``only the vertices in` `               ``set {0, 1, 2, .. k-1} as` `               ``intermediate vertices.` `          ``----> After the end of an iteration,` `                ``vertex no. k is added` `                ``to the set of intermediate` `                ``vertices and the set` `                ``becomes {0, 1, 2, .. k} */` `        ``for` `(k = ``0``; k < V; k++) {` `            ``// Pick all vertices as source one by one` `            ``for` `(i = ``0``; i < V; i++) {` `                ``// Pick all vertices as destination for the` `                ``// above picked source` `                ``for` `(j = ``0``; j < V; j++) {` `                    ``// If vertex k is on the shortest path` `                    ``// from i to j, then update the value of` `                    ``// dist[i][j]` `                    ``if` `(dist[i][k] + dist[k][j]` `                        ``< dist[i][j])` `                        ``dist[i][j]` `                            ``= dist[i][k] + dist[k][j];` `                ``}` `            ``}` `        ``}`   `        ``// Print the shortest distance matrix` `        ``printSolution(dist);` `    ``}`   `    ``void` `printSolution(``int` `dist[][])` `    ``{` `        ``System.out.println(` `            ``"The following matrix shows the shortest "` `            ``+ ``"distances between every pair of vertices"``);` `        ``for` `(``int` `i = ``0``; i < V; ++i) {` `            ``for` `(``int` `j = ``0``; j < V; ++j) {` `                ``if` `(dist[i][j] == INF)` `                    ``System.out.print(``"INF "``);` `                ``else` `                    ``System.out.print(dist[i][j] + ``"   "``);` `            ``}` `            ``System.out.println();` `        ``}` `    ``}`   `    ``// Driver's code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``/* Let us create the following weighted graph` `           ``10` `        ``(0)------->(3)` `        ``|         /|\` `        ``5 |          |` `        ``|          | 1` `        ``\|/         |` `        ``(1)------->(2)` `           ``3           */` `        ``int` `graph[][] = { { ``0``, ``5``, INF, ``10` `},` `                          ``{ INF, ``0``, ``3``, INF },` `                          ``{ INF, INF, ``0``, ``1` `},` `                          ``{ INF, INF, INF, ``0` `} };` `        ``AllPairShortestPath a = ``new` `AllPairShortestPath();`   `        ``// Function call` `        ``a.floydWarshall(graph);` `    ``}` `}`   `// Contributed by Aakash Hasija`

## Python3

 `# Python3 Program for Floyd Warshall Algorithm`   `# Number of vertices in the graph` `V ``=` `4`   `# Define infinity as the large` `# enough value. This value will be` `# used for vertices not connected to each other` `INF ``=` `99999`   `# Solves all pair shortest path` `# via Floyd Warshall Algorithm`     `def` `floydWarshall(graph):` `    ``""" dist[][] will be the output ` `       ``matrix that will finally` `        ``have the shortest distances ` `        ``between every pair of vertices """` `    ``""" initializing the solution matrix ` `    ``same as input graph matrix` `    ``OR we can say that the initial ` `    ``values of shortest distances` `    ``are based on shortest paths considering no ` `    ``intermediate vertices """`   `    ``dist ``=` `list``(``map``(``lambda` `i: ``list``(``map``(``lambda` `j: j, i)), graph))`   `    ``""" Add all vertices one by one ` `    ``to the set of intermediate` `     ``vertices.` `     ``---> Before start of an iteration, ` `     ``we have shortest distances` `     ``between all pairs of vertices ` `     ``such that the shortest` `     ``distances consider only the ` `     ``vertices in the set ` `    ``{0, 1, 2, .. k-1} as intermediate vertices.` `      ``----> After the end of a ` `      ``iteration, vertex no. k is` `     ``added to the set of intermediate ` `     ``vertices and the ` `    ``set becomes {0, 1, 2, .. k}` `    ``"""` `    ``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):`   `                ``# If vertex k is on the shortest path from` `                ``# i to j, then update the value of dist[i][j]` `                ``dist[i][j] ``=` `min``(dist[i][j],` `                                 ``dist[i][k] ``+` `dist[k][j]` `                                 ``)` `    ``printSolution(dist)`     `# A utility function to print the solution` `def` `printSolution(dist):` `    ``print``("Following matrix shows the shortest distances\` ` ``between every pair of vertices")` `    ``for` `i ``in` `range``(V):` `        ``for` `j ``in` `range``(V):` `            ``if``(dist[i][j] ``=``=` `INF):` `                ``print``(``"%7s"` `%` `(``"INF"``), end``=``" "``)` `            ``else``:` `                ``print``(``"%7d\t"` `%` `(dist[i][j]), end``=``' '``)` `            ``if` `j ``=``=` `V``-``1``:` `                ``print``()`     `# Driver's code` `if` `__name__ ``=``=` `"__main__"``:` `    ``"""` `                ``10` `           ``(0)------->(3)` `            ``|         /|\` `          ``5 |          |` `            ``|          | 1` `           ``\|/         |` `           ``(1)------->(2)` `                ``3           """` `    ``graph ``=` `[[``0``, ``5``, INF, ``10``],` `             ``[INF, ``0``, ``3``, INF],` `             ``[INF, INF, ``0``,   ``1``],` `             ``[INF, INF, INF, ``0``]` `             ``]` `    ``# Function call` `    ``floydWarshall(graph)` `# This code is contributed by Mythri J L`

## C#

 `// C# program for Floyd Warshall All` `// Pairs Shortest Path algorithm.`   `using` `System;`   `public` `class` `AllPairShortestPath {` `    ``readonly` `static` `int` `INF = 99999, V = 4;`   `    ``void` `floydWarshall(``int``[, ] graph)` `    ``{` `        ``int``[, ] dist = ``new` `int``[V, V];` `        ``int` `i, j, k;`   `        ``// Initialize the solution matrix` `        ``// same as input graph matrix` `        ``// Or we can say the initial` `        ``// values of shortest distances` `        ``// are based on shortest paths` `        ``// considering no intermediate` `        ``// vertex` `        ``for` `(i = 0; i < V; i++) {` `            ``for` `(j = 0; j < V; j++) {` `                ``dist[i, j] = graph[i, j];` `            ``}` `        ``}`   `        ``/* Add all vertices one by one to` `        ``the set of intermediate vertices.` `        ``---> Before start of a iteration,` `             ``we have shortest distances` `             ``between all pairs of vertices` `             ``such that the shortest distances` `             ``consider only the vertices in` `             ``set {0, 1, 2, .. k-1} as` `             ``intermediate vertices.` `        ``---> After the end of a iteration,` `             ``vertex no. k is added` `             ``to the set of intermediate` `             ``vertices and the set` `             ``becomes {0, 1, 2, .. k} */` `        ``for` `(k = 0; k < V; k++) {` `            ``// Pick all vertices as source` `            ``// one by one` `            ``for` `(i = 0; i < V; i++) {` `                ``// Pick all vertices as destination` `                ``// for the above picked source` `                ``for` `(j = 0; j < V; j++) {` `                    ``// If vertex k is on the shortest` `                    ``// path from i to j, then update` `                    ``// the value of dist[i][j]` `                    ``if` `(dist[i, k] + dist[k, j]` `                        ``< dist[i, j]) {` `                        ``dist[i, j]` `                            ``= dist[i, k] + dist[k, j];` `                    ``}` `                ``}` `            ``}` `        ``}`   `        ``// Print the shortest distance matrix` `        ``printSolution(dist);` `    ``}`   `    ``void` `printSolution(``int``[, ] dist)` `    ``{` `        ``Console.WriteLine(` `            ``"Following matrix shows the shortest "` `            ``+ ``"distances between every pair of vertices"``);` `        ``for` `(``int` `i = 0; i < V; ++i) {` `            ``for` `(``int` `j = 0; j < V; ++j) {` `                ``if` `(dist[i, j] == INF) {` `                    ``Console.Write(``"INF "``);` `                ``}` `                ``else` `{` `                    ``Console.Write(dist[i, j] + ``" "``);` `                ``}` `            ``}`   `            ``Console.WriteLine();` `        ``}` `    ``}`   `    ``// Driver's Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``/* Let us create the following` `           ``weighted graph` `              ``10` `        ``(0)------->(3)` `        ``|         /|\` `        ``5 |         |` `        ``|         | 1` `        ``\|/         |` `        ``(1)------->(2)` `             ``3             */` `        ``int``[, ] graph = { { 0, 5, INF, 10 },` `                          ``{ INF, 0, 3, INF },` `                          ``{ INF, INF, 0, 1 },` `                          ``{ INF, INF, INF, 0 } };`   `        ``AllPairShortestPath a = ``new` `AllPairShortestPath();`   `        ``// Function call` `        ``a.floydWarshall(graph);` `    ``}` `}`   `// This article is contributed by` `// Abdul Mateen Mohammed`

## PHP

 ` Before start of an iteration, we have ` `    ``shortest distances between all pairs of ` `    ``vertices such that the shortest distances ` `    ``consider only the vertices in set ` `    ``{0, 1, 2, .. k-1} as intermediate vertices. ` `    ``----> After the end of an iteration, vertex ` `    ``no. k is added to the set of intermediate` `    ``vertices and the set becomes {0, 1, 2, .. k} */` `    ``for` `(``\$k` `= 0; ``\$k` `< ``\$V``; ``\$k``++) ` `    ``{ ` `        ``// Pick all vertices as source one by one ` `        ``for` `(``\$i` `= 0; ``\$i` `< ``\$V``; ``\$i``++) ` `        ``{ ` `            ``// Pick all vertices as destination ` `            ``// for the above picked source ` `            ``for` `(``\$j` `= 0; ``\$j` `< ``\$V``; ``\$j``++) ` `            ``{ ` `                ``// If vertex k is on the shortest path from ` `                ``// i to j, then update the value of dist[i][j] ` `                ``if` `(``\$dist``[``\$i``][``\$k``] + ``\$dist``[``\$k``][``\$j``] < ` `                                    ``\$dist``[``\$i``][``\$j``]) ` `                    ``\$dist``[``\$i``][``\$j``] = ``\$dist``[``\$i``][``\$k``] +` `                                    ``\$dist``[``\$k``][``\$j``]; ` `            ``} ` `        ``} ` `    ``} `   `    ``// Print the shortest distance matrix ` `    ``printSolution(``\$dist``, ``\$V``, ``\$INF``); ` `} `   `/* A utility function to print solution */` `function` `printSolution(``\$dist``, ``\$V``, ``\$INF``) ` `{ ` `    ``echo` `"The following matrix shows the "` `.` `             ``"shortest distances between "` `. ` `                ``"every pair of vertices \n"``; ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$V``; ``\$i``++) ` `    ``{ ` `        ``for` `(``\$j` `= 0; ``\$j` `< ``\$V``; ``\$j``++) ` `        ``{ ` `            ``if` `(``\$dist``[``\$i``][``\$j``] == ``\$INF``) ` `                ``echo` `"INF "` `; ` `            ``else` `                ``echo` `\$dist``[``\$i``][``\$j``], ``" "``;` `        ``} ` `        ``echo` `"\n"``; ` `    ``} ` `} `   `// Drivers' Code`   `// Number of vertices in the graph ` `\$V` `= 4 ;`   `/* Define Infinite as a large enough ` `value. This value will be used for` `vertices not connected to each other */` `\$INF` `= 99999 ;`   `/* Let us create the following weighted graph ` `        ``10 ` `(0)------->(3) ` `    ``|     /|\ ` `5 |     | ` `    ``|     | 1 ` `\|/     | ` `(1)------->(2) ` `        ``3     */` `\$graph` `= ``array``(``array``(0, 5, ``\$INF``, 10), ` `               ``array``(``\$INF``, 0, 3, ``\$INF``), ` `               ``array``(``\$INF``, ``\$INF``, 0, 1), ` `               ``array``(``\$INF``, ``\$INF``, ``\$INF``, 0)); `   `// Function call` `floydWarshall(``\$graph``, ``\$V``, ``\$INF``); `   `// This code is contributed by Ryuga` `?>`

## Javascript

 `// A JavaScript program for Floyd Warshall All` `      ``// Pairs Shortest Path algorithm.`   `      ``var` `INF = 99999;` `      ``class AllPairShortestPath {` `        ``constructor() {` `          ``this``.V = 4;` `        ``}`   `        ``floydWarshall(graph) {` `          ``var` `dist = Array.from(Array(``this``.V), () => ``new` `Array(``this``.V).fill(0));` `          ``var` `i, j, k;`   `          ``// Initialize the solution matrix` `          ``// same as input graph matrix` `          ``// Or we can say the initial` `          ``// values of shortest distances` `          ``// are based on shortest paths` `          ``// considering no intermediate` `          ``// vertex` `          ``for` `(i = 0; i < ``this``.V; i++) {` `            ``for` `(j = 0; j < ``this``.V; j++) {` `              ``dist[i][j] = graph[i][j];` `            ``}` `          ``}`   `          ``/* Add all vertices one by one to` `        ``the set of intermediate vertices.` `        ``---> Before start of a iteration,` `            ``we have shortest distances` `            ``between all pairs of vertices` `            ``such that the shortest distances` `            ``consider only the vertices in` `            ``set {0, 1, 2, .. k-1} as` `            ``intermediate vertices.` `        ``---> After the end of a iteration,` `            ``vertex no. k is added` `            ``to the set of intermediate` `            ``vertices and the set` `            ``becomes {0, 1, 2, .. k} */` `          ``for` `(k = 0; k < ``this``.V; k++) {` `            ``// Pick all vertices as source` `            ``// one by one` `            ``for` `(i = 0; i < ``this``.V; i++) {` `              ``// Pick all vertices as destination` `              ``// for the above picked source` `              ``for` `(j = 0; j < ``this``.V; j++) {` `                ``// If vertex k is on the shortest` `                ``// path from i to j, then update` `                ``// the value of dist[i][j]` `                ``if` `(dist[i][k] + dist[k][j] < dist[i][j]) {` `                  ``dist[i][j] = dist[i][k] + dist[k][j];` `                ``}` `              ``}` `            ``}` `          ``}`   `          ``// Print the shortest distance matrix` `          ``this``.printSolution(dist);` `        ``}`   `        ``printSolution(dist) {` `          ``document.write(` `            ``"Following matrix shows the shortest "` `+` `              ``"distances between every pair of vertices
"` `          ``);` `          ``for` `(``var` `i = 0; i < ``this``.V; ++i) {` `            ``for` `(``var` `j = 0; j < ``this``.V; ++j) {` `              ``if` `(dist[i][j] == INF) {` `                ``document.write(``" INF "``);` `              ``} ``else` `{` `                ``document.write(``"  "` `+ dist[i][j] + ``" "``);` `              ``}` `            ``}`   `            ``document.write(``"
"``);` `          ``}` `        ``}` `      ``}` `      ``// Driver Code` `      ``/* Let us create the following` `        ``weighted graph` `            ``10` `        ``(0)------->(3)` `        ``|         /|\` `        ``5 |         |` `        ``|         | 1` `        ``\|/         |` `        ``(1)------->(2)` `            ``3             */` `      ``var` `graph = [` `        ``[0, 5, INF, 10],` `        ``[INF, 0, 3, INF],` `        ``[INF, INF, 0, 1],` `        ``[INF, INF, INF, 0],` `      ``];`   `      ``var` `a = ``new` `AllPairShortestPath();`   `      ``// Print the solution` `      ``a.floydWarshall(graph);` `      `  `      ``// This code is contributed by rdtaank.`

Output

```The following matrix shows the shortest distances between every pair of vertices
0      5      8      9
INF      0      3      4
INF    INF      0      1
INF    INF    INF      0```

Time Complexity: O(V3)
Auxiliary Space: O(V2)

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.

Also, the value of INF can be taken as INT_MAX from limits.h to make sure that we handle the maximum possible value. When we take INF as INT_MAX, we need to change the if condition in the above program to avoid arithmetic overflow.

## C++

 `#include`   `#define INF INT_MAX` `..........................``if` `(dist[i][k] != INF` `                              ``&& dist[k][j] != INF` `                              ``&& dist[i][k] + dist[k][j]` `                                     ``< dist[i][j])` `    ``dist[i][j]` `    ``= dist[i][k] + dist[k][j];` `...........................`

## Java

 `// Java code` `final` `int` `INF = Integer.MAX_VALUE;`   `if` `(dist[i][k] != INF` `        ``&& dist[k][j] != INF` `        ``&& dist[i][k] + dist[k][j] < dist[i][j]) {` `    ``dist[i][j] = dist[i][k] + dist[k][j];` `}`

## Python3

 `if` `dist[i][k] !``=` `numeric_limits.``max``() ``and` `dist[k][j] !``=` `numeric_limits.``max``() ``and` `dist[i][k] ``+` `dist[k][j] < dist[i][j]:` `    ``dist[i][j] ``=` `dist[i][k] ``+` `dist[k][j]`

## C#

 `using` `System;`   `const` `int` `INF = ``int``.MaxValue;`   `if` `(dist[i,k] != INF` `                ``&& dist[k,j] != INF` `                ``&& dist[i,k] + dist[k,j] < dist[i,j])` `{` `  ``dist[i,j] = dist[i,k] + dist[k,j];` `}`

## Javascript

 `// js code` `if` `(dist[i][k] !== Number.MAX_SAFE_INTEGER && dist[k][j] !== Number.MAX_SAFE_INTEGER && dist[i][k] + dist[k][j] < dist[i][j]) {` `    ``dist[i][j] = dist[i][k] + dist[k][j];` `}`