Minimum edges to reverse to make path from a source to a destination

// Function to find the minimum cost required 
// to run m tasks on n cores
import java.util.*;

class GfG {
    static int solve(Map<Integer, List<Pair> > map, int[] v, 
    String str, int src, int dst, Map<String, Integer> dp) {

        if (v[src] == 1)
            return Integer.MAX_VALUE - 1000;

        if (src == dst)
            return 0;

        String _key = str + "-" + src;

        if (dp.containsKey(_key))
            return dp.get(_key);

        v[src] = 1;
        int minStep = Integer.MAX_VALUE - 1000;

        if (map.containsKey(src)) {

            for (Pair key : map.get(src)) {
                String temp = str + key.node;

                if (key.dir == -1) {
                    minStep = Math.min(minStep, 
                    1 + solve(map, v, temp, key.node, dst, dp));
                }
                else {
                    minStep = Math.min(minStep, 
                    solve(map, v, temp, key.node, dst, dp));
                }
            }
        }

        v[src] = -1;
        dp.put(_key, minStep);
        return minStep;
    }

    // Function to find the minimum number of edge reversals
    static int minimumEdgeReversal(int[][] edges, 
    int n, int src, int dst) {

        Map<Integer, List<Pair> > map = new HashMap<>();

        for (int[] edge : edges) {

            if (map.containsKey(edge[0])) {

                // forward edge -> 1
                map.get(edge[0]).add(new Pair(edge[1], 1));
            }
            else {
                List<Pair> l = new ArrayList<>();
                l.add(new Pair(edge[1], 1));
                map.put(edge[0], l);
            }

            if (map.containsKey(edge[1])) {

                // backward edge -> -1
                map.get(edge[1]).add(new Pair(edge[0], -1));
            }
            else {
                List<Pair> l = new ArrayList<>();
                l.add(new Pair(edge[0], -1));
                map.put(edge[1], l);
            }
        }

        // visited
        int[] v = new int[n + 1]; 
        Arrays.fill(v, -1);

        Map<String, Integer> dp = new HashMap<>();

        int step = solve(map, v, 
        String.valueOf(src), src, dst, dp);

        return step == Integer.MAX_VALUE - 1000 ? -1 : step;
    }

    public static void main(String[] args) {
        int[][] edgeList = { {0, 1}, {2, 1}, {2, 3}, 
        {6, 3}, {6, 4}, {4, 5}, {5, 1} };
        int n = 7, src = 0, dst = 6;
        System.out.println(
        minimumEdgeReversal(edgeList, n, src, dst));
    }

    static class Pair {
        
        public int node;
        public int dir;
        
        
        public Pair(int node, int dir) {
            
            this.node = node;
            this.dir = dir;
        }
    }
}

// Function to find the minimum cost required 
// to run m tasks on n cores
import java.util.*;

class GfG {

    // Function to find the minimum number of edge reversals
    static int minimumEdgeReversal(int[][] edges, 
    int n, int src, int dst) {
        
        // Creating adjacency list for the given graph
        ArrayList<ArrayList<Pair>> g = new ArrayList<>();
        for (int i = 0; i < n + 2; i++) {
            g.add(new ArrayList<>());
        }
        for (int i = 0; i < edges.length; i++) {
            g.get(edges[i][0]).add(new Pair(edges[i][1], 0));
            g.get(edges[i][1]).add(new Pair(edges[i][0], 1));
        }
        
        // Creating a priority queue to store 
        // the vertices with their distances
        PriorityQueue<PairInt> pq = new 
        PriorityQueue<>(new Comparator<PairInt>() {
            public int compare(PairInt a, PairInt b) {
                return Integer.compare(a.first, b.first);
            }
        });
        
        // Creating a vector to store the 
        // distances of all vertices from src
        int[] dis = new int[n + 1];
        Arrays.fill(dis, Integer.MAX_VALUE);
        
        // Setting the distance of the source vertex to 0
        dis[src] = 0;
        
        // Inserting the source vertex into the priority queue
        pq.add(new PairInt(0, src));
        
        // Performing Dijkstra's algorithm
        while (!pq.isEmpty()) {
            PairInt p = pq.poll();
            int u = p.second;
            int w1 = p.first;
            
            // Iterating over the neighbors of the current vertex
            for (Pair nxt : g.get(u)) {
                int v = nxt.first;
                int w2 = nxt.second;
                
                // Updating the distance of the neighbor 
                // if a shorter path is found
                if (w1 + w2 < dis[v]) {
                    dis[v] = w1 + w2;
                    
                    // Inserting the neighbor 
                    // into the priority queue
                    pq.add(new PairInt(dis[v], v));
                }
            }
        }
        
        // If the distance to the destination 
        // vertex is still Integer.MAX_VALUE,
        // this means that there is no path from src to dst
        if (dis[dst] == Integer.MAX_VALUE)
            return -1;
        
        // Returning the distance of 
        // the destination vertex from src
        return dis[dst];
    }
    
    public static void main(String[] args) {
        int[][] edgeList = { {0, 1}, {2, 1}, {2, 3}, {6, 3}, {6, 4}, {4, 5}, {5, 1} };
        int n = 7, src = 0, dst = 6;
        System.out.println(minimumEdgeReversal(edgeList, n, src, dst));
    }
}

class Pair {
    int first, second;
    Pair(int first, int second) {
        this.first = first;
        this.second = second;
    }
}

class PairInt {
    int first, second;
    PairInt(int first, int second) {
        this.first = first;
        this.second = second;
    }
}

import java.util.*;

class GfG {

    // Function to find the minimum number of edge reversals
    static int minimumEdgeReversal(int[][] edges, 
    int n, int src, int dst) {

        // Creating adjacency list for the given graph
        List<List<int[]>> adj = new ArrayList<>();
        for (int i = 0; i <= n; i++)
            adj.add(new ArrayList<>());

        int m = edges.length;

        for (int i = 0; i < m; i++) {
            int fromNode = edges[i][0];
            int toNode = edges[i][1];
            adj.get(fromNode).add(new int[]{toNode, 0});
            adj.get(toNode).add(new int[]{fromNode, 1});
        }

        // Using BFS to find the shortest path
        int[] dist = new int[n + 1];
        Arrays.fill(dist, Integer.MAX_VALUE);

        // Creating a deque to store the vertices
        Deque<Integer> dq = new ArrayDeque<>();
        dq.addLast(src);
        dist[src] = 0;

        // Performing BFS
        while (!dq.isEmpty()) {
            int node = dq.pollFirst();

            // Iterating over the neighbors of the current vertex
            for (int[] neighbor : adj.get(node)) {
                int node2 = neighbor[0];
                int weight = neighbor[1];

                // Updating the distance of the neighbor
                // if a shorter path is found
                if (dist[node] + weight < dist[node2]) {
                    dist[node2] = dist[node] + weight;

                    // Inserting the neighbor into the deque
                    if (weight == 0)
                        dq.addFirst(node2);
                    else
                        dq.addLast(node2);
                }
            }
        }

        // If the distance of the destination vertex is Integer.MAX_VALUE
        // then there is no path from src to dst
        if (dist[dst] == Integer.MAX_VALUE)
            return -1;
        return dist[dst];
    }

    public static void main(String[] args) {
        int[][] edges = {{0, 1}, {2, 1}, {2, 3}, {6, 3}, 
        {6, 4}, {4, 5}, {5, 1}};
        int n = 7, src = 0, dst = 6;
        
        System.out.println(minimumEdgeReversal(edges, n, src, dst));
    }
}