Skip to content
Related Articles

Related Articles

Improve Article

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 <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)
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
Recommended Articles
Page :