Given a directed graph with N nodes and E edges where the weight of each of the edge is > 1, also given a source S and a destination D. The task is to find the path with the minimum product of edges from S to D. If there is no path from S to D then print -1.
Examples:
Input: N = 3, E = 3, Edges = {{{1, 2}, 5}, {{1, 3}, 9}, {{2, 3}, 1}}, S = 1, and D = 3
Output: 5
The path with smallest product of edges will be 1->2->3
with product as 5*1 = 5.Input: N = 3, E = 3, Edges = {{{3, 2}, 5}, {{3, 3}, 9}, {{3, 3}, 1}}, S = 1, and D = 3
Output: -1
Approach: The idea is to use Dijkstra’s shortest path algorithm with a slight variation.
The following steps can be followed to compute the result:
- If the source is equal to the destination then return 0.
- Initialise a priority-queue pq with S and its weight as 1 and a visited array v[].
- While pq is not empty:
- Pop the top-most element from pq. Let’s call it as curr and its product of distance as dist.
- If curr is already visited then continue.
- If curr is equal to D then return dist.
- Iterate all the nodes adjacent to curr and push into pq (next and dist + gr[nxt].weight)
- return -1.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std; // Function to return the smallest // product of edges double dijkstra( int s, int d, vector<vector<pair< int , double > > > gr) { // If the source is equal // to the destination if (s == d) return 0; // Initialise the priority queue set<pair< int , int > > pq; pq.insert({ 1, s }); // Visited array bool v[gr.size()] = { 0 }; // While the priority-queue // is not empty while (pq.size()) { // Current node int curr = pq.begin()->second; // Current product of distance int dist = pq.begin()->first; // Popping the top-most element pq.erase(pq.begin()); // If already visited continue if (v[curr]) continue ; // Marking the node as visited v[curr] = 1; // If it is a destination node if (curr == d) return dist; // Traversing the current node for ( auto it : gr[curr]) pq.insert({ dist * it.second, it.first }); } // If no path exists return -1; } // Driver code int main() { int n = 3; // Graph as adjacency matrix vector<vector<pair< int , double > > > gr(n + 1); // Input edges gr[1].push_back({ 3, 9 }); gr[2].push_back({ 3, 1 }); gr[1].push_back({ 2, 5 }); // Source and destination int s = 1, d = 3; // Dijkstra cout << dijkstra(s, d, gr); return 0; } |
Java
// Java implementation of the approach import java.util.ArrayList; import java.util.PriorityQueue; class Pair implements Comparable<Pair> { int first, second; public Pair( int first, int second) { this .first = first; this .second = second; } public int compareTo(Pair o) { if ( this .first == o.first) { return this .second - o.second; } return this .first - o.first; } } class GFG{ // Function to return the smallest // xor sum of edges static int dijkstra( int s, int d, ArrayList<ArrayList<Pair>> gr) { // If the source is equal // to the destination if (s == d) return 0 ; // Initialise the priority queue PriorityQueue<Pair> pq = new PriorityQueue<>(); pq.add( new Pair( 1 , s)); // Visited array boolean [] v = new boolean [gr.size()]; // While the priority-queue // is not empty while (!pq.isEmpty()) { // Current node Pair p = pq.poll(); int curr = p.second; // Current xor sum of distance int dist = p.first; // If already visited continue if (v[curr]) continue ; // Marking the node as visited v[curr] = true ; // If it is a destination node if (curr == d) return dist; // Traversing the current node for (Pair it : gr.get(curr)) pq.add( new Pair(dist ^ it.second, it.first)); } // If no path exists return - 1 ; } // Driver code public static void main(String[] args) { int n = 3 ; // Graph as adjacency matrix ArrayList<ArrayList<Pair>> gr = new ArrayList<>(); for ( int i = 0 ; i < n + 1 ; i++) { gr.add( new ArrayList<Pair>()); } // Input edges gr.get( 1 ).add( new Pair( 3 , 9 )); gr.get( 2 ).add( new Pair( 3 , 1 )); gr.get( 1 ).add( new Pair( 2 , 5 )); // Source and destination int s = 1 , d = 3 ; System.out.println(dijkstra(s, d, gr)); } } // This code is contributed by sanjeev2552 |
Python3
# Python3 implementation of the approach # Function to return the smallest # product of edges def dijkstra(s, d, gr) : # If the source is equal # to the destination if (s = = d) : return 0 ; # Initialise the priority queue pq = []; pq.append(( 1 , s )); # Visited array v = [ 0 ] * ( len (gr) + 1 ); # While the priority-queue # is not empty while ( len (pq) ! = 0 ) : # Current node curr = pq[ 0 ][ 1 ]; # Current product of distance dist = pq[ 0 ][ 0 ]; # Popping the top-most element pq.pop(); # If already visited continue if (v[curr]) : continue ; # Marking the node as visited v[curr] = 1 ; # If it is a destination node if (curr = = d) : return dist; # Traversing the current node for it in gr[curr] : if it not in pq : pq.insert( 0 ,( dist * it[ 1 ], it[ 0 ] )); # If no path exists return - 1 ; # Driver code if __name__ = = "__main__" : n = 3 ; # Graph as adjacency matrix gr = {}; # Input edges gr[ 1 ] = [( 3 , 9 ) ]; gr[ 2 ] = [ ( 3 , 1 ) ]; gr[ 1 ].append(( 2 , 5 )); gr[ 3 ] = []; #print(gr); # Source and destination s = 1 ; d = 3 ; # Dijkstra print (dijkstra(s, d, gr)); # This code is contributed by AnkitRai01 |
5
Time complexity: O((E + V) logV)
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.