# Finding shortest path between any two nodes using Floyd Warshall Algorithm

• Difficulty Level : Hard
• Last Updated : 18 Aug, 2021

Given a graph and two nodes u and v, the task is to print the shortest path between u and v using the Floyd Warshall algorithm.

Examples:

Input: u = 1, v = 3 Output: 1 -> 2 -> 3
Explanation:
Shortest path from 1 to 3 is through vertex 2 with total cost 3.
The first edge is 1 -> 2 with cost 2 and the second edge is 2 -> 3 with cost 1.

Input: u = 0, v = 2 Output: 0 -> 1 -> 2
Explanation:
Shortest path from 0 to 2 is through vertex 1 with total cost = 5

Approach:

• The main idea here is to use a matrix(2D array) that will keep track of the next node to point if the shortest path changes for any pair of nodes. Initially, the shortest path between any two nodes u and v is v (that is the direct edge from u -> v).

• Initialising the Next array

If the path exists between two nodes then Next[u][v] = v
else we set Next[u][v] = -1

• Modification in Floyd Warshall Algorithm

Inside the if condition of Floyd Warshall Algorithm we’ll add a statement Next[i][j] = Next[i][k]
(that means we found the shortest path between i, j through an intermediate node k).

• This is how our if condition would look like
```if(dis[i][j] > dis[i][k] + dis[k][j])
{
dis[i][j] = dis[i][k] + dis[k][j];
Next[i][j] = Next[i][k];
}```
• For constructing path using these nodes we’ll simply start looping through the node u while updating its value to next[u][v] until we reach node v.
```path = [u]
while u != v:
u = Next[u][v]
path.append(u)```

Below is the implementation of the above approach.

## C++

 `// C++ program to find the shortest ` `// path between any two nodes using ` `// Floyd Warshall Algorithm. ` `#include ` `using` `namespace` `std; `   `#define MAXN 100 ` `// Infinite value for array ` `const` `int` `INF = 1e7; `   `int` `dis[MAXN][MAXN]; ` `int` `Next[MAXN][MAXN]; `   `// Initializing the distance and ` `// Next array ` `void` `initialise(``int` `V, ` `                ``vector >& graph) ` `{ ` `    ``for` `(``int` `i = 0; i < V; i++) { ` `        ``for` `(``int` `j = 0; j < V; j++) { ` `            ``dis[i][j] = graph[i][j]; `   `            ``// No edge between node ` `            ``// i and j ` `            ``if` `(graph[i][j] == INF) ` `                ``Next[i][j] = -1; ` `            ``else` `                ``Next[i][j] = j; ` `        ``} ` `    ``} ` `} `   `// Function construct the shortest ` `// path between u and v ` `vector<``int``> constructPath(``int` `u, ` `                        ``int` `v) ` `{ ` `    ``// If there's no path between ` `    ``// node u and v, simply return ` `    ``// an empty array ` `    ``if` `(Next[u][v] == -1) ` `        ``return` `{}; `   `    ``// Storing the path in a vector ` `    ``vector<``int``> path = { u }; ` `    ``while` `(u != v) { ` `        ``u = Next[u][v]; ` `        ``path.push_back(u); ` `    ``} ` `    ``return` `path; ` `} `   `// Standard Floyd Warshall Algorithm ` `// with little modification Now if we find ` `// that dis[i][j] > dis[i][k] + dis[k][j] ` `// then we modify next[i][j] = next[i][k] ` `void` `floydWarshall(``int` `V) ` `{ ` `    ``for` `(``int` `k = 0; k < V; k++) { ` `        ``for` `(``int` `i = 0; i < V; i++) { ` `            ``for` `(``int` `j = 0; j < V; j++) { `   `                ``// We cannot travel through ` `                ``// edge that doesn't exist ` `                ``if` `(dis[i][k] == INF ` `                    ``|| dis[k][j] == INF) ` `                    ``continue``; `   `                ``if` `(dis[i][j] > dis[i][k] ` `                                    ``+ dis[k][j]) { ` `                    ``dis[i][j] = dis[i][k] ` `                                ``+ dis[k][j]; ` `                    ``Next[i][j] = Next[i][k]; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` `} `   `// Print the shortest path ` `void` `printPath(vector<``int``>& path) ` `{ ` `    ``int` `n = path.size(); ` `    ``for` `(``int` `i = 0; i < n - 1; i++) ` `        ``cout << path[i] << ``" -> "``; ` `    ``cout << path[n - 1] << endl; ` `} `   `// Driver code ` `int` `main() ` `{ `   `    ``int` `V = 4; ` `    ``vector > graph ` `        ``= { { 0, 3, INF, 7 }, ` `            ``{ 8, 0, 2, INF }, ` `            ``{ 5, INF, 0, 1 }, ` `            ``{ 2, INF, INF, 0 } }; `   `    ``// Function to initialise the ` `    ``// distance and Next array ` `    ``initialise(V, graph); `   `    ``// Calling Floyd Warshall Algorithm, ` `    ``// this will update the shortest ` `    ``// distance as well as Next array ` `    ``floydWarshall(V); ` `    ``vector<``int``> path; `   `    ``// Path from node 1 to 3 ` `    ``cout << ``"Shortest path from 1 to 3: "``; ` `    ``path = constructPath(1, 3); ` `    ``printPath(path); `   `    ``// Path from node 0 to 2 ` `    ``cout << ``"Shortest path from 0 to 2: "``; ` `    ``path = constructPath(0, 2); ` `    ``printPath(path); `   `    ``// path from node 3 to 2 ` `    ``cout << ``"Shortest path from 3 to 2: "``; ` `    ``path = constructPath(3, 2); ` `    ``printPath(path); `   `    ``return` `0; ` `} `

## Java

 `// Java program to find the shortest ` `// path between any two nodes using ` `// Floyd Warshall Algorithm. ` `import` `java.util.*; `   `class` `GFG{ `   `static` `final` `int` `MAXN = ``100``; `   `// Infinite value for array ` `static` `int` `INF = (``int``) 1e7; `   `static` `int` `[][]dis = ``new` `int``[MAXN][MAXN]; ` `static` `int` `[][]Next = ``new` `int``[MAXN][MAXN]; `   `// Initializing the distance and ` `// Next array ` `static` `void` `initialise(``int` `V, ` `                    ``int` `[][] graph) ` `{ ` `    ``for``(``int` `i = ``0``; i < V; i++) ` `    ``{ ` `    ``for``(``int` `j = ``0``; j < V; j++) ` `    ``{ ` `        ``dis[i][j] = graph[i][j]; ` `            `  `        ``// No edge between node ` `        ``// i and j ` `        ``if` `(graph[i][j] == INF) ` `            ``Next[i][j] = -``1``; ` `        ``else` `            ``Next[i][j] = j; ` `    ``} ` `    ``} ` `} `   `// Function construct the shortest ` `// path between u and v ` `static` `Vector constructPath(``int` `u, ` `                                    ``int` `v) ` `{ `   `    ``// If there's no path between ` `    ``// node u and v, simply return ` `    ``// an empty array ` `    ``if` `(Next[u][v] == -``1``) ` `        ``return` `null``; `   `    ``// Storing the path in a vector ` `    ``Vector path = ``new` `Vector(); ` `    ``path.add(u); ` `    `  `    ``while` `(u != v) ` `    ``{ ` `        ``u = Next[u][v]; ` `        ``path.add(u); ` `    ``} ` `    ``return` `path; ` `} `   `// Standard Floyd Warshall Algorithm ` `// with little modification Now if we find ` `// that dis[i][j] > dis[i][k] + dis[k][j] ` `// then we modify next[i][j] = next[i][k] ` `static` `void` `floydWarshall(``int` `V) ` `{ ` `    ``for``(``int` `k = ``0``; k < V; k++) ` `    ``{ ` `    ``for``(``int` `i = ``0``; i < V; i++) ` `    ``{ ` `        ``for``(``int` `j = ``0``; j < V; j++) ` `        ``{ ` `            `  `            ``// We cannot travel through ` `            ``// edge that doesn't exist ` `            ``if` `(dis[i][k] == INF || ` `                ``dis[k][j] == INF) ` `                ``continue``; ` `                `  `            ``if` `(dis[i][j] > dis[i][k] + ` `                            ``dis[k][j]) ` `            ``{ ` `                ``dis[i][j] = dis[i][k] + ` `                            ``dis[k][j]; ` `                ``Next[i][j] = Next[i][k]; ` `            ``} ` `        ``} ` `    ``} ` `    ``} ` `} `   `// Print the shortest path ` `static` `void` `printPath(Vector path) ` `{ ` `    ``int` `n = path.size(); ` `    ``for``(``int` `i = ``0``; i < n - ``1``; i++) ` `    ``System.out.print(path.get(i) + ``" -> "``); ` `    ``System.out.print(path.get(n - ``1``) + ``"\n"``); ` `} `   `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `V = ``4``; ` `    ``int` `[][] graph = { { ``0``, ``3``, INF, ``7` `}, ` `                    ``{ ``8``, ``0``, ``2``, INF }, ` `                    ``{ ``5``, INF, ``0``, ``1` `}, ` `                    ``{ ``2``, INF, INF, ``0` `} }; `   `    ``// Function to initialise the ` `    ``// distance and Next array ` `    ``initialise(V, graph); `   `    ``// Calling Floyd Warshall Algorithm, ` `    ``// this will update the shortest ` `    ``// distance as well as Next array ` `    ``floydWarshall(V); ` `    ``Vector path; `   `    ``// Path from node 1 to 3 ` `    ``System.out.print(``"Shortest path from 1 to 3: "``); ` `    ``path = constructPath(``1``, ``3``); ` `    ``printPath(path); `   `    ``// Path from node 0 to 2 ` `    ``System.out.print(``"Shortest path from 0 to 2: "``); ` `    ``path = constructPath(``0``, ``2``); ` `    ``printPath(path); `   `    ``// Path from node 3 to 2 ` `    ``System.out.print(``"Shortest path from 3 to 2: "``); ` `    ``path = constructPath(``3``, ``2``); ` `    ``printPath(path); ` `} ` `} `   `// This code is contributed by Amit Katiyar `

## Python3

 `# Python3 program to find the shortest` `# path between any two nodes using` `# Floyd Warshall Algorithm.`   `# Initializing the distance and` `# Next array` `def` `initialise(V):` `    ``global` `dis, ``Next`   `    ``for` `i ``in` `range``(V):` `        ``for` `j ``in` `range``(V):` `            ``dis[i][j] ``=` `graph[i][j]`   `            ``# No edge between node` `            ``# i and j` `            ``if` `(graph[i][j] ``=``=` `INF):` `                ``Next``[i][j] ``=` `-``1` `            ``else``:` `                ``Next``[i][j] ``=` `j`   `# Function construct the shortest` `# path between u and v` `def` `constructPath(u, v):` `    ``global` `graph, ``Next` `    `  `    ``# If there's no path between` `    ``# node u and v, simply return` `    ``# an empty array` `    ``if` `(``Next``[u][v] ``=``=` `-``1``):` `        ``return` `{}`   `    ``# Storing the path in a vector` `    ``path ``=` `[u]` `    ``while` `(u !``=` `v):` `        ``u ``=` `Next``[u][v]` `        ``path.append(u)`   `    ``return` `path`   `# Standard Floyd Warshall Algorithm` `# with little modification Now if we find` `# that dis[i][j] > dis[i][k] + dis[k][j]` `# then we modify next[i][j] = next[i][k]` `def` `floydWarshall(V):` `    ``global` `dist, ``Next` `    ``for` `k ``in` `range``(V):` `        ``for` `i ``in` `range``(V):` `            ``for` `j ``in` `range``(V):` `                `  `                ``# We cannot travel through` `                ``# edge that doesn't exist` `                ``if` `(dis[i][k] ``=``=` `INF ``or` `dis[k][j] ``=``=` `INF):` `                    ``continue` `                ``if` `(dis[i][j] > dis[i][k] ``+` `dis[k][j]):` `                    ``dis[i][j] ``=` `dis[i][k] ``+` `dis[k][j]` `                    ``Next``[i][j] ``=` `Next``[i][k]`   `# Print the shortest path` `def` `printPath(path):` `    ``n ``=` `len``(path)` `    ``for` `i ``in` `range``(n ``-` `1``):` `        ``print``(path[i], end``=``" -> "``)` `    ``print` `(path[n ``-` `1``])`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``MAXM,INF ``=` `100``,``10``*``*``7` `    ``dis ``=` `[[``-``1` `for` `i ``in` `range``(MAXM)] ``for` `i ``in` `range``(MAXM)]` `    ``Next` `=` `[[``-``1` `for` `i ``in` `range``(MAXM)] ``for` `i ``in` `range``(MAXM)]`   `    ``V ``=` `4` `    ``graph ``=` `[ [ ``0``, ``3``, INF, ``7` `],` `            ``[ ``8``, ``0``, ``2``, INF ],` `            ``[ ``5``, INF, ``0``, ``1` `],` `            ``[ ``2``, INF, INF, ``0` `] ]`   `    ``# Function to initialise the` `    ``# distance and Next array` `    ``initialise(V)`   `    ``# Calling Floyd Warshall Algorithm,` `    ``# this will update the shortest` `    ``# distance as well as Next array` `    ``floydWarshall(V)` `    ``path ``=` `[]`   `    ``# Path from node 1 to 3` `    ``print``(``"Shortest path from 1 to 3: "``, end ``=` `"")` `    ``path ``=` `constructPath(``1``, ``3``)` `    ``printPath(path)`   `    ``# Path from node 0 to 2` `    ``print``(``"Shortest path from 0 to 2: "``, end ``=` `"")` `    ``path ``=` `constructPath(``0``, ``2``)` `    ``printPath(path)`   `    ``# Path from node 3 to 2` `    ``print``(``"Shortest path from 3 to 2: "``, end ``=` `"")` `    ``path ``=` `constructPath(``3``, ``2``)` `    ``printPath(path)`   `    ``# This code is contributed by mohit kumar 29`

## C#

 `// C# program to find the shortest` `// path between any two nodes using` `// Floyd Warshall Algorithm.` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `static` `readonly` `int` `MAXN = 100;`   `// Infinite value for array` `static` `int` `INF = (``int``)1e7;`   `static` `int` `[,]dis = ``new` `int``[MAXN, MAXN];` `static` `int` `[,]Next = ``new` `int``[MAXN, MAXN];`   `// Initializing the distance and` `// Next array` `static` `void` `initialise(``int` `V,` `                       ``int` `[,] graph)` `{` `    ``for``(``int` `i = 0; i < V; i++)` `    ``{` `        ``for``(``int` `j = 0; j < V; j++) ` `        ``{` `            ``dis[i, j] = graph[i, j];` `                `  `            ``// No edge between node` `            ``// i and j` `            ``if` `(graph[i, j] == INF)` `                ``Next[i, j] = -1;` `            ``else` `                ``Next[i, j] = j;` `        ``}` `    ``}` `}`   `// Function construct the shortest` `// path between u and v` `static` `List<``int``> constructPath(``int` `u, ``int` `v)` `{` `    `  `    ``// If there's no path between` `    ``// node u and v, simply return` `    ``// an empty array` `    ``if` `(Next[u, v] == -1)` `        ``return` `null``;`   `    ``// Storing the path in a vector` `    ``List<``int``> path = ``new` `List<``int``>();` `    ``path.Add(u);` `    `  `    ``while` `(u != v) ` `    ``{` `        ``u = Next[u, v];` `        ``path.Add(u);` `    ``}` `    ``return` `path;` `}`   `// Standard Floyd Warshall Algorithm` `// with little modification Now if we find` `// that dis[i,j] > dis[i,k] + dis[k,j]` `// then we modify next[i,j] = next[i,k]` `static` `void` `floydWarshall(``int` `V)` `{` `    ``for``(``int` `k = 0; k < V; k++)` `    ``{` `        ``for``(``int` `i = 0; i < V; i++)` `        ``{` `            ``for``(``int` `j = 0; j < V; j++)` `            ``{` `                `  `                ``// We cannot travel through ` `                ``// edge that doesn't exist ` `                ``if` `(dis[i, k] == INF ||  ` `                    ``dis[k, j] == INF) ` `                    ``continue``; ` `                   `  `                ``if` `(dis[i, j] > dis[i, k] + ` `                                ``dis[k, j]) ` `                ``{ ` `                    ``dis[i, j] = dis[i, k] +  ` `                                ``dis[k, j]; ` `                    ``Next[i, j] = Next[i, k]; ` `                ``} ` `            ``}` `        ``}` `    ``}` `}`   `// Print the shortest path` `static` `void` `printPath(List<``int``> path)` `{` `    ``int` `n = path.Count;` `    `  `    ``for``(``int` `i = 0; i < n - 1; i++) ` `        ``Console.Write(path[i] + ``" -> "``);` `       `  `    ``Console.Write(path[n - 1] + ``"\n"``);` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `V = 4;` `    ``int` `[,] graph = { { 0, 3, INF, 7 },` `                      ``{ 8, 0, 2, INF },` `                      ``{ 5, INF, 0, 1 },` `                      ``{ 2, INF, INF, 0 } };`   `    ``// Function to initialise the` `    ``// distance and Next array` `    ``initialise(V, graph);`   `    ``// Calling Floyd Warshall Algorithm,` `    ``// this will update the shortest` `    ``// distance as well as Next array` `    ``floydWarshall(V);` `    ``List<``int``> path;`   `    ``// Path from node 1 to 3` `    ``Console.Write(``"Shortest path from 1 to 3: "``);` `    ``path = constructPath(1, 3);` `    ``printPath(path);`   `    ``// Path from node 0 to 2` `    ``Console.Write(``"Shortest path from 0 to 2: "``);` `    ``path = constructPath(0, 2);` `    ``printPath(path);`   `    ``// Path from node 3 to 2` `    ``Console.Write(``"Shortest path from 3 to 2: "``);` `    ``path = constructPath(3, 2);` `    ``printPath(path);` `}` `}`   `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

```Shortest path from 1 to 3: 1 -> 2 -> 3
Shortest path from 0 to 2: 0 -> 1 -> 2
Shortest path from 3 to 2: 3 -> 0 -> 1 -> 2```

Complexity Analysis:

• The time complexity for Floyd Warshall Algorithm is O(V3)
• For finding shortest path time complexity is O(V) per query.

Note: It would be efficient to use the Floyd Warshall Algorithm when your graph contains a couple of hundred vertices and you need to answer multiple queries related to the shortest path.

My Personal Notes arrow_drop_up
Recommended Articles
Page :