Given a graph of N Nodes and E edges in form of {U, V, W} such that there exists an edge between U and V with weight W. You are given an integer K and source src and destination dst. The task is to find the cheapest cost path from given source to destination from K stops.
Examples:
Input: N = 3, edges = [[0, 1, 100], [1, 2, 100], [0, 2, 500]], src = 0, dst = 2, k = 1
Output: 200
Explanation:
The Cheapest Price is from City 0 to City 2. With just one stop, it just costs 200 which is our Output.
Input: N = 3, edges = [[0, 1, 100], [1, 2, 100], [0, 2, 500]], src = 0, dst = 2, k = 0
Output: 500
Method 1: Using Depth First Search
- Explore the current node and keep exploring its children.
- Use a map to store the visited node in pair with stops and distance as value.
- Break the recursion tree if the key is present in the map.
- Find the answer (minimum cost) for each recursion tree and return it.
Below is the implementation of our approach.
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Structure to implement hashing to // stores pairs in map struct pair_hash {
template < class T1, class T2>
std:: size_t
operator()( const std::pair<T1, T2>& pair) const
{
return std::hash<T1>()(pair.first)
^ std::hash<T2>()(pair.second);
}
}; // DFS memoization vector<vector< int > > adjMatrix;
typedef std::pair< int , int > pair1;
unordered_map<pair1, int , pair_hash> mp;
// Function to implement DFS Traversal long DFSUtility( int node, int stops,
int dst, int cities)
{ // Base Case
if (node == dst)
return 0;
if (stops < 0) {
return INT_MAX;
}
pair< int , int > key(node, stops);
// Find value with key in a map
if (mp.find(key) != mp.end()) {
return mp[key];
}
long ans = INT_MAX;
// Traverse adjacency matrix of
// source node
for ( int neighbour = 0;
neighbour < cities;
++neighbour) {
long weight
= adjMatrix[node][neighbour];
if (weight > 0) {
// Recursive DFS call for
// child node
long minVal
= DFSUtility(neighbour,
stops - 1,
dst, cities);
if (minVal + weight > 0)
ans = min(ans,
minVal
+ weight);
}
}
mp[key] = ans;
// Return ans
return ans;
} // Function to find the cheapest price // from given source to destination int findCheapestPrice( int cities,
vector<vector< int > >& flights,
int src, int dst, int stops)
{ // Resize Adjacency Matrix
adjMatrix.resize(cities + 1,
vector< int >(cities + 1, 0));
// Traverse flight[][]
for ( auto item : flights) {
// Create Adjacency Matrix
adjMatrix[item[0]][item[1]] = item[2];
}
// DFS Call to find shortest path
long ans = DFSUtility(src, stops,
dst, cities);
// Return the cost
return ans >= INT_MAX ? -1 : ( int )ans;
;
} // Driver Code int main()
{ // Input flight : {Source,
// Destination, Cost}
vector<vector< int > > flights
= { { 4, 1, 1 }, { 1, 2, 3 }, { 0, 3, 2 }, { 0, 4, 10 }, { 3, 1, 1 }, { 1, 4, 3 } };
// vec, n, stops, src, dst
int stops = 2;
int totalCities = 5;
int sourceCity = 0;
int destCity = 4;
// Function Call
long ans = findCheapestPrice(
totalCities, flights,
sourceCity, destCity,
stops);
cout << ans;
return 0;
} |
// Java program for the above approach import java.util.HashMap;
public class SingleS {
// DFS memoization
static int adjMatrix[][];
static HashMap< int [], Integer> mp
= new HashMap< int [], Integer>();
// Function to implement DFS Traversal
static int DFSUtility( int node, int stops, int dst,
int cities)
{
// Base Case
if (node == dst)
return 0 ;
if (stops < 0 )
return Integer.MAX_VALUE;
int [] key = new int [] { node, stops };
// Find value with key in a map
if (mp.containsKey(key))
return mp.get(mp);
int ans = Integer.MAX_VALUE;
// Traverse adjacency matrix of
// source node
for ( int neighbour = 0 ; neighbour < cities;
++neighbour) {
int weight = adjMatrix[node][neighbour];
if (weight > 0 ) {
// Recursive DFS call for
// child node
int minVal = DFSUtility(
neighbour, stops - 1 , dst, cities);
if (minVal + weight > 0 )
ans = Math.min(ans, minVal + weight);
}
mp.put(key, ans);
}
// Return ans
return ans;
}
// Function to find the cheapest price
// from given source to destination
static int findCheapestPrice( int cities,
int [][] flights, int src,
int dst, int stops)
{
// Resize Adjacency Matrix
adjMatrix = new int [cities + 1 ][cities + 1 ];
// Traverse flight[][]
for ( int [] item : flights) {
// Create Adjacency Matrix
adjMatrix[item[ 0 ]][item[ 1 ]] = item[ 2 ];
}
// DFS Call to find shortest path
int ans = DFSUtility(src, stops, dst, cities);
// Return the cost
return ans >= Integer.MAX_VALUE ? - 1 : ans;
}
// Driver Code
public static void main(String[] args)
{
// Input flight : :Source,
// Destination, Cost
int [][] flights
= { { 4 , 1 , 1 }, { 1 , 2 , 3 }, { 0 , 3 , 2 },
{ 0 , 4 , 10 }, { 3 , 1 , 1 }, { 1 , 4 , 3 } };
// vec, n, stops, src, dst
int stops = 2 ;
int totalCities = 5 ;
int sourceCity = 0 ;
int destCity = 4 ;
// Function Call
int ans = findCheapestPrice(totalCities, flights,
sourceCity, destCity,
stops);
System.out.println(ans);
}
} // This code is contributed by Lovely Jain |
# Python3 program for the above approach # DFS memoization adjMatrix = []
mp = dict ()
# Function to implement DFS Traversal def DFSUtility(node, stops, dst, cities):
# Base Case
if (node = = dst):
return 0
if (stops < 0 ) :
return 1e9
key = (node, stops)
# Find value with key in a map
if key in mp:
return mp[key]
ans = 1e9
# Traverse adjacency matrix of
# source node
for neighbour in range (cities):
weight = adjMatrix[node][neighbour]
if (weight > 0 ) :
# Recursive DFS call for
# child node
minVal = DFSUtility(neighbour, stops - 1 , dst, cities)
if (minVal + weight > 0 ):
ans = min (ans, minVal + weight)
mp[key] = ans
# Return ans
return ans
# Function to find the cheapest price # from given source to destination def findCheapestPrice(cities, flights, src, dst, stops):
global adjMatrix
# Resize Adjacency Matrix
adjMatrix = [[ 0 ] * (cities + 1 ) for _ in range (cities + 1 )]
# Traverse flight[][]
for item in flights:
# Create Adjacency Matrix
adjMatrix[item[ 0 ]][item[ 1 ]] = item[ 2 ]
# DFS Call to find shortest path
ans = DFSUtility(src, stops, dst, cities)
# Return the cost
return - 1 if ans > = 1e9 else int (ans)
# Driver Code if __name__ = = '__main__' :
# Input flight : :Source,
# Destination, Cost
flights = [[ 4 , 1 , 1 ],[ 1 , 2 , 3 ] , [ 0 , 3 , 2 ] , [ 0 , 4 , 10 ] , [ 3 , 1 , 1 ] , [ 1 , 4 , 3 ]]
# vec, n, stops, src, dst
stops = 2
totalCities = 5
sourceCity = 0
destCity = 4
# Function Call
ans = findCheapestPrice(
totalCities, flights,
sourceCity, destCity,
stops)
print (ans)
|
// C# program to implement above approach using System;
using System.Collections;
using System.Collections.Generic;
class GFG
{ // DFS memoization
static int [][] adjMatrix;
static Dictionary< int [], int > mp = new Dictionary< int [], int >();
// Function to implement DFS Traversal
static int DFSUtility( int node, int stops, int dst, int cities)
{
// Base Case
if (node == dst){
return 0;
}
if (stops < 0){
return Int32.MaxValue;
}
int [] key = new int [] { node, stops };
// Find value with key in a map
if (mp.ContainsKey(key)){
return mp[key];
}
int ans = Int32.MaxValue;
// Traverse adjacency matrix of
// source node
for ( int neighbour = 0 ; neighbour < cities ; ++neighbour) {
int weight = adjMatrix[node][neighbour];
if (weight > 0) {
// Recursive DFS call for
// child node
int minVal = DFSUtility(neighbour, stops - 1, dst, cities);
if (minVal + weight > 0){
ans = Math.Min(ans, minVal + weight);
}
}
if (!mp.ContainsKey(key)){
mp.Add(key, 0);
}
mp[key] = ans;
}
// Return ans
return ans;
}
// Function to find the cheapest price
// from given source to destination
static int findCheapestPrice( int cities, int [][] flights, int src, int dst, int stops)
{
// Resize Adjacency Matrix
adjMatrix = new int [cities + 1][];
for ( int i = 0 ; i <= cities ; i++){
adjMatrix[i] = new int [cities + 1];
}
// Traverse flight[][]
foreach ( int [] item in flights) {
// Create Adjacency Matrix
adjMatrix[item[0]][item[1]] = item[2];
}
// DFS Call to find shortest path
int ans = DFSUtility(src, stops, dst, cities);
// Return the cost
return ans >= Int32.MaxValue ? -1 : ans;
}
// Driver code
public static void Main( string [] args){
// Input flight : :Source,
// Destination, Cost
int [][] flights = new int [][]{
new int []{ 4, 1, 1 },
new int []{ 1, 2, 3 },
new int []{ 0, 3, 2 },
new int []{ 0, 4, 10 },
new int []{ 3, 1, 1 },
new int []{ 1, 4, 3 }
};
// vec, n, stops, src, dst
int stops = 2;
int totalCities = 5;
int sourceCity = 0;
int destCity = 4;
// Function Call
int ans = findCheapestPrice(totalCities, flights, sourceCity, destCity, stops);
Console.WriteLine(ans);
}
} // This code is contributed by entertain2022. |
const pair_hash = { // Function to implement hashing
operator(pair) {
return (
Math.hash(pair.first) ^ Math.hash(pair.second)
);
}
}; // DFS memoization let adjMatrix = []; let mp = new Map();
// Function to implement DFS Traversal function DFSUtility(node, stops, dst, cities)
{ // Base Case
if (node === dst) return 0;
if (stops < 0) return Number.MAX_SAFE_INTEGER;
let key = new Map();
// Find value with key in a map
if (mp.has(key)) return mp.get(key);
let ans = Number.MAX_SAFE_INTEGER;
// Traverse adjacency matrix of
// source node
for (let neighbour = 0; neighbour < cities; neighbour++) {
let weight = adjMatrix[node][neighbour];
if (weight > 0)
{
// Recursive DFS call for
// child node
let minVal = DFSUtility(neighbour, stops - 1, dst, cities);
if (minVal + weight > 0)
ans = Math.min(ans, minVal + weight);
}
}
mp.set(key, ans);
// Return ans
return ans;
} // Function to find the cheapest price // from given source to destination function findCheapestPrice(cities, flights,
src, dst, stops) { // Resize Adjacency Matrix
adjMatrix.resize = cities + 1;
for (let i = 0; i < cities + 1; i++) {
adjMatrix[i] = Array(cities + 1).fill(0);
}
// Traverse flight[][]
for (let item of flights)
{
// Create Adjacency Matrix
adjMatrix[item[0]][item[1]] = item[2];
}
// DFS Call to find shortest path
let ans = DFSUtility(src, stops, dst, cities);
// Return the cost
return ans >= Number.MAX_SAFE_INTEGER ? -1 : ans;
} // Driver Code // Input flight : {Source, // Destination, Cost} let flights = [ [4, 1, 1],
[1, 2, 3],
[0, 3, 2],
[0, 4, 10],
[3, 1, 1],
[1, 4, 3],
]; // vec, n, stops, src, dst let stops = 2; let totalCities = 5; let sourceCity = 0; let destCity = 4; // Function Call let ans = findCheapestPrice( totalCities,
flights,
sourceCity,
destCity,
stops
); console.log(ans); // This code is contributed by ishankhandelwals. |
6
Time Complexity: O(V + E), where V is the number of nodes and E is the edges.
Auxiliary Space: O(V)
Method 2: Using Breadth-First Search
- The idea is to use Queue to perform BFS Traversal.
- Perform traversal from current node and insert root node in the queue.
- Traverse the queue and explore the current node and its siblings. Then insert the siblings of the node in the queue.
- While exploring each sibling and keep pushing the entries in the queue if the cost is less and update the minimum cost.
- Print the minimum cost after the above traversal.
Below is the implementation of our approach:
// C++ program of the above approach #include <bits/stdc++.h> #include <iostream> #include <queue> #include <tuple> #include <unordered_map> using namespace std;
// BSF Memoization typedef tuple< int , int , int > tupl;
// Function to implement BFS int findCheapestPrice( int cities,
vector<vector< int > >& flights,
int src, int dst, int stops)
{ unordered_map< int ,
vector<pair< int , int > > >
adjList;
// Traverse flight[][]
for ( auto flight : flights) {
// Create Adjacency Matrix
adjList[flight[0]].push_back(
{ flight[1], flight[2] });
}
// < city, distancefromsource > pair
queue<pair< int , int > >
q;
q.push({ src, 0 });
// Store the Result
int srcDist = INT_MAX;
// Traversing the Matrix
while (!q.empty() && stops-- >= 0) {
int qSize = q.size();
for ( int i = 0; i < qSize; i++) {
pair< int , int > curr = q.front();
q.pop();
for ( auto next : adjList[curr.first]) {
// If source distance is already
// least the skip this iteration
if (srcDist < curr.second
+ next.second)
continue ;
q.push({ next.first,
curr.second
+ next.second });
if (dst == next.first) {
srcDist = min(
srcDist, curr.second
+ next.second);
}
}
}
}
// Returning the Answer
return srcDist == INT_MAX ? -1 : srcDist;
} // Driver Code int main()
{ // Input flight : {Source,
// Destination, Cost}
vector<vector< int > > flights
= { { 4, 1, 1 }, { 1, 2, 3 }, { 0, 3, 2 }, { 0, 4, 10 }, { 3, 1, 1 }, { 1, 4, 3 } };
// vec, n, stops, src, dst
int stops = 2;
int totalCities = 5;
// Given source and destination
int sourceCity = 0;
int destCity = 4;
// Function Call
long ans = findCheapestPrice(
totalCities, flights,
sourceCity, destCity,
stops);
cout << ans;
return 0;
} |
// Jaca program of the above approach import java.util.*;
public class Main
{ // Driver Code
public static void main(String[] args)
{
// Input flight : {Source,
// Destination, Cost}
int [][] flights
= { { 4 , 1 , 1 }, { 1 , 2 , 3 }, { 0 , 3 , 2 },
{ 0 , 4 , 10 }, { 3 , 1 , 1 }, { 1 , 4 , 3 } };
// vec, n, stops, src, dst
int stops = 2 ;
int totalCities = 5 ;
// Given source and destination
int sourceCity = 0 ;
int destCity = 4 ;
// Function Call
long ans = findCheapestPrice(totalCities, flights,
sourceCity, destCity,
stops);
System.out.println(ans);
}
public static long findCheapestPrice( int cities,
int [][] flights,
int src, int dst,
int stops)
{
Map<Integer, List< int []> > adjList
= new HashMap<>();
// Traverse flight[][]
for ( int [] flight : flights) {
// Create Adjacency Matrix
adjList
.computeIfAbsent(flight[ 0 ],
k -> new ArrayList<>())
.add( new int [] { flight[ 1 ], flight[ 2 ] });
}
// < city, distancefromsource > []
Queue< int []> q = new LinkedList<>();
q.offer( new int [] { src, 0 });
// Store the Result
long srcDist = Integer.MAX_VALUE;
// Traversing the Matrix
while (!q.isEmpty() && stops-- >= 0 ) {
int qSize = q.size();
for ( int i = 0 ; i < qSize; i++) {
int [] curr = q.poll();
for ( int [] next : adjList.getOrDefault(
curr[ 0 ], new ArrayList<>())) {
// If source distance is already
// least the skip this iteration
if (srcDist < curr[ 1 ] + next[ 1 ])
continue ;
q.offer( new int [] {
next[ 0 ], curr[ 1 ] + next[ 1 ] });
if (dst == next[ 0 ])
srcDist = Math.min(
srcDist, curr[ 1 ] + next[ 1 ]);
}
}
}
// Returning the Answer
return srcDist == Integer.MAX_VALUE ? - 1 : srcDist;
}
} // This code is contributed by Tapesh(tapeshdua420) |
# Python3 program of the above approach from queue import Queue as Q
# Function to implement BFS def findCheapestPrice(cities, flights, src, dst, stops):
adjList = dict ()
# Traverse flight[][]
for flight in flights :
# Create Adjacency Matrix
if flight[ 0 ] in adjList:
adjList[flight[ 0 ]].append(
(flight[ 1 ], flight[ 2 ]))
else :
adjList[flight[ 0 ]] = [(flight[ 1 ], flight[ 2 ])]
q = Q()
q.put((src, 0 ))
# Store the Result
srcDist = 1e9
# Traversing the Matrix
while ( not q.empty() and stops > = 0 ) :
stops - = 1
for i in range (q.qsize()) :
curr = q.get()
for nxt in adjList[curr[ 0 ]]:
# If source distance is already
# least the skip this iteration
if (srcDist < curr[ 1 ] + nxt[ 1 ]):
continue
q.put((nxt[ 0 ],curr[ 1 ] + nxt[ 1 ]))
if (dst = = nxt[ 0 ]):
srcDist = min ( srcDist, curr[ 1 ] + nxt[ 1 ])
# Returning the Answer
return - 1 if srcDist = = 1e9 else srcDist
# Driver Code if __name__ = = '__main__' :
# Input flight : :Source,
# Destination, Cost
flights = [[ 4 , 1 , 1 ],[ 1 , 2 , 3 ] , [ 0 , 3 , 2 ] , [ 0 , 4 , 10 ] , [ 3 , 1 , 1 ] , [ 1 , 4 , 3 ]]
# vec, n, stops, src, dst
stops = 2
totalCities = 5
# Given source and destination
sourceCity = 0
destCity = 4
# Function Call
ans = findCheapestPrice(
totalCities, flights,
sourceCity, destCity,
stops)
print (ans)
|
// C# program of the above approach using System;
using System.Collections;
using System.Collections.Generic;
public class GFG {
public static int findCheapestPrice( int n,
int [, ] flights,
int src, int dst,
int K)
{
var adjList
= new Dictionary< int ,
List<Tuple< int , int > > >();
// Traverse flight[][]
for ( int i = 0; i < flights.GetLength(0); i++) {
// Create Adjacency Matrix
if (!adjList.ContainsKey(flights[i, 0])) {
adjList.Add(flights[i, 0],
new List<Tuple< int , int > >());
}
adjList[flights[i, 0]].Add(
Tuple.Create(flights[i, 1], flights[i, 2]));
}
// < city, distancefromsource > []
var q = new Queue<( int , int )>();
q.Enqueue((src, 0));
// Store the Result
var srcDist = Int32.MaxValue;
// Traversing the Matrix
while (q.Count > 0 && K-- >= 0) {
var qSize = q.Count;
for ( var i = 0; i < qSize; i++) {
var curr = q.Dequeue();
foreach ( var next in adjList[curr.Item1])
{
// If source distance is already
// least the skip this iteration
if (srcDist < curr.Item2 + next.Item2)
continue ;
q.Enqueue((next.Item1,
curr.Item2 + next.Item2));
if (dst == next.Item1) {
srcDist = Math.Min(
srcDist,
curr.Item2 + next.Item2);
}
}
}
}
// Returning the Answer
return srcDist == Int32.MaxValue ? -1 : srcDist;
}
// Driver Code
public static void Main( string [] args)
{
// Input flight : {Source,
// Destination, Cost}
int [, ] flights
= new int [, ] { { 4, 1, 1 }, { 1, 2, 3 },
{ 0, 3, 2 }, { 0, 4, 10 },
{ 3, 1, 1 }, { 1, 4, 3 } };
// vec, n, stops, src, dst
int stops = 2;
int totalCities = 5;
// Given source and destination
int sourceCity = 0;
int destCity = 4;
// Function Call
long ans = findCheapestPrice(totalCities, flights,
sourceCity, destCity,
stops);
Console.WriteLine(ans);
}
} // This code is contributed by Tapesh(tapeshdua420) |
function findCheapestPrice(cities, flights, src, dst, stops) {
const adjList = new Map();
// Traverse flight[][]
for (let i = 0; i < flights.length; i++) {
const flight = flights[i];
// Create Adjacency Matrix
const dest = flight[1];
const cost = flight[2];
const neighbors = adjList.get(flight[0]) || [];
neighbors.push([dest, cost]);
adjList.set(flight[0], neighbors);
}
// < city, distancefromsource > []
const q = [];
q.push([src, 0]);
// Store the Result
let srcDist = Infinity;
// Traversing the Matrix
while (q.length > 0 && stops-- >= 0) {
const qSize = q.length;
for (let i = 0; i < qSize; i++) {
const curr = q.shift();
const neighbors = adjList.get(curr[0]) || [];
for (let j = 0; j < neighbors.length; j++) {
const next = neighbors[j];
// If source distance is already
// least the skip this iteration
if (srcDist < curr[1] + next[1]) {
continue ;
}
q.push([next[0], curr[1] + next[1]]);
if (dst === next[0]) {
srcDist = Math.min(srcDist, curr[1] + next[1]);
}
}
}
}
// Returning the Answer
return srcDist === Infinity ? -1 : srcDist;
} // Driver Code const flights = [ [4, 1, 1],
[1, 2, 3],
[0, 3, 2],
[0, 4, 10],
[3, 1, 1],
[1, 4, 3]
]; const stops = 2; const totalCities = 5; const sourceCity = 0; const destCity = 4; const ans = findCheapestPrice(totalCities, flights, sourceCity, destCity, stops); console.log(ans); |
6
Time Complexity: O(Stops* N * N) where N is the Product of Cities and Size in Queue
Auxiliary Space: O(N)
Method 3: Using Dijkstra Algorithm
- Update the distance of all the vertices from the source.
- The vertices that are not directly connected from the source are marked with infinity and vertices that are directly connected are updated with the correct distance.
- Start from the source, and extract next min vertices. This will ensure the minimum cost.
- Do Edge Relaxation at each step: D denotes Distance and w denotes weights
- If D[u] + w(u, z) < D[z] then
- D[z] = D[u] + w(u, z)
Here is the implementation of our approach:
// C++ program for the above approach #include <bits/stdc++.h> #include <tuple> using namespace std;
typedef tuple< int , int , int > tupl;
long findCheapestPrice( int cities,
vector<vector< int > >& flights,
int src, int dst, int stops)
{ // Adjacency Matrix
vector<vector<pair< int , int > > > adjList(cities);
// Traverse flight[][]
for ( auto flight : flights) {
// Create Adjacency Matrix
adjList[flight[0]].push_back(
{ flight[1], flight[2] });
}
// Implementing Priority Queue
priority_queue<tupl, vector<tupl>,
greater<tupl> >
pq;
tupl t = make_tuple(0, src, stops);
pq.push(t);
// While PQ is not empty
while (!pq.empty()) {
tupl t = pq.top();
pq.pop();
if (src == dst)
return 0;
int cost = get<0>(t);
int current = get<1>(t);
int stop = get<2>(t);
if (current == dst)
// Return the Answer
return cost;
if (stop >= 0) {
for ( auto next : adjList[current]) {
tupl t = make_tuple((cost
+ next.second),
next.first,
stop - 1);
pq.push(t);
}
}
}
return -1;
} int main()
{ // Input flight : {Source,
// Destination, Cost}
vector<vector< int > > flights
= { { 4, 1, 1 }, { 1, 2, 3 }, { 0, 3, 2 }, { 0, 4, 10 }, { 3, 1, 1 }, { 1, 4, 3 } };
// vec, n, stops, src, dst
int stops = 2;
int totalCities = 5;
// Given source and destination
int sourceCity = 0;
int destCity = 4;
// Function Call
long ans = findCheapestPrice(
totalCities, flights,
sourceCity, destCity, stops);
cout << ans;
return 0;
} |
// Java code import java.util.*;
import java.util.stream.Collectors;
public class Main {
// Create a tuple class
static class tupl implements Comparable<tupl> {
int cost;
int current;
int stop;
public tupl( int cost, int current, int stop)
{
this .cost = cost;
this .current = current;
this .stop = stop;
}
@Override public int compareTo(tupl o)
{
return this .cost - o.cost;
}
};
// Function to find the cheapest
// price from source to destination
// using at-most k stops
static long
findCheapestPrice( int cities,
List<List<Integer> > flights, int src,
int dst, int stops)
{
// Adjacency Matrix
List<List< int []> > adjList = new ArrayList<>();
for ( int i = 0 ; i < cities; i++)
adjList.add( new ArrayList<>());
// Traverse flight[][]
for (List<Integer> flight : flights) {
// Create Adjacency Matrix
adjList.get(flight.get( 0 ))
.add( new int [] { flight.get( 1 ),
flight.get( 2 ) });
}
// Implementing Priority Queue
PriorityQueue<tupl> pq = new PriorityQueue<>();
tupl t = new tupl( 0 , src, stops);
pq.add(t);
// While PQ is not empty
while (!pq.isEmpty()) {
tupl t1 = pq.poll();
int cost = t1.cost;
int current = t1.current;
int stop = t1.stop;
if (current == dst)
// Return the Answer
return cost;
if (stop >= 0 ) {
for ( int [] next : adjList.get(current)) {
tupl t2 = new tupl((cost + next[ 1 ]),
next[ 0 ], stop - 1 );
pq.add(t2);
}
}
}
return - 1 ;
}
// Driver Code
public static void main(String[] args)
{
// Input flight : {Source,
// Destination, Cost}
List<List<Integer> > flights = Arrays.asList(
Arrays.asList( 4 , 1 , 1 ), Arrays.asList( 1 , 2 , 3 ),
Arrays.asList( 0 , 3 , 2 ), Arrays.asList( 0 , 4 , 10 ),
Arrays.asList( 3 , 1 , 1 ), Arrays.asList( 1 , 4 , 3 ));
// vec, n, stops, src, dst
int stops = 2 ;
int totalCities = 5 ;
// Given source and destination
int sourceCity = 0 ;
int destCity = 4 ;
// Function Call
long ans = findCheapestPrice(totalCities, flights,
sourceCity, destCity,
stops);
System.out.println(ans);
}
} |
# Python3 program for the above approach import heapq as hq
def findCheapestPrice(cities, flights, src, dst, stops):
# Adjacency Matrix
adjList = [[] for _ in range (cities)]
# Traverse flight[][]
for flight in flights:
# Create Adjacency Matrix
adjList[flight[ 0 ]].append((flight[ 1 ], flight[ 2 ]))
# Implementing Priority Queue
pq = []
t = ( 0 , src, stops)
hq.heappush(pq, t)
# While PQ is not empty
while (pq):
t = hq.heappop(pq)
if (src = = dst):
return 0
cost, current, stop = t
if (current = = dst):
# Return the Answer
return cost
if (stop > = 0 ):
for nxt in adjList[current]:
t = ((cost + nxt[ 1 ]), nxt[ 0 ], stop - 1 )
hq.heappush(pq, t)
return - 1
if __name__ = = '__main__' :
# Input flight : :Source,
# Destination, Cost
flights = [[ 4 , 1 , 1 ], [ 1 , 2 , 3 ], [ 0 , 3 , 2 ],
[ 0 , 4 , 10 ], [ 3 , 1 , 1 ], [ 1 , 4 , 3 ]]
# vec, n, stops, src, dst
stops = 2
totalCities = 5
# Given source and destination
sourceCity = 0
destCity = 4
# Function Call
ans = findCheapestPrice(
totalCities, flights,
sourceCity, destCity, stops)
print (ans)
|
function findCheapestPrice(cities, flights, src, dst, stops) {
// Adjacency List
const adjList = Array.from({ length: cities }, () => []);
// Traverse flights[][]
for (const flight of flights) {
// Create Adjacency List
adjList[flight[0]].push([flight[1], flight[2]]);
}
// Implementing Priority Queue
const pq = [];
const t = [0, src, stops];
pq.push(t);
// While PQ is not empty
while (pq.length > 0) {
const t = pq.shift();
if (src == dst) {
return 0;
}
const [cost, current, stop] = t;
if (current == dst) {
// Return the answer
return cost;
}
if (stop >= 0) {
for (const [nxt, price] of adjList[current]) {
const t = [cost + price, nxt, stop - 1];
pq.push(t);
}
pq.sort((a, b) => a[0] - b[0]);
}
}
return -1;
} // Input flight: [Source, Destination, Cost] const flights = [ [4, 1, 1], [1, 2, 3],
[0, 3, 2],
[0, 4, 10],
[3, 1, 1],
[1, 4, 3],
]; // vec, n, stops, src, dst const stops = 2; const totalCities = 5; // Given source and destination const sourceCity = 0; const destCity = 4; // Function call const ans = findCheapestPrice( totalCities,
flights,
sourceCity,
destCity,
stops
); console.log(ans); |
//C# program for the above approach using System;
using System.Collections.Generic;
public class MainClass
{ public static int findCheapestPrice( int cities, int [][] flights, int src, int dst, int stops)
{
// Adjacency Matrix
List<List<Tuple< int , int >>> adjList = new List<List<Tuple< int , int >>>();
for ( int i = 0; i < cities; i++)
{
adjList.Add( new List<Tuple< int , int >>());
}
// Traverse flight[][]
foreach ( int [] flight in flights)
{
// Create Adjacency Matrix
adjList[flight[0]].Add(Tuple.Create(flight[1], flight[2]));
}
// Implementing Priority Queue
List<Tuple< int , int , int >> pq = new List<Tuple< int , int , int >>();
Tuple< int , int , int > t = Tuple.Create(0, src, stops);
pq.Add(t);
// While PQ is not empty
while (pq.Count > 0)
{
t = pq[0];
pq.RemoveAt(0);
if (src == dst)
{
return 0;
}
int cost = t.Item1;
int current = t.Item2;
int stop = t.Item3;
if (current == dst)
{
// Return the Answer
return cost;
}
if (stop >= 0)
{
foreach (Tuple< int , int > nxt in adjList[current])
{
t = Tuple.Create(cost + nxt.Item2, nxt.Item1, stop - 1);
pq.Add(t);
}
pq.Sort();
}
}
return -1;
}
public static void Main()
{
// Input flight : :Source,
// Destination, Cost
int [][] flights = new int [][]{
new int []{4, 1, 1},
new int []{1, 2, 3},
new int []{0, 3, 2},
new int []{0, 4, 10},
new int []{3, 1, 1},
new int []{1, 4, 3}
};
// vec, n, stops, src, dst
int stops = 2;
int totalCities = 5;
// Given source and destination
int sourceCity = 0;
int destCity = 4;
// Function Call
int ans = findCheapestPrice(totalCities, flights, sourceCity, destCity, stops);
Console.WriteLine(ans);
}
} //This code is contributed by shivamsharma215 |
6
Time Complexity: O(E+V log V) where V is the number of nodes and E is the edges.
Auxiliary Space: O(V)
Method 4: Using Bellmon Ford
- Initialize distances from the source to all vertices as infinite and distance to the source itself as 0.
- Do Edge Relaxation at each step: D denotes Distance and w denotes weights
- If D[u] + w(u, z) < D[z] then D[z] = D[u] + w(u, z)
- The algorithm has been modified to solve the given problem instead of relaxing the graph V-1 times, we will do it for the given number of stops.
Below is the implementation of the above approach
// C++ program of the above Approach #include <bits/stdc++.h> #include <vector> using namespace std;
// Function to find the cheapest cost // from source to destination using K stops int findCheapestPrice( int cities,
vector<vector< int > >& flights,
int src, int dst, int stops)
{ // Distance from source to all other nodes
vector< int > dist(cities, INT_MAX);
dist[src] = 0;
// Do relaxation for V-1 vertices
// here we need for K stops so we
// will do relaxation for k+1 stops
for ( int i = 0; i <= stops; i++) {
vector< int > intermediate(dist);
for ( auto flight : flights) {
if (dist[flight[0]] != INT_MAX) {
intermediate[flight[1]]
= min(intermediate[flight[1]],
dist[flight[0]]
+ flight[2]);
}
}
// Update the distance vector
dist = intermediate;
}
// Return the final cost
return dist[dst] == INT_MAX ? -1 : dist[dst];
} // Driver Code int main()
{ // Input flight : {Source, Destination, Cost}
vector<vector< int > > flights
= { { 4, 1, 1 }, { 1, 2, 3 }, { 0, 3, 2 }, { 0, 4, 10 }, { 3, 1, 1 }, { 1, 4, 3 } };
// vec, n, stops, src, dst
int stops = 2;
int totalCities = 5;
// Given source and destination
int sourceCity = 0;
int destCity = 4;
// Function Call
long ans = findCheapestPrice(
totalCities, flights, sourceCity,
destCity, stops);
cout << ans;
return 0;
} |
// Java program of the above approach import java.util.*;
public class Main {
// Function to find the cheapest cost
// from source to destination using K stops
public static int findCheapestPrice(
int cities, ArrayList<ArrayList<Integer> > flights,
int src, int dst, int stops)
{
// Distance from source to all other nodes
ArrayList<Integer> dist = new ArrayList<Integer>();
for ( int i = 0 ; i < cities; i++) {
dist.add(Integer.MAX_VALUE);
}
dist.set(src, 0 );
// Do relaxation for V-1 vertices
// here we need for K stops so we
// will do relaxation for k+1 stops
for ( int i = 0 ; i <= stops; i++) {
ArrayList<Integer> intermediate
= new ArrayList<Integer>(dist);
for (ArrayList<Integer> flight : flights) {
if (dist.get(flight.get( 0 ))
!= Integer.MAX_VALUE) {
intermediate.set(
flight.get( 1 ),
Math.min(
intermediate.get(flight.get( 1 )),
dist.get(flight.get( 0 ))
+ flight.get( 2 )));
}
}
// Update the distance vector
dist = intermediate;
}
// Return the final cost
return dist.get(dst) == Integer.MAX_VALUE
? - 1
: dist.get(dst);
}
// Driver Code
public static void main(String[] args)
{
// Input flight : {Source, Destination, Cost}
ArrayList<ArrayList<Integer> > flights
= new ArrayList<ArrayList<Integer> >();
flights.add(
new ArrayList<Integer>(Arrays.asList( 4 , 1 , 1 )));
flights.add(
new ArrayList<Integer>(Arrays.asList( 1 , 2 , 3 )));
flights.add(
new ArrayList<Integer>(Arrays.asList( 0 , 3 , 2 )));
flights.add( new ArrayList<Integer>(
Arrays.asList( 0 , 4 , 10 )));
flights.add(
new ArrayList<Integer>(Arrays.asList( 3 , 1 , 1 )));
flights.add(
new ArrayList<Integer>(Arrays.asList( 1 , 4 , 3 )));
// vec, n, stops, src, dst
int stops = 2 ;
int totalCities = 5 ;
// Given source and destination
int sourceCity = 0 ;
int destCity = 4 ;
// Function Call
int ans = findCheapestPrice(totalCities, flights,
sourceCity, destCity,
stops);
System.out.println(ans);
}
} // This code is contributed by rishabmalhdijo |
# Python3 program of the above Approach # Function to find the cheapest cost # from source to destination using K stops def findCheapestPrice(cities, flights, src, dst, stops):
# Distance from source to all other nodes
dist = [ 1e9 ] * cities
dist[src] = 0
# Do relaxation for V-1 vertices
# here we need for K stops so we
# will do relaxation for k+1 stops
for i in range (stops):
intermediate = dist
for flight in flights:
if (dist[flight[ 0 ]] ! = 1e9 ) :
intermediate[flight[ 1 ]] = min (intermediate[flight[ 1 ]], dist[flight[ 0 ]] + flight[ 2 ])
# Update the distance vector
dist = intermediate
# Return the final cost
return - 1 if dist[dst] = = 1e9 else dist[dst]
# Driver Code if __name__ = = '__main__' :
# Input flight : :Source, Destination, Cost
flights = [[ 4 , 1 , 1 ], [ 1 , 2 , 3 ], [ 0 , 3 , 2 ],
[ 0 , 4 , 10 ], [ 3 , 1 , 1 ], [ 1 , 4 , 3 ]]
# vec, n, stops, src, dst
stops = 2
totalCities = 5
# Given source and destination
sourceCity = 0
destCity = 4
# Function Call
ans = findCheapestPrice(
totalCities, flights,
sourceCity, destCity, stops)
print (ans)
|
using System;
using System.Collections.Generic;
using System.Linq;
class MainClass
{ // Function to find the cheapest cost
// from source to destination using K stops
public static int FindCheapestPrice(
int cities, List<List< int >> flights,
int src, int dst, int stops)
{
// Distance from source to all other nodes
List< int > dist = new List< int >(Enumerable.Repeat(Int32.MaxValue, cities));
dist[src] = 0;
// Do relaxation for V-1 vertices
// here we need for K stops so we
// will do relaxation for k+1 stops
for ( int i = 0; i <= stops; i++) {
List< int > intermediate = new List< int >(dist);
foreach (List< int > flight in flights) {
if (dist[flight[0]] != Int32.MaxValue) {
intermediate[flight[1]] = Math.Min(
intermediate[flight[1]],
dist[flight[0]] + flight[2]);
}
}
// Update the distance vector
dist = intermediate;
}
// Return the final cost
return dist[dst] == Int32.MaxValue ? -1 : dist[dst];
}
// Driver Code
public static void Main() {
// Input flight : {Source, Destination, Cost}
List<List< int >> flights = new List<List< int >> {
new List< int > {4, 1, 1},
new List< int > {1, 2, 3},
new List< int > {0, 3, 2},
new List< int > {0, 4, 10},
new List< int > {3, 1, 1},
new List< int > {1, 4, 3}
};
// vec, n, stops, src, dst
int stops = 2;
int totalCities = 5;
// Given source and destination
int sourceCity = 0;
int destCity = 4;
// Function Call
int ans = FindCheapestPrice(totalCities, flights,
sourceCity, destCity,
stops);
Console.WriteLine(ans);
}
} // This code is contributed by Prajwal Kandekar |
// JavaScript program of the above Approach // Function to find the cheapest cost // from source to destination using K stops function findCheapestPrice(cities,flights,src,dst,stops)
{ // Distance from source to all other nodes
var dist = Array(cities).fill(Number.MAX_VALUE);
dist[src] = 0;
// Do relaxation for V-1 vertices
// here we need for K stops so we
// will do relaxation for k+1 stops
for (let i = 0; i <= stops; i++) {
var intermediate = [...dist];
for (let flight of flights) {
if (dist[flight[0]] != Number.MAX_VALUE) {
intermediate[flight[1]]
= Math.min(intermediate[flight[1]],
dist[flight[0]] + flight[2]);
}
}
// Update the distance vector
dist = [...intermediate];
}
// Return the final cost
return dist[dst] == Number.MAX_VALUE ? -1 : dist[dst];
} // Driver code const flights = [ [4, 1, 1],
[1, 2, 3],
[0, 3, 2],
[0, 4, 10],
[3, 1, 1],
[1, 4, 3]
]; let stops = 2; let totalCities = 5; let sourceCity = 0; let destCity = 4; let ans = findCheapestPrice(totalCities, flights, sourceCity, destCity, stops); console.log(ans); // This code is contributed by ishankhandelwals. |
6
Time Complexity: O(E*V) where V is the number of nodes and E is the edges.
Auxiliary Space:O(V)