Single source shortest path between two cities
Last Updated :
15 Jul, 2025
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++
// 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
// 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
# 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#
// 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.
JavaScript
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.
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++
// 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;
}
Java
// 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
# 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#
// 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)
JavaScript
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);
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++
// 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
// 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
# 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)
JavaScript
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#
//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
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++
// 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
// 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
# 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)
C#
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
// 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.
Time Complexity: O(E*V) where V is the number of nodes and E is the edges.
Auxiliary Space:O(V)
Similar Reads
Basics & Prerequisites
Data Structures
Array Data StructureIn this article, we introduce array, implementation in different popular languages, its basic operations and commonly seen problems / interview questions. An array stores items (in case of C/C++ and Java Primitive Arrays) or their references (in case of Python, JS, Java Non-Primitive) at contiguous
3 min read
String in Data StructureA string is a sequence of characters. The following facts make string an interesting data structure.Small set of elements. Unlike normal array, strings typically have smaller set of items. For example, lowercase English alphabet has only 26 characters. ASCII has only 256 characters.Strings are immut
2 min read
Hashing in Data StructureHashing is a technique used in data structures that efficiently stores and retrieves data in a way that allows for quick access. Hashing involves mapping data to a specific index in a hash table (an array of items) using a hash function. It enables fast retrieval of information based on its key. The
2 min read
Linked List Data StructureA linked list is a fundamental data structure in computer science. It mainly allows efficient insertion and deletion operations compared to arrays. Like arrays, it is also used to implement other data structures like stack, queue and deque. Hereâs the comparison of Linked List vs Arrays Linked List:
2 min read
Stack Data StructureA Stack is a linear data structure that follows a particular order in which the operations are performed. The order may be LIFO(Last In First Out) or FILO(First In Last Out). LIFO implies that the element that is inserted last, comes out first and FILO implies that the element that is inserted first
2 min read
Queue Data StructureA Queue Data Structure is a fundamental concept in computer science used for storing and managing data in a specific order. It follows the principle of "First in, First out" (FIFO), where the first element added to the queue is the first one to be removed. It is used as a buffer in computer systems
2 min read
Tree Data StructureTree Data Structure is a non-linear data structure in which a collection of elements known as nodes are connected to each other via edges such that there exists exactly one path between any two nodes. Types of TreeBinary Tree : Every node has at most two childrenTernary Tree : Every node has at most
4 min read
Graph Data StructureGraph Data Structure is a collection of nodes connected by edges. It's used to represent relationships between different entities. If you are looking for topic-wise list of problems on different topics like DFS, BFS, Topological Sort, Shortest Path, etc., please refer to Graph Algorithms. Basics of
3 min read
Trie Data StructureThe Trie data structure is a tree-like structure used for storing a dynamic set of strings. It allows for efficient retrieval and storage of keys, making it highly effective in handling large datasets. Trie supports operations such as insertion, search, deletion of keys, and prefix searches. In this
15+ min read
Algorithms
Searching AlgorithmsSearching algorithms are essential tools in computer science used to locate specific items within a collection of data. In this tutorial, we are mainly going to focus upon searching in an array. When we search an item in an array, there are two most common algorithms used based on the type of input
2 min read
Sorting AlgorithmsA Sorting Algorithm is used to rearrange a given array or list of elements in an order. For example, a given array [10, 20, 5, 2] becomes [2, 5, 10, 20] after sorting in increasing order and becomes [20, 10, 5, 2] after sorting in decreasing order. There exist different sorting algorithms for differ
3 min read
Introduction to RecursionThe process in which a function calls itself directly or indirectly is called recursion and the corresponding function is called a recursive function. A recursive algorithm takes one step toward solution and then recursively call itself to further move. The algorithm stops once we reach the solution
14 min read
Greedy AlgorithmsGreedy algorithms are a class of algorithms that make locally optimal choices at each step with the hope of finding a global optimum solution. At every step of the algorithm, we make a choice that looks the best at the moment. To make the choice, we sometimes sort the array so that we can always get
3 min read
Graph AlgorithmsGraph is a non-linear data structure like tree data structure. The limitation of tree is, it can only represent hierarchical data. For situations where nodes or vertices are randomly connected with each other other, we use Graph. Example situations where we use graph data structure are, a social net
3 min read
Dynamic Programming or DPDynamic Programming is an algorithmic technique with the following properties.It is mainly an optimization over plain recursion. Wherever we see a recursive solution that has repeated calls for the same inputs, we can optimize it using Dynamic Programming. The idea is to simply store the results of
3 min read
Bitwise AlgorithmsBitwise algorithms in Data Structures and Algorithms (DSA) involve manipulating individual bits of binary representations of numbers to perform operations efficiently. These algorithms utilize bitwise operators like AND, OR, XOR, NOT, Left Shift, and Right Shift.BasicsIntroduction to Bitwise Algorit
4 min read
Advanced
Segment TreeSegment Tree is a data structure that allows efficient querying and updating of intervals or segments of an array. It is particularly useful for problems involving range queries, such as finding the sum, minimum, maximum, or any other operation over a specific range of elements in an array. The tree
3 min read
Pattern SearchingPattern searching algorithms are essential tools in computer science and data processing. These algorithms are designed to efficiently find a particular pattern within a larger set of data. Patten SearchingImportant Pattern Searching Algorithms:Naive String Matching : A Simple Algorithm that works i
2 min read
GeometryGeometry is a branch of mathematics that studies the properties, measurements, and relationships of points, lines, angles, surfaces, and solids. From basic lines and angles to complex structures, it helps us understand the world around us.Geometry for Students and BeginnersThis section covers key br
2 min read
Interview Preparation
Practice Problem