Related Articles
Path from a given source to a given destination having Kth largest weight in a Graph
• Difficulty Level : Basic
• Last Updated : 17 Mar, 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 {`` ` `    ``// Intializing 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)

My Personal Notes arrow_drop_up