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

• Difficulty Level : Basic
• Last Updated : 22 Jul, 2021

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```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

```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```

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])` `{` `  ``// Initializing 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[][])` `{` `    ``// Initializing 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):` `    `  `    ``# Initializing 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)` `{` `    ``// Initializing 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`

## Javascript

 ``

Output:

```NO
YES```

Time complexity: O(V^3)

My Personal Notes arrow_drop_up
Recommended Articles
Page :