Open In App

# Single source shortest path between two cities

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

1. Explore the current node and keep exploring its children.
2. Use a map to store the visited node in pair with stops and distance as value.
3. Break the recursion tree if the key is present in the map.
4. 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 using namespace std; // Structure to implement hashing to// stores pairs in mapstruct pair_hash {    template     std::size_t    operator()(const std::pair& pair) const    {        return std::hash()(pair.first)               ^ std::hash()(pair.second);    }}; // DFS memoizationvector > adjMatrix;typedef std::pair pair1;unordered_map mp; // Function to implement DFS Traversallong DFSUtility(int node, int stops,                int dst, int cities){    // Base Case    if (node == dst)        return 0;     if (stops < 0) {        return INT_MAX;    }     pair 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 destinationint findCheapestPrice(int cities,                      vector >& flights,                      int src, int dst, int stops){     // Resize Adjacency Matrix    adjMatrix.resize(cities + 1,                     vector(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 Codeint main(){    // Input flight : {Source,    // Destination, Cost}    vector > 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 approachimport java.util.HashMap; public class SingleS {     // DFS memoization    static int adjMatrix[][];    static HashMap mp        = new HashMap();     // 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 memoizationadjMatrix=[]mp=dict() # Function to implement DFS Traversaldef 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 destinationdef 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 Codeif __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 approachusing System;using System.Collections;using System.Collections.Generic; class GFG{   // DFS memoization  static int[][] adjMatrix;  static Dictionary mp = new Dictionary();   // 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 memoizationlet adjMatrix = [];let mp = new Map(); // Function to implement DFS Traversalfunction 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 destinationfunction 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, dstlet stops = 2;let totalCities = 5;let sourceCity = 0;let destCity = 4; // Function Calllet ans = findCheapestPrice(    totalCities,    flights,    sourceCity,    destCity,    stops);console.log(ans); // This code is contributed by ishankhandelwals.

Output:

6

Time Complexity: O(V + E), where V is the number of nodes and E is the edges.
Auxiliary Space: O(V)

1. The idea is to use Queue to perform BFS Traversal.
2. Perform traversal from current node and insert root node in the queue.
3. Traverse the queue and explore the current node and its siblings. Then insert the siblings of the node in the queue.
4. While exploring each sibling and keep pushing the entries in the queue if the cost is less and update the minimum cost.
5. Print the minimum cost after the above traversal.

Below is the implementation of our approach:

## C++

 // C++ program of the above approach#include #include #include #include #include  using namespace std;// BSF Memoizationtypedef tuple tupl; // Function to implement BFSint findCheapestPrice(int cities,                      vector >& flights,                      int src, int dst, int stops){    unordered_map > >        adjList;     // Traverse flight[][]    for (auto flight : flights) {         // Create Adjacency Matrix        adjList[flight[0]].push_back(            { flight[1], flight[2] });    }     // < city, distancefromsource > pair    queue >        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 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 Codeint main(){    // Input flight : {Source,    // Destination, Cost}    vector > 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 approachimport 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 > 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 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 BFSdef 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 Codeif __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 approachusing 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 > >();     // 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 >());      }      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 Codeconst 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);

Output:

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

1. Update the distance of all the vertices from the source.
2. 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.
3. Start from the source, and extract next min vertices. This will ensure the minimum cost.
4. Do Edge Relaxation at each step: D denotes Distance and w denotes weights
1. If D[u] + w(u, z) < D[z] then
2. D[z] = D[u] + w(u, z)

Here is the implementation of our approach:

## C++

 // C++ program for the above approach#include #include using namespace std; typedef tuple tupl;long findCheapestPrice(int cities,                       vector >& flights,                       int src, int dst, int stops){    // Adjacency Matrix    vector > > 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,                   greater >        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 > 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;}

## Python3

 # Python3 program for the above approachimport 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, dstconst stops = 2;const totalCities = 5; // Given source and destinationconst sourceCity = 0;const destCity = 4; // Function callconst ans = findCheapestPrice(  totalCities,  flights,  sourceCity,  destCity,  stops);console.log(ans);

## C#

Output:

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

1. Initialize distances from the source to all vertices as infinite and distance to the source itself as 0.
2. 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)
3. 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 #include using namespace std; // Function to find the cheapest cost// from source to destination using K stopsint findCheapestPrice(int cities,                      vector >& flights,                      int src, int dst, int stops){    // Distance from source to all other nodes    vector 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 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 Codeint main(){    // Input flight : {Source, Destination, Cost}    vector > 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 approachimport 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 > flights,    int src, int dst, int stops)  {     // Distance from source to all other nodes    ArrayList dist = new ArrayList();    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 intermediate        = new ArrayList(dist);       for (ArrayList 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 > flights      = new ArrayList >();    flights.add(      new ArrayList(Arrays.asList(4, 1, 1)));    flights.add(      new ArrayList(Arrays.asList(1, 2, 3)));    flights.add(      new ArrayList(Arrays.asList(0, 3, 2)));    flights.add(new ArrayList(      Arrays.asList(0, 4, 10)));    flights.add(      new ArrayList(Arrays.asList(3, 1, 1)));    flights.add(      new ArrayList(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 stopsdef 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 Codeif __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> flights,    int src, int dst, int stops)  {     // Distance from source to all other nodes    List dist = new List(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 intermediate = new List(dist);       foreach (List 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> flights = new List> {      new List {4, 1, 1},      new List {1, 2, 3},      new List {0, 3, 2},      new List {0, 4, 10},      new List {3, 1, 1},      new List {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 stopsfunction 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 codeconst 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.

Output:

6

Time Complexity: O(E*V) where V is the number of nodes and E is the edges.
Auxiliary Space:O(V)