Related Articles

# Path from a given source to a given destination having Kth largest weight in a Graph

• Difficulty Level : Basic
• Last Updated : 11 Aug, 2021

Given a weighted graph consisting of N nodes and M edges, a source vertex, a destination vertex, and an integer K, the task is to find the path with Kth largest weight from source to destination in the graph.

Examples:

Input: N = 7, M = 8, source = 0, destination = 6, K = 3, Edges[][] = {{0, 1, 10}, {1, 2, 10}, {2, 3, 10}, {0, 3, 40}, {3, 4, 2}, {4, 5, 3}, {5, 6, 3}, {4, 6, 8}, {2, 5, 5}}
Output: 0 1 2 3 4 6
Explanation: A total of 4 paths exists from the source to the destination:
Path: 0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6. Weight = 38.
Path: 0 ->1 -> 2 -> 3 -> 6. Weight = 40.
Path: 0 -> 3 -> 4 -> 5 -> 6. Weight = 48.
Path: 0 -> 3 -> 4 -> 6. Weight = 50.
The 3rd largest weighted path is the path with weight 40. Hence, the path having weight 40 is the output.

Input: N = 2, M = 1, source = 0, destination = 1, K = 1, Edges[][] = {{0 1 25}},
Output: 0 1

Approach: The given problem can be solved by finding all the paths from a given source to a destination and using a Priority Queue to find the Kth largest weight. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.util.*;` `// Edge class represents a source,``// destination, weight of the edge``class` `Edge {` `    ``// Source``    ``int` `src;` `    ``// Destination``    ``int` `nbr;` `    ``// Weight``    ``int` `wt;` `    ``// Constructor to create an Edge``    ``Edge(``int` `src, ``int` `nbr, ``int` `wt)``    ``{``        ``this``.src = src;``        ``this``.nbr = nbr;``        ``this``.wt = wt;``    ``}``}` `// Pair class``class` `Pair ``implements` `Comparable {` `    ``// Weight so far``    ``int` `wsf;` `    ``// Path so far``    ``String psf;` `    ``// Constructor to create a Pair``    ``Pair(``int` `wsf, String psf)``    ``{``        ``this``.wsf = wsf;``        ``this``.psf = psf;``    ``}` `    ``// Function to sort in increasing``    ``// order of weights``    ``public` `int` `compareTo(Pair o)``    ``{``        ``return` `this``.wsf - o.wsf;``    ``}``}` `class` `GFG {` `    ``// Initializing the priority queue``    ``static` `PriorityQueue pq``        ``= ``new` `PriorityQueue<>();` `    ``// Function to find the path from src to``    ``// dest with Kth largest weight in the graph``    ``public` `static` `void` `kthLargest(``        ``ArrayList[] graph,``        ``int` `src, ``int` `dest,``        ``boolean``[] visited, ``int` `k,``        ``String psf, ``int` `wsf)``    ``{``        ``// Base Case: When the``        ``// destination has been reached``        ``if` `(src == dest) {` `            ``// If pq has at most K elements``            ``if` `(pq.size() < k) {``                ``pq.add(``new` `Pair(wsf, psf));``            ``}` `            ``else` `if` `(wsf > pq.peek().wsf) {``                ``pq.remove();``                ``pq.add(``new` `Pair(wsf, psf));``            ``}` `            ``return``;``        ``}` `        ``// Mark the source node as visited``        ``visited[src] = ``true``;` `        ``// Iterating over all``        ``// the neighbours of src``        ``for` `(Edge e : graph[src]) {` `            ``// If neighbour is not visited``            ``if` `(!visited[e.nbr]) {` `                ``kthLargest(graph, e.nbr,``                           ``dest, visited,``                           ``k, psf + e.nbr,``                           ``wsf + e.wt);``            ``}``        ``}` `        ``// Mark src as unvisited``        ``visited[src] = ``false``;``    ``}` `    ``// Function to add edges``    ``public` `static` `void` `addEdges(``        ``ArrayList[] graph)``    ``{``        ``// Adding a bidirectional edge``        ``graph[``0``].add(``new` `Edge(``0``, ``1``, ``10``));``        ``graph[``1``].add(``new` `Edge(``1``, ``0``, ``10``));` `        ``graph[``1``].add(``new` `Edge(``1``, ``2``, ``10``));``        ``graph[``2``].add(``new` `Edge(``2``, ``1``, ``10``));` `        ``graph[``2``].add(``new` `Edge(``2``, ``3``, ``10``));``        ``graph[``3``].add(``new` `Edge(``3``, ``2``, ``10``));` `        ``graph[``0``].add(``new` `Edge(``0``, ``3``, ``40``));``        ``graph[``3``].add(``new` `Edge(``3``, ``0``, ``40``));` `        ``graph[``3``].add(``new` `Edge(``3``, ``4``, ``2``));``        ``graph[``4``].add(``new` `Edge(``4``, ``3``, ``2``));` `        ``graph[``4``].add(``new` `Edge(``4``, ``5``, ``3``));``        ``graph[``5``].add(``new` `Edge(``5``, ``4``, ``3``));` `        ``graph[``5``].add(``new` `Edge(``5``, ``6``, ``3``));``        ``graph[``6``].add(``new` `Edge(``6``, ``5``, ``3``));` `        ``graph[``4``].add(``new` `Edge(``4``, ``6``, ``8``));``        ``graph[``6``].add(``new` `Edge(``6``, ``4``, ``8``));``    ``}` `    ``// Utility function to find the``    ``// path with Kth largest weight``    ``public` `static` `void` `kthLargestPathUtil(``        ``int` `N, ``int` `M, ``int` `src,``        ``int` `dest, ``int` `k)``    ``{``        ``@SuppressWarnings``(``"unchecked"``)` `        ``// Arraylist to store edges``        ``ArrayList[] graph``            ``= ``new` `ArrayList[``2` `* N];` `        ``for` `(``int` `i = ``0``; i < ``2` `* N; i++) {``            ``graph[i] = ``new` `ArrayList<>();``        ``}` `        ``// Function to add edges``        ``addEdges(graph);` `        ``// Stores if a vertex is visited or not``        ``boolean``[] visited = ``new` `boolean``[N];` `        ``kthLargest(graph, src, dest,``                   ``visited, k, src + ``""``,``                   ``0``);` `        ``// Stores the kth largest weighted path``        ``String path = pq.peek().psf;` `        ``// Traversing path string``        ``for` `(``int` `i = ``0``;``             ``i < path.length(); i++) {``            ``System.out.print(``                ``path.charAt(i) + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// No of vertices and Edges``        ``int` `N = ``7``, M = ``8``;` `        ``// Source vertex``        ``int` `src = ``0``;` `        ``// Destination vertex``        ``int` `dest = ``6``;``        ``int` `k = ``3``;` `        ``kthLargestPathUtil(N, M, src,``                           ``dest, k);``    ``}``}`

Time Complexity: O(V + E)
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