Minimum cost of path between given nodes containing at most K nodes in a directed and weighted graph
Given a directed weighted graph represented by a 2-D array graph[][] of size n and 3 integers src, dst, and k representing the source point, destination point, and the available number of stops. The task is to minimize the cost of the path between two nodes containing at most K nodes in a directed and weighted graph. If there is no such route, return -1.
Examples:
Input: n=6, graph[][] = [[0, 1, 10], [1, 2, 20], [1, 3, 10], [2, 5, 30], [3, 4, 10], [4, 5, 10]], src=0, dst=5, k=2
Output: 60
Explanation:
Src = 0, Dst = 5 and k = 2
There can be a route marked with a green arrow that takes cost = 10+10+10+10=40 using three stops. And route marked with red arrow takes cost = 10+20+30=60 using two stops. But since there can be at most 2 stops, the answer will be 60.
Input: n=3, graph[][] = [[0, 1, 10], [0, 2, 50], [1, 2, 10], src=0, dst=2, k=1
Output: 20
Explanation:
Src=0 and Dst=2
Since the k is 1, then the green-colored path can be taken with a minimum cost of 20.
Approach: Increase k by 1 because on reaching the destination, k+1 stops will be consumed. Use Breadth-first search to run while loop till the queue becomes empty. At each time pop out all the elements from the queue and decrease k by 1 and check-in their adjacent list of elements and check they are not visited before or their cost is greater than the cost of parent node + cost of that node, then mark their prices by prices[parent] + cost of that node. If k becomes 0 then break the while loop because either cost is calculated or we consumed k+1 stops. Follow the steps below to solve the problem:
- Increase the value of k by 1.
- Initialize a vector of pair adj[n] and construct the adjacency list for the graph.
- Initialize a vector prices[n] with values -1.
- Initialize a queue of pair q[].
- Push the pair {src, 0} into the queue and set the value of prices[0] as 0.
- Traverse in a while loop until the queue becomes empty and perform the following steps:
- If k equals 0 then break.
- Initialize the variable sz as the size of the queue.
- Traverse in a while loop until sz is greater than 0 and perform the following tasks:
- Initialize the variables node as the first value of the front pair of the queue and cost as the second value of the front pair of the queue.
- Iterate over the range [0, adj[node].size()) using the variable it and perform the following tasks:
- If prices[it.first] equals -1 or cost + it.second is less than prices[it.first] then set the value of prices[it.first] as cost + it.second and push the pair {it.first, cost + it.second} into the queue.
- Reduce the value of k by 1.
- After performing the above steps, print the value of prices[dst] as the answer.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int findCheapestCost( int n,
vector<vector< int > >& graph,
int src, int dst, int k)
{
if (dst > n)
return -1;
k = k + 1;
vector<pair< int , int > > adj[n];
for ( auto it : graph) {
adj[it[0]].push_back({ it[1], it[2] });
}
vector< int > prices(n, -1);
queue<pair< int , int > > q;
q.push({ src, 0 });
prices[src] = 0;
while (!q.empty()) {
if (k == 0)
break ;
int sz = q.size();
while (sz--) {
int node = q.front().first;
int cost = q.front().second;
q.pop();
for ( auto it : adj[node]) {
if (prices[it.first] == -1
or cost + it.second
< prices[it.first]) {
prices[it.first] = cost + it.second;
q.push({ it.first, cost + it.second });
}
}
}
k--;
}
return prices[dst];
}
int main()
{
int n = 6;
vector<vector< int > > graph
= { { 0, 1, 10 }, { 1, 2, 20 }, { 2, 5, 30 }, { 1, 3, 10 }, { 3, 4, 10 }, { 4, 5, 10 } };
int src = 0;
int dst = 5;
int k = 2;
cout << findCheapestCost(n, graph, src, dst, k)
<< endl;
return 0;
}
|
Java
import java.util.*;
public class GFG{
static class pair
{
int first, second;
public pair( int first, int second)
{
this .first = first;
this .second = second;
}
}
static int findCheapestCost( int n,
int [][] graph,
int src, int dst, int k)
{
if (dst > n)
return - 1 ;
k = k + 1 ;
Vector<pair> []adj = new Vector[n];
for ( int i = 0 ; i < adj.length; i++)
adj[i] = new Vector<pair>();
for ( int it[] : graph) {
adj[it[ 0 ]].add( new pair( it[ 1 ], it[ 2 ] ));
}
int []prices = new int [n];
Arrays.fill(prices, - 1 );
Queue<pair > q = new LinkedList<>();
q.add( new pair( src, 0 ));
prices[src] = 0 ;
while (!q.isEmpty()) {
if (k == 0 )
break ;
int sz = q.size();
while (sz-- > 0 ) {
int node = q.peek().first;
int cost = q.peek().second;
q.remove();
for (pair it : adj[node]) {
if (prices[it.first] == - 1
|| cost + it.second
< prices[it.first]) {
prices[it.first] = cost + it.second;
q.add( new pair( it.first, cost + it.second ));
}
}
}
k--;
}
return prices[dst];
}
public static void main(String[] args)
{
int n = 6 ;
int [][] graph
= { { 0 , 1 , 10 }, { 1 , 2 , 20 }, { 2 , 5 , 30 }, { 1 , 3 , 10 }, { 3 , 4 , 10 }, { 4 , 5 , 10 } };
int src = 0 ;
int dst = 5 ;
int k = 2 ;
System.out.print(findCheapestCost(n, graph, src, dst, k)
+ "\n" );
}
}
|
Python3
from collections import deque
def findCheapestCost(n, graph, src, dst, k):
if dst > n:
return - 1 ;
k = k + 1
adj = [[] for _ in range (n)]
for it in graph:
adj[it[ 0 ]].append([it[ 1 ], it[ 2 ]])
prices = [ - 1 for _ in range (n)]
q = deque()
q.append([src, 0 ])
prices[src] = 0
while ( len (q) ! = 0 ):
if (k = = 0 ):
break
sz = len (q)
while ( True ):
sz - = 1
pr = q.popleft()
node = pr[ 0 ]
cost = pr[ 1 ]
for it in adj[node]:
if (prices[it[ 0 ]] = = - 1
or cost + it[ 1 ]
< prices[it[ 0 ]]):
prices[it[ 0 ]] = cost + it[ 1 ]
q.append([it[ 0 ], cost + it[ 1 ]])
if sz = = 0 :
break
k - = 1
return prices[dst]
if __name__ = = "__main__" :
n = 6
graph = [
[ 0 , 1 , 10 ],
[ 1 , 2 , 20 ],
[ 2 , 5 , 30 ],
[ 1 , 3 , 10 ],
[ 3 , 4 , 10 ],
[ 4 , 5 , 10 ]]
src = 0
dst = 5
k = 2
print (findCheapestCost(n, graph, src, dst, k))
|
C#
using System;
using System.Collections.Generic;
class Program
{
public static int findCheapestCost( int n, int [,] graph, int src, int dst, int k)
{
if (dst > n)
{
return -1;
}
k = k + 1;
List<List< int []>> adj = new List<List< int []>>();
for ( int i = 0; i < n; i++)
{
adj.Add( new List< int []>());
}
for ( int i = 0; i < graph.GetLength(0); i++)
{
adj[graph[i, 0]].Add( new int [] { graph[i, 1], graph[i, 2] });
}
int [] prices = new int [n];
for ( int i = 0; i < n; i++)
{
prices[i] = -1;
}
Queue< int []> q = new Queue< int []>();
q.Enqueue( new int [] { src, 0 });
prices[src] = 0;
while (q.Count != 0)
{
if (k == 0)
{
break ;
}
int sz = q.Count;
while (sz-- > 0)
{
int [] pr = q.Dequeue();
int node = pr[0];
int cost = pr[1];
foreach ( int [] it in adj[node])
{
if (prices[it[0]] == -1
|| cost + it[1] < prices[it[0]])
{
prices[it[0]] = cost + it[1];
q.Enqueue( new int [] { it[0], cost + it[1] });
}
}
}
k--;
}
return prices[dst];
}
public static void Main()
{
int n = 6;
int [,] graph = {
{0, 1, 10},
{1, 2, 20},
{2, 5, 30},
{1, 3, 10},
{3, 4, 10},
{4, 5, 10}
};
int src = 0;
int dst = 5;
int k = 2;
Console.WriteLine(findCheapestCost(n, graph, src, dst, k));
}
}
|
Javascript
function findCheapestCost(n, graph, src, dst, k) {
if (dst > n) {
return -1;
}
k = k + 1;
let adj = Array.from({ length: n }, () => []);
for (let i = 0; i < graph.length; i++) {
adj[graph[i][0]].push([graph[i][1], graph[i][2]]);
}
let prices = Array.from({ length: n }, () => -1);
let q = [];
q.push([src, 0]);
prices[src] = 0;
while (q.length != 0) {
if (k == 0) {
break ;
}
let sz = q.length;
while (sz > 0) {
sz -= 1;
let pr = q.shift();
let node = pr[0];
let cost = pr[1];
for (let i = 0; i < adj[node].length; i++) {
let it = adj[node][i];
if (prices[it[0]] == -1 || cost + it[1] < prices[it[0]]) {
prices[it[0]] = cost + it[1];
q.push([it[0], cost + it[1]]);
}
}
if (sz == 0) {
break ;
}
}
k -= 1;
}
return prices[dst];
}
let n = 6;
let graph = [ [0, 1, 10],
[1, 2, 20],
[2, 5, 30],
[1, 3, 10],
[3, 4, 10],
[4, 5, 10],
];
let src = 0;
let dst = 5;
let k = 2;
console.log(findCheapestCost(n, graph, src, dst, k));
|
Time Complexity: O(n*k)
Auxiliary Space: O(n)
Last Updated :
20 Feb, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...