Open In App
Related Articles

# 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(1)

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];``}`