# 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 = 3Output: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 = 3Output:-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)

- Pop the top-most element from
- 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` |

**Output:**

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**.