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[1][0] + M[0][2] + M[2][1] + M[1][3] = 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][3] = 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[0][2] + M[2][1] = 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[0][1] = 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[4][4] = { { 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 sysimport math # Number of citiesn = 4 # Matrix holding time such that time[i][j]# denotes time taken to reach from i to j citytime = [[0, 2, 1, 4],        [1, 0, 4, 1],        [3, 1, 0, 3],        [1, 1, 1, 0]] # Number of queriesm = 2 # Arrays containing Number of city as# source, destination, and intermediatesource = [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 kfor 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 queriesfor 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 functionGFG();

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