Possibility of finishing all courses given pre-requisites

There are a total of A courses you have to take, labeled from 1 to A.

Some courses may have prerequisites, for example to take course 2 you have to first take course 1, which is expressed as a pair: [1,2].

Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?

Return 1 if it is possible to finish all the courses, or 0 if it is not possible to finish all the courses.

The first argument of input contains an integer A, representing the number of courses.
The second argument of input contains an integer array, B.
The third argument of input contains an integer array, C.

Return a boolean value:
    1 : If it is possible to complete all the courses.
    0 : If it is not possible to complete all the courses.

1 <= A <= 6e4
1 <= length(B) = length(C) <= 1e5
1 <= B[i], C[i] <= A

Input 1:
    A = 3
    B = [1, 2]
    C = [2, 3]

Output 1:
    1

Explanation 1:
    It is possible to complete the courses in the following order:
        1 -> 2 -> 3

Input 2:
    A = 2
    B = [1, 2]
    C = [2, 1]

Output 2:
    0

Explanation 2:
    It is not possible to complete all the courses.

Solution:

Topological sort

Time: O(V + E)

public class Solution {
    static class Graph {
        Map<Integer, List<Integer>> edges; // from key to value
        int[] inDegrees;
        
        public Graph(int v) {
            this.edges = new HashMap<>();
            this.inDegrees = new int[v + 1];
        }
        
        public void construct(int[] V, int[] W) {
            int n = V.length;
            for (int i = 0; i < n; i ++) {
                int start = V[i];
                int end = W[i];
                inDegrees[end] ++;
                List<Integer> edgeList = edges.getOrDefault(start, new ArrayList<>());
                edgeList.add(end);
                edges.put(start, edgeList);
            }
        }
        
        public int topologicalSort() {
            Deque<Integer> zeroIns = new ArrayDeque<>();
            for (int i = 1; i < inDegrees.length; i ++) {
                if (inDegrees[i] == 0) {
                    zeroIns.offer(i);
                }
            }
            while (!zeroIns.isEmpty()) {
                int curr = zeroIns.poll();
                if (edges.containsKey(curr)) {
                    for (int next : edges.get(curr)) {
                        inDegrees[next] --;
                        if (inDegrees[next] == 0) {
                            zeroIns.offer(next);
                        }
                    }
                    edges.remove(curr);
                }
            }
            if (edges.size() > 0) {
                return 0;
            } else {
                return 1;
            }
        }
    }
    
    public int solve(int A, int[] B, int[] C) {
        Graph graph = new Graph(A);
        graph.construct(B, C);
        return graph.topologicalSort();
    }
}