Path with smallest product of edges with weight >= 1
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 edgesdouble 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 codeint 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 approachimport 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 edgesstatic 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 codepublic 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 edgesdef 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 codeif __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. 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.
