Related Articles

# Path with smallest product of edges with weight >= 1

• Last Updated : 13 Aug, 2021

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:
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:
1. Pop the top-most element from pq. Let’s call it as curr and its product of distance as dist.
2. If curr is already visited then continue.
3. If curr is equal to D then return dist.
4. 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 ``using` `namespace` `std;` `// Function to return the smallest``// product of edges``double` `dijkstra(``int` `s, ``int` `d,``                ``vector > > gr)``{``    ``// If the source is equal``    ``// to the destination``    ``if` `(s == d)``        ``return` `0;` `    ``// Initialise the priority queue``    ``set > 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 > > gr(n + 1);` `    ``// Input edges``    ``gr.push_back({ 3, 9 });``    ``gr.push_back({ 3, 1 });``    ``gr.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``{``    ``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> gr)``{``    ` `    ``// If the source is equal``    ``// to the destination``    ``if` `(s == d)``        ``return` `0``;` `    ``// Initialise the priority queue``    ``PriorityQueue 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> gr = ``new` `ArrayList<>();``    ``for``(``int` `i = ``0``; i < n + ``1``; i++)``    ``{``        ``gr.add(``new` `ArrayList());``    ``}` `    ``// 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`
Output:
`5`

Time complexity: O((E + V) logV)
Auxiliary Space: O(V).

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.

My Personal Notes arrow_drop_up