Minimum Cost of Simple Path between two nodes in a Directed and Weighted Graph

27 May, 2021
Given a directed graph, which may contain cycles, where every edge has weight, the task is to find the minimum cost of any simple path from a given source vertex ‘s’ to a given destination vertex ‘t’. Simple Path is the path from one vertex to another such that no vertex is visited more than once. If there is no simple path possible then return INF(infinite).
The graph is given as adjacency matrix representation where value of graph[i][j] indicates the weight of an edge from vertex i to vertex j and a value INF(infinite) indicates no edge from i to j.
Examples:
Input : V = 5, E = 6
        s = 0, t = 2
    graph[][] =      0   1   2   3   4  
                 0  INF -1  INF  1  INF
                 1  INF INF -2  INF INF
                 2  -3  INF INF INF INF
                 3  INF INF -1  INF INF
                 4  INF INF INF  2  INF
 
Output : -3 
Explanation : 
The minimum cost simple path between 0 and 2 is given by:
0 -----> 1 ------> 2 whose cost is (-1) + (-2) = (-3). 

Input : V = 5, E = 6
        s = 0, t = 4
    graph[][] =      0   1   2   3   4  
                 0  INF -7  INF -2  INF
                 1  INF INF -11 INF INF
                 2  INF INF INF INF INF
                 3  INF INF INF  3  -4
                 4  INF INF INF INF INF
 
Output : -6
Explanation : 
The minimum cost simple path between 0 and 2 is given by:
0 -----> 3 ------> 4 whose cost is (-2) + (-4) = (-6). 
Approach :The main idea to solve the above problem is to traverse through all simple paths from s to t using a modified version of Depth First Search and find the minimum cost path amongst them. One important observation about DFS is that it traverses one path at a time, hence we can traverse separate paths independently using DFS by marking the nodes as unvisited before leaving them.A simple solution is to start from s, go to all adjacent vertices, and follow recursion for further adjacent vertices until we reach the destination. This algorithm will work even when negative weight cycles or self edges are present in the graph.
Below is the implementation of the above-mentioned approach: 
C++
Java
Python3
C#
Javascript
// C++ code for printing Minimum Cost// Simple Path between two given nodes// in a directed and weighted graph#include <bits/stdc++.h>using namespace std; // Define number of vertices in// the graph and infinite value#define V 5#define INF INT_MAX // Function to do DFS through the nodesint minimumCostSimplePath(int u, int destination,                    bool visited[], int graph[][V]){     // check if we find the destination    // then further cost will be 0    if (u == destination)        return 0;     // marking the current node as visited    visited[u] = 1;     int ans = INF;     // traverse through all    // the adjacent nodes    for (int i = 0; i < V; i++) {        if (graph[u][i] != INF && !visited[i]) {             // cost of the further path            int curr = minimumCostSimplePath(i,                        destination, visited, graph);             // check if we have reached the destination            if (curr < INF) {                 // Taking the minimum cost path                ans = min(ans, graph[u][i] + curr);            }        }    }     // unmarking the current node    // to make it available for other    // simple paths    visited[u] = 0;     // returning the minimum cost    return ans;} // driver codeint main(){     // initialising the graph    int graph[V][V];    for (int i = 0; i < V; i++) {        for (int j = 0; j < V; j++) {            graph[i][j] = INF;        }    }     // marking all nodes as unvisited    bool visited[V] = { 0 };     // initialising the edges;    graph[0][1] = -1;    graph[0][3] = 1;    graph[1][2] = -2;    graph[2][0] = -3;    graph[3][2] = -1;    graph[4][3] = 2;     // source and destination    int s = 0, t = 2;     // marking the source as visited    visited[s] = 1;     cout << minimumCostSimplePath(s, t,                            visited, graph);     return 0;}
// Java code for printing Minimum Cost// Simple Path between two given nodes// in a directed and weighted graphimport java.util.*;import java.lang.*; class GFG{     // Define number of vertices in// the graph and infinite valuestatic int V = 5;static int INF = Integer.MAX_VALUE; // Function to do DFS through the nodesstatic int minimumCostSimplePath(int u, int destination,                                 boolean visited[],                                 int graph[][]){         // Check if we find the destination    // then further cost will be 0    if (u == destination)        return 0;             // Marking the current node as visited    visited[u] = true;     int ans = INF;     // Traverse through all    // the adjacent nodes    for(int i = 0; i < V; i++)    {        if (graph[u][i] != INF && !visited[i])        {                         // Cost of the further path            int curr = minimumCostSimplePath(i,                        destination, visited, graph);             // Check if we have reached the            // destination            if (curr < INF)            {                                 // Taking the minimum cost path                ans = Math.min(ans, graph[u][i] + curr);            }        }    }     // Unmarking the current node    // to make it available for other    // simple paths    visited[u] = false;     // Returning the minimum cost    return ans;}   // Driver codepublic static void main(String[] args){         // Initialising the graph    int graph[][] = new int[V][V];    for(int i = 0; i < V; i++)    {        for(int j = 0; j < V; j++)        {            graph[i][j] = INF;        }    }         // Marking all nodes as unvisited    boolean visited[] = new boolean[V];         // Initialising the edges;    graph[0][1] = -1;    graph[0][3] = 1;    graph[1][2] = -2;    graph[2][0] = -3;    graph[3][2] = -1;    graph[4][3] = 2;         // Source and destination    int s = 0, t = 2;         // Marking the source as visited    visited[s] = true;         System.out.println(minimumCostSimplePath(s, t,                            visited, graph));}} // This code is contributed by offbeat
# Python3 code for printing Minimum Cost# Simple Path between two given nodes# in a directed and weighted graphimport sys V = 5INF = sys.maxsize  # Function to do DFS through the nodesdef minimumCostSimplePath(u, destination,                          visited, graph):     # Check if we find the destination    # then further cost will be 0    if (u == destination):        return 0      # Marking the current node as visited    visited[u] = 1      ans = INF      # Traverse through all    # the adjacent nodes    for i in range(V):        if (graph[u][i] != INF and not visited[i]):              # Cost of the further path            curr = minimumCostSimplePath(i, destination,                                         visited, graph)              # Check if we have reached the destination            if (curr < INF):                  # Taking the minimum cost path                ans = min(ans, graph[u][i] + curr)                 # Unmarking the current node    # to make it available for other    # simple paths    visited[u] = 0      # Returning the minimum cost    return ans     # Driver codeif __name__=="__main__":         # Initialising the graph    graph = [[INF for j in range(V)]                  for i in range(V)]      # Marking all nodes as unvisited    visited = [0 for i in range(V)]      # Initialising the edges    graph[0][1] = -1    graph[0][3] = 1    graph[1][2] = -2    graph[2][0] = -3    graph[3][2] = -1    graph[4][3] = 2         # Source and destination    s = 0    t = 2      # Marking the source as visited    visited[s] = 1         print(minimumCostSimplePath(s, t, visited, graph))  # This code is contributed by rutvik_56
// C# code for printing Minimum Cost// Simple Path between two given nodes// in a directed and weighted graphusing System;using System.Collections;using System.Collections.Generic;class GFG{       // Define number of vertices in    // the graph and infinite value    static int V = 5;    static int INF = int.MaxValue;     // Function to do DFS through the nodes    static int minimumCostSimplePath(int u, int destination,                                     bool[] visited, int[, ] graph)    {               // Check if we find the destination        // then further cost will be 0        if (u == destination)            return 0;         // Marking the current node as visited        visited[u] = true;        int ans = INF;         // Traverse through all        // the adjacent nodes        for (int i = 0; i < V; i++)        {            if (graph[u, i] != INF && !visited[i])            {                               // Cost of the further path                int curr = minimumCostSimplePath(i, destination,                                                 visited, graph);                 // Check if we have reached the                // destination                if (curr < INF)                {                                       // Taking the minimum cost path                    ans = Math.Min(ans, graph[u, i] + curr);                }            }        }         // Unmarking the current node        // to make it available for other        // simple paths        visited[u] = false;         // Returning the minimum cost        return ans;    }     // Driver code    public static void Main(string[] args)    {               // Initialising the graph        int[, ] graph = new int[V, V];        for (int i = 0; i < V; i++)        {            for (int j = 0; j < V; j++)            {                graph[i, j] = INF;            }        }         // Marking all nodes as unvisited        bool[] visited = new bool[V];         // Initialising the edges;        graph[0, 1] = -1;        graph[0, 3] = 1;        graph[1, 2] = -2;        graph[2, 0] = -3;        graph[3, 2] = -1;        graph[4, 3] = 2;         // Source and destination        int s = 0, t = 2;         // Marking the source as visited        visited[s] = true;        Console.WriteLine(minimumCostSimplePath(s, t, visited, graph));    }} // This code is contributed by sanjeev2552
<script> // JavaScript code for printing Minimum Cost// Simple Path between two given nodes// in a directed and weighted graph  // Define number of vertices in// the graph and infinite valuelet V = 5let INF =  Number.MAX_SAFE_INTEGER // Function to do DFS through the nodesfunction minimumCostSimplePath(u, destination, visited, graph){     // check if we find the destination    // then further cost will be 0    if (u == destination)        return 0;     // marking the current node as visited    visited[u] = 1;     let ans = INF;     // traverse through all    // the adjacent nodes    for (let i = 0; i < V; i++) {        if (graph[u][i] != INF && !visited[i]) {             // cost of the further path            let curr = minimumCostSimplePath(i,                        destination, visited, graph);             // check if we have reached the destination            if (curr < INF) {                 // Taking the minimum cost path                ans = Math.min(ans, graph[u][i] + curr);            }        }    }     // unmarking the current node    // to make it available for other    // simple paths    visited[u] = 0;     // returning the minimum cost    return ans;} // driver code      // initialising the graph    let graph = new Array();    for(let i = 0;  i< V; i++){        graph.push([])    }     for (let i = 0; i < V; i++) {        for (let j = 0; j < V; j++) {            graph[i][j] = INF;        }    }     // marking all nodes as unvisited    let visited = new Array(V).fill(0);     // initialising the edges;    graph[0][1] = -1;    graph[0][3] = 1;    graph[1][2] = -2;    graph[2][0] = -3;    graph[3][2] = -1;    graph[4][3] = 2;     // source and destination    let s = 0, t = 2;     // marking the source as visited    visited[s] = 1;     document.write(minimumCostSimplePath(s, t, visited, graph));     // This code is contributed by _saurabh_jaiswal         </script>
-3
 
rutvik_56
offbeat
sanjeev2552
_saurabh_jaiswal
DFS
Arrays
Competitive Programming
Graph
Recursion
Write From Home
Arrays
Recursion
DFS
Graph
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.