Maximum cost path from source node to destination node via at most K intermediate nodes

import java.util.*;

class Main {

    // Function to find the longest distance
    // from source to destination with at
    // most K intermediate nodes
    public static int findShortestPath(int n, int[][] edges,
                                       int src, int dst,
                                       int K)
    {
        // Initialize the adjacency list
        List<List<int[]> > adjlist = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            adjlist.add(new ArrayList<int[]>());
        }

        // Initialize a queue to perform BFS
        Queue<int[]> q = new LinkedList<>();

        Map<Integer, Integer> mp = new HashMap<>();

        // Store the maximum distance of
        // every node from source vertex
        int ans = Integer.MIN_VALUE;

        // Initialize adjacency list
        for (int[] edge : edges) {
            adjlist.get(edge[0]).add(
                new int[] { edge[1], edge[2] });
        }

        // Push the first element into queue
        q.add(new int[] { src, 0 });

        int level = 0;

        // Iterate until the queue becomes empty
        // and the number of nodes between src
        // and dst vertex is at most to K
        while (!q.isEmpty() && level < K + 2) {

            // Current size of the queue
            int sz = q.size();

            for (int i = 0; i < sz; i++) {

                // Extract the front
                // element of the queue
                int[] pr = q.poll();

                // If the dst vertex is reached
                if (pr[0] == dst)
                    ans = Math.max(ans, pr[1]);

                // Traverse the adjacent nodes
                for (int[] pr2 : adjlist.get(pr[0])) {

                    // If the distance is greater
                    // than the current distance
                    if (!mp.containsKey(pr2[0])
                        || mp.get(pr2[0])
                               > pr[1] + pr2[1]) {

                        // Push it into the queue
                        q.add(new int[] { pr2[0],
                                          pr[1] + pr2[1] });
                        mp.put(pr2[0], pr[1] + pr2[1]);
                    }
                }
            }

            // Increment the level by 1
            level++;
        }

        // Finally, return the maximum distance
        return ans != Integer.MIN_VALUE ? ans : -1;
    }

    // Driver Code
    public static void main(String[] args)
    {
        int n = 3, src = 0, dst = 2, k = 1;
        int[][] edges = { { 0, 1, 100 },
                          { 1, 2, 100 },
                          { 0, 2, 500 } };

        System.out.println(
            findShortestPath(n, edges, src, dst, k));
    }
}

import java.util.*;

public class Main {
    static int max_cost(int n, List<List<Integer>> edges, int src,
             int dst, int k)
    {
      
        // We use 2 arrays for this algorithm
        // temp is the shortest distances array in current pass
        int[] temp = new int[n];
        Arrays.fill(temp, Integer.MAX_VALUE);
        temp[src] = 0;
        for (int i = 0; i <= k; i++) 
        {
          
            // c is the shortest distances array in previous
            // pass For every iteration current pass becomes the
            // previous
            int[] c = temp.clone();
            for (List<Integer> edge : edges) {
                int a = edge.get(0), b = edge.get(1), d = edge.get(2);
              
                // Updating the current array using previous
                // array Subtracting d is same as adding -d
                temp[b] = Math.min(temp[b], c[a] == Integer.MAX_VALUE ? Integer.MAX_VALUE : c[a] - d);
            }
        }
      
        // Checking if dst is reachable from src or not
        if (temp[dst] != Integer.MAX_VALUE)
        {
          
            // Returning the negative value of the shortest
            // distance to return the longest distance
            return -temp[dst];
        }
        return -1;
    }

    public static void main(String[] args) {
        List<List<Integer>> edges = Arrays.asList(
            Arrays.asList(0, 1, 100),
            Arrays.asList(1, 2, 100),
            Arrays.asList(0, 2, 500)
        );
        int src = 0;
        int dst = 2;
        int k = 1;
        int n = 3;

        System.out.println(max_cost(n, edges, src, dst, k));
    }
}