 GeeksforGeeks App
Open App Browser
Continue

# Time saved travelling in shortest route and shortest path through given city

Given a matrix mat[][] of size N * N, where mat[i][j] represents the time taken to reach from ith city to jth city. Also, given M queries in the form of three arrays S[], I[], and D[] representing source, intermediate, and destination respectively. The task is to find the time taken to go from S[i] to D[i] using I[i] city and the time that can be saved if we go using the shortest path from S[i] to D[i].

Examples:

Input: N = 4, M = 2
mat[][]: { {0, 2, 1, 4}, {1, 0, 4, 1}, {3, 1, 0, 3}, {1, 1, 1, 0} }
S[] = {1, 0}, I[] = {2, 2}, D[] = {3, 1}
Output:
4 3
2 0
Explanation:
Query 1:

• Source, Intermediate and Destination city are S1 = 1, I1 = 2, D1 = 3 respectively.
• Travelling source to destination (1 ->3) city using intermediate (2) city:
• We can use cities as: 1 -> 0 -> 2 -> 1 -> 3, total time taken will be M + M + M + M = 1+1+1+1 = 4. It can be verified that it is the minimum possible time to use an intermediate city for travelling sources to the destination city.
• Travelling source to destination (1 ->3) city directly:
• The most optimal path will be: 1 -> 3, Total time taken will be = M = 1.
• So that the time taken from source to destination city using intermediate city is: 4, while the time that can be saved if travelled directly from source to destination is: 4-1=3 Therefore, the output is 4 3

The time that will take with the intermediate and time that can be saved if not travelled from the intermediate city are 4, and 3 respectively.  Therefore, the output is 4 3.
Query 2:

• Source, Intermediate and Destination city are S2=0, I2=2, D2=1 respectively
• Travelling source to destination (0 ->1) city using intermediate (2) city:
• We can use cities as:  0 -> 2 -> 1, Total time taken will be M + M = 1+1 = 2. It can be verified that it is the minimum possible time using intermediate city for travelling source to destination city.
• Travelling source to destination (0 -> 1) city directly:
• The most optimal path will be: 0 -> 1, Total time taken will be = M = 2.
• So that the time taken from source to destination city using intermediate city is: 2, while the time that can be saved if travelled directly from source to destination is: 2-2 = 0. Therefore, the output is 2 0.

Input:  N = 4, M = 3
mat[][] = {0, 2, 4}, {1, 0, 7}, {3, 2, 0} }
S[] = {0, 2, 1}, I[] = {1, 1, 2}, D[] = {3, 2, 0}
Output:
7 3
3 0
7 7

Approach: Implement the idea below to solve the problem:

The problem is based on shortest path technique and can be solved by using all pair shortest path approach for all the cities.

Steps were taken to solve the problem:

1. Run three nested loops for i = 0, j = 0, k = 0 to i < n, j < n, k < n respectively, and follow below mentioned steps under the scope of loop:
• Calculate time[i][j] as the minimum of mat[i][j] and (mat[i][k] + mat[k][j] )
2. Run a loop from i=0 to M and do the following:
• Create three variables S, IN and D and initialize them equal to S[i], I[i] and D[i] respectively.
• Output the value of mat[S][IN] + mat[IN][D] and  mat[S][IN] + mat[IN][D] – mat[S][D].

Below is the code to implement the approach:

## C++

 `// C++ code to implement the approach` `#include ``using` `namespace` `std;` `int` `main() {` `    ``// Number of cities``    ``int` `n = 4;` `    ``// Matrix holding time such that time[i][j]``    ``// denotes time taken to reach from i``    ``// to j  city``    ``int` `time`` = { { 0, 2, 1, 4 },``                     ``{ 1, 0, 4, 1 },``                     ``{ 3, 1, 0, 3 },``                     ``{ 1, 1, 1, 0 } };` `    ``// Number of queries``    ``int` `m = 2;` `    ``// Arrays containing Number of city as``    ``// source, destination and intermediate``    ``int` `source[] = { 1, 0 };``    ``int` `intermediate[] = { 2, 2 };``    ``int` `destination[] = { 3, 1 };` `    ``// Nested loop for all pair shortest paths``    ``// from i city to j city having shortest``    ``// intermediate city k``    ``for` `(``int` `k = 0; k < n; k++) {``        ``for` `(``int` `i = 0; i < n; i++) {``            ``for` `(``int` `j = 0; j < n; j++) {``                ``time``[i][j] = min(``time``[i][j], ``time``[i][k] + ``time``[k][j]);``            ``}``        ``}``    ``}` `    ``// Loop for number of queries``    ``for` `(``int` `i = 0; i < m; i++) {` `        ``// Variables containing source,``        ``// intermediate an   destination``        ``// cities for per query``        ``int` `s = source[i];``        ``int` `in = intermediate[i];``        ``int` `d = destination[i];` `        ``// Time taken if source to destination``        ``// reached with intermediate city``        ``int` `withIntermediate = ``time``[s][in] + ``time``[in][d];` `        ``// Time taken if source to destination``        ``// reached without intermediate city``        ``int` `withoutIntermediate = withIntermediate - ``time``[s][d];` `        ``// Printing the output``        ``cout << withIntermediate << ``" "` `<< withoutIntermediate << endl;``    ``}``}` `// This code is contributed by Rahul Sharma`

## Java

 `// Java code to implement the approach` `import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG {``    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``        ``throws` `java.lang.Exception``    ``{` `        ``// Number of cities``        ``int` `n = ``4``;` `        ``// Matrix holding time such that time[i][j]``        ``// denotes time taken to reach from i``        ``// to j  city``        ``int``[][] time = { { ``0``, ``2``, ``1``, ``4` `},``                         ``{ ``1``, ``0``, ``4``, ``1` `},``                         ``{ ``3``, ``1``, ``0``, ``3` `},``                         ``{ ``1``, ``1``, ``1``, ``0` `} };` `        ``// Number of queries``        ``int` `m = ``2``;` `        ``// Arrays containing Number of city as``        ``// source, destination and intermediate``        ``int``[] source = { ``1``, ``0` `};``        ``int``[] intermediate = { ``2``, ``2` `};``        ``int``[] destination = { ``3``, ``1` `};` `        ``// Nested loop for all pair shortest paths``        ``// from i city to j city having shortest``        ``// intermediate city k``        ``for` `(``int` `k = ``0``; k < n; k++) {` `            ``for` `(``int` `i = ``0``; i < n; i++) {``                ``for` `(``int` `j = ``0``; j < n; j++) {``                    ``time[i][j] = Integer.min(``                        ``time[i][j],``                        ``time[i][k] + time[k][j]);``                ``}``            ``}``        ``}` `        ``// Loop for number of queries``        ``for` `(``int` `i = ``0``; i < m; i++) {` `            ``// Variables containing source,``            ``// intermediate and destination``            ``// cities for per query``            ``int` `s = source[i];``            ``int` `in = intermediate[i];``            ``int` `d = destination[i];` `            ``// Time taken if source to destination``            ``// reached with intermediate city``            ``int` `withIntermediate``                ``= time[s][in] + time[in][d];` `            ``// Time taken if source to destination``            ``// reached without intermediate city``            ``int` `withoutIntermediate``                ``= withIntermediate - time[s][d];` `            ``// Printing the output``            ``System.out.println(withIntermediate + ``" "``                               ``+ withoutIntermediate);``        ``}``    ``}``}`

## Python3

 `import` `sys``import` `math` `# Number of cities``n ``=` `4` `# Matrix holding time such that time[i][j]``# denotes time taken to reach from i to j city``time ``=` `[[``0``, ``2``, ``1``, ``4``],``        ``[``1``, ``0``, ``4``, ``1``],``        ``[``3``, ``1``, ``0``, ``3``],``        ``[``1``, ``1``, ``1``, ``0``]]` `# Number of queries``m ``=` `2` `# Arrays containing Number of city as``# source, destination, and intermediate``source ``=` `[``1``, ``0``]``intermediate ``=` `[``2``, ``2``]``destination ``=` `[``3``, ``1``]` `# Nested loop for all pair shortest paths``# from i city to j city having shortest``# intermediate city k``for` `k ``in` `range``(n):``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(n):``            ``time[i][j] ``=` `min``(time[i][j],``                             ``time[i][k] ``+` `time[k][j])` `# Loop for number of queries``for` `i ``in` `range``(m):` `    ``# Variables containing source,``    ``# intermediate and destination``    ``# cities for per query``    ``s ``=` `source[i]``    ``in_ ``=` `intermediate[i]``    ``d ``=` `destination[i]` `    ``# Time taken if source to destination``    ``# reached with intermediate city``    ``with_intermediate ``=` `time[s][in_] ``+` `time[in_][d]` `    ``# Time taken if source to destination``    ``# reached without intermediate city``    ``without_intermediate ``=` `with_intermediate ``-` `time[s][d]` `    ``# Printing the output``    ``print``(with_intermediate, without_intermediate)`

## C#

 `using` `System;` `class` `GFG``{``    ``// Driver Code``    ``static` `void` `Main(``string``[] args)``    ``{``        ``// Number of cities``        ``int` `n = 4;` `        ``// Matrix holding time such that time[i][j]``        ``// denotes time taken to reach from i``        ``// to j city``        ``int``[,] time = {{0, 2, 1, 4},``                       ``{1, 0, 4, 1},``                       ``{3, 1, 0, 3},``                       ``{1, 1, 1, 0}};` `        ``// Number of queries``        ``int` `m = 2;` `        ``// Arrays containing Number of city as``        ``// source, destination and intermediate``        ``int``[] source = {1, 0};``        ``int``[] intermediate = {2, 2};``        ``int``[] destination = {3, 1};` `        ``// Nested loop for all pair shortest paths``        ``// from i city to j city having shortest``        ``// intermediate city k``        ``for` `(``int` `k = 0; k < n; k++)``        ``{``            ``for` `(``int` `i = 0; i < n; i++)``            ``{``                ``for` `(``int` `j = 0; j < n; j++)``                ``{``                    ``time[i, j] = Math.Min(``                        ``time[i, j],``                        ``time[i, k] + time[k, j]);``                ``}``            ``}``        ``}` `        ``// Loop for number of queries``        ``for` `(``int` `i = 0; i < m; i++)``        ``{``            ``// Variables containing source,``            ``// intermediate and destination``            ``// cities for per query``            ``int` `s = source[i];``            ``int` `in` `= intermediate[i];``            ``int` `d = destination[i];` `            ``// Time taken if source to destination``            ``// reached with intermediate city``            ``int` `withIntermediate``                ``= time[s, ``in``] + time[``in``, d];` `            ``// Time taken if source to destination``            ``// reached without intermediate city``            ``int` `withoutIntermediate``                ``= withIntermediate - time[s, d];` `            ``// Printing the output``            ``Console.WriteLine(withIntermediate + ``" "` `+``                              ``withoutIntermediate);``        ``}``    ``}``}`

## Javascript

 `function` `GFG() {` `    ``// Number of cities``    ``var` `n = 4;` `    ``// Matrix holding time such that time[i][j]``    ``// denotes time taken to reach from i``    ``// to j  city``    ``var` `time = [ [0, 2, 1, 4],``                 ``[1, 0, 4, 1],``                 ``[3, 1, 0, 3],``                 ``[1, 1, 1, 0] ];` `    ``// Number of queries``    ``var` `m = 2;` `    ``// Arrays containing Number of city as``    ``// source, destination and intermediate``    ``var` `source = [1, 0];``    ``var` `intermediate = [2, 2];``    ``var` `destination = [3, 1];` `    ``// Nested loop for all pair shortest paths``    ``// from i city to j city having shortest``    ``// intermediate city k``    ``for` `(``var` `k = 0; k < n; k++) {` `        ``for` `(``var` `i = 0; i < n; i++) {``            ``for` `(``var` `j = 0; j < n; j++) {``                ``time[i][j] = Math.min(time[i][j], time[i][k] + time[k][j]);``            ``}``        ``}``    ``}` `    ``// Loop for number of queries``    ``for` `(``var` `i = 0; i < m; i++) {` `        ``// Variables containing source,``        ``// intermediate and destination``        ``// cities for per query``        ``var` `s = source[i];``        ``var` `in` `= intermediate[i];``        ``var` `d = destination[i];` `        ``// Time taken if source to destination``        ``// reached with intermediate city``        ``var` `withIntermediate = time[s][``in``] + time[``in``][d];` `        ``// Time taken if source to destination``        ``// reached without intermediate city``        ``var` `withoutIntermediate = withIntermediate - time[s][d];` `        ``// Printing the output``        ``console.log(withIntermediate + ``" "` `+ withoutIntermediate);``    ``}``}` `// Call the GFG function``GFG();`

Output

```4 3
2 0```

Time Complexity: O(N3)
Auxiliary Space:  O(N^2), where n is the number of cities. This is because the program uses a 2D array of size n x n to store the time taken to travel between each pair of cities.

Related Articles:

My Personal Notes arrow_drop_up