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

• Difficulty Level : Medium
• Last Updated : 10 Nov, 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`

## Javascript

 ``

Output:

`5`

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

My Personal Notes arrow_drop_up