# Check if given path between two nodes of a graph represents a shortest paths

Given an unweighted directed graph and Q queries consisting of sequences of traversal between two nodes of the graph, the task is to find out if the sequences represent one of the shortest paths between the two nodes.

Examples:

```Input: 1 2 3 4
Output: NO

Explanation:
The first and last node of the input sequence
is 1 and 4 respectively. The shortest path
between 1 and 4 is 1 -> 3 -> 4 hence,
the output is NO for the 1st example.

Input: 1 3 4
Output: YES
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:
The idea is to use Floyd Warshall Algorithm to store the length of all pairs of vertices. If the length of the shortest path between the starting and ending node of the sequence is one less than the length of the sequence, then the given sequence represents one of the shortest paths between the nodes.

Below is the implementation of above approach:

## C++

 `// C++ program for  ` `// the above approach ` `#include ` `using` `namespace` `std; ` `#define INFINITE 10000 ` ` `  `// Function to store the  ` `// length of shortest path  ` `// between all pairs of nodes ` `void` `shortestPathLength(``int` `n, ``int` `graph[4][4], ``int` `dis[4][4]) ` `{ ` `  ``// Intialising dis matrix  ` `  ``// with current distance value   ` `  ``for` `(``int` `i = 0; i < n; i++) { ` `      ``for` `(``int` `j = 0; j < n; j++) { ` `          ``dis[i][j] = graph[i][j]; ` `      ``} ` `  ``} ` ` `  `  ``// Floyd-Warshall Algorithm ` `  ``for` `(``int` `k = 0; k < n; k++) { ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `      ``for` `(``int` `j = 0; j < n; j++) { ` `          ``dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]); ` `      ``} ` `    ``} ` `  ``} ` `} ` ` `  `// A function that prints YES if the ` `// given path is the shortest path ` `// and prints NO if the given path ` `// is not shortest ` `void` `checkShortestPath(``int` `length, ``int` `path[], ``int` `dis[4][4]) ` `{ ` `  ``// Check if the given path ` `  ``// is shortest or not ` `  ``// as discussed in above approach ` `  ``if` `(dis[path[0] - 1][path[length - 1] - 1] == length - 1) { ` `      ``cout << ``"YES"` `<< endl; ` `  ``} ` `  ``else` `{ ` `      ``cout << ``"NO"` `<< endl; ` `  ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// Adjacency matrix representing the graph ` `    ``const` `int` `n = 4; ` `    ``int` `graph[n][n] = { { 0, 1, 1, INFINITE }, ` `                        ``{ INFINITE, 0, 1, INFINITE }, ` `                        ``{ INFINITE, INFINITE, 0, 1 }, ` `                        ``{ 1, INFINITE, INFINITE, 0 } }; ` `    ``// A matrix to store the length of shortest ` `    ``int` `dis[n][n]; ` ` `  `    ``// path between all pairs of vertices ` `    ``shortestPathLength(n, graph, dis); ` ` `  `    ``int` `path1[] = { 1, 2, 3, 4 }; ` `    ``checkShortestPath(n, path1, dis); ` ` `  `    ``int` `path2[] = { 1, 3, 4 }; ` `    ``checkShortestPath(3, path2, dis); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach ` `class` `GFG  ` `{ ` `static` `int` `INFINITE = ``10000``; ` ` `  `// Function to store the  ` `// length of shortest path  ` `// between all pairs of nodes ` `static` `void` `shortestPathLength(``int` `n, ``int` `graph[][], ` `                                      ``int` `dis[][]) ` `{ ` `    ``// Intialising dis matrix  ` `    ``// with current distance value  ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{ ` `        ``for` `(``int` `j = ``0``; j < n; j++) ` `        ``{ ` `            ``dis[i][j] = graph[i][j]; ` `        ``} ` `    ``} ` `     `  `    ``// Floyd-Warshall Algorithm ` `    ``for` `(``int` `k = ``0``; k < n; k++)  ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``{ ` `            ``for` `(``int` `j = ``0``; j < n; j++) ` `            ``{ ` `                ``dis[i][j] = Math.min(dis[i][j],  ` `                                     ``dis[i][k] +  ` `                                     ``dis[k][j]); ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// A function that prints YES if the ` `// given path is the shortest path ` `// and prints NO if the given path ` `// is not shortest ` `static` `void` `checkShortestPath(``int` `length,  ` `                              ``int` `path[],  ` `                              ``int` `dis[][]) ` `{ ` `    ``// Check if the given path ` `    ``// is shortest or not ` `    ``// as discussed in above approach ` `    ``if` `(dis[path[``0``] - ``1``][path[length - ``1``] - ``1``] == length - ``1``)  ` `    ``{ ` `        ``System.out.println(``"YES"``); ` `    ``} ` `    ``else`  `    ``{ ` `        ``System.out.println(``"NO"``); ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``// Adjacency matrix representing the graph ` `    ``int` `n = ``4``; ` `    ``int` `graph[][] = { { ``0``, ``1``, ``1``, INFINITE }, ` `                      ``{ INFINITE, ``0``, ``1``, INFINITE }, ` `                      ``{ INFINITE, INFINITE, ``0``, ``1` `}, ` `                      ``{ ``1``, INFINITE, INFINITE, ``0` `} }; ` `                       `  `    ``// A matrix to store the length of shortest ` `    ``int` `[][]dis = ``new` `int``[n][n]; ` ` `  `    ``// path between all pairs of vertices ` `    ``shortestPathLength(n, graph, dis); ` ` `  `    ``int` `path1[] = { ``1``, ``2``, ``3``, ``4` `}; ` `    ``checkShortestPath(n, path1, dis); ` ` `  `    ``int` `path2[] = { ``1``, ``3``, ``4` `}; ` `    ``checkShortestPath(``3``, path2, dis); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python3 program for the above approach ` `INFINITE ``=` `10000` ` `  `# Function to store the ` `# length of shortest path ` `# between all pairs of nodes ` `def` `shortestPathLength(n, graph, dis): ` `     `  `    ``# Initialising dis matrix ` `    ``# with current distance value ` `    ``for` `i ``in` `range``(n): ` `        ``for` `j ``in` `range``(n): ` `            ``dis[i][j] ``=` `graph[i][j] ` ` `  `    ``# Floyd-Warshall Algorithm ` `    ``for` `k ``in` `range``(n): ` `        ``for` `i ``in` `range``(n): ` `            ``for` `j ``in` `range``(n): ` `                ``dis[i][j] ``=` `min``(dis[i][j],  ` `                    ``dis[i][k] ``+` `dis[k][j]) ` ` `  `# A function that prints YES if the ` `# given path is the shortest path ` `# and prints NO if the given path ` `# is not shortest ` `def` `checkShortestPath(length, path, dis): ` `     `  `    ``# Check if the given path ` `    ``# is shortest or not ` `    ``# as discussed in above approach ` `    ``if` `(dis[path[``0``] ``-` `1``][path[length ``-` `1``] ``-` `1``] ``=``=` `length ``-` `1``): ` `        ``print``(``"YES"``) ` `    ``else``: ` `        ``print``(``"NO"``) ` ` `  `# Driver code ` ` `  `# Adjacency matrix representing the graph ` `n ``=` `4` `graph ``=` `[[ ``0``, ``1``, ``1``, INFINITE], ` `         ``[INFINITE, ``0``, ``1``, INFINITE], ` `         ``[INFINITE, INFINITE, ``0``, ``1``], ` `         ``[``1``, INFINITE, INFINITE, ``0``]] ` `         `  `# A matrix to store the length of shortest ` `dis ``=` `[[``0` `for` `i ``in` `range``(n)]  ` `          ``for` `i ``in` `range``(n)] ` ` `  `# path between all pairs of vertices ` `shortestPathLength(n, graph, dis) ` ` `  `path1 ``=` `[``1``, ``2``, ``3``, ``4``] ` `checkShortestPath(n, path1, dis) ` ` `  `path2 ``=` `[``1``, ``3``, ``4``] ` `checkShortestPath(``3``, path2, dis) ` ` `  `# This code is contributed Mohit Kumar `

## C#

 `// C# program for the above approach ` `using` `System; ` ` `  `class` `GFG  ` `{ ` `     `  `static` `int` `INFINITE = 10000; ` ` `  `// Function to store the  ` `//.Length of shortest path  ` `// between all pairs of nodes ` `static` `void` `shortestPathLength(``int` `n, ``int` `[,]graph, ` `                                    ``int` `[,]dis) ` `{ ` `    ``// Intialising dis matrix  ` `    ``// with current distance value  ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``for` `(``int` `j = 0; j < n; j++) ` `        ``{ ` `            ``dis[i, j] = graph[i, j]; ` `        ``} ` `    ``} ` `     `  `    ``// Floyd-Warshall Algorithm ` `    ``for` `(``int` `k = 0; k < n; k++)  ` `    ``{ ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `            ``for` `(``int` `j = 0; j < n; j++) ` `            ``{ ` `                ``dis[i, j] = Math.Min(dis[i, j],  ` `                                    ``dis[i, k] +  ` `                                    ``dis[k, j]); ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `// A function that prints YES if the ` `// given path is the shortest path ` `// and prints NO if the given path ` `// is not shortest ` `static` `void` `checkShortestPath(``int` `length,  ` `                            ``int` `[]path,  ` `                            ``int` `[,]dis) ` `{ ` `    ``// Check if the given path ` `    ``// is shortest or not ` `    ``// as discussed in above approach ` `    ``if` `(dis[path[0] - 1, path[length - 1] - 1] == length - 1)  ` `    ``{ ` `        ``Console.WriteLine(``"YES"``); ` `    ``} ` `    ``else` `    ``{ ` `        ``Console.WriteLine(``"NO"``); ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``// Adjacency matrix representing the graph ` `    ``int` `n = 4; ` `    ``int` `[,]graph = { { 0, 1, 1, INFINITE }, ` `                    ``{ INFINITE, 0, 1, INFINITE }, ` `                    ``{ INFINITE, INFINITE, 0, 1 }, ` `                    ``{ 1, INFINITE, INFINITE, 0 } }; ` `                         `  `    ``// A matrix to store the.Length of shortest ` `    ``int` `[,]dis = ``new` `int``[n, n]; ` ` `  `    ``// path between all pairs of vertices ` `    ``shortestPathLength(n, graph, dis); ` ` `  `    ``int` `[]path1 = { 1, 2, 3, 4 }; ` `    ``checkShortestPath(n, path1, dis); ` ` `  `    ``int` `[]path2 = { 1, 3, 4 }; ` `    ``checkShortestPath(3, path2, dis); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```NO
YES
```

Time complexity: O(V^3)

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.