public class Solution {

     public int[] findOrder(int numCourses, int[][] prerequisites) {

         // This problem is to print one possible topological sort result

         // First, we need to construct a directed graph in the form of adjacency list

         List<Integer>[] adjacencyList = new ArrayList[numCourses];

         int[] result = new int[numCourses];

         int[] degree = new int[numCourses];

         Arrays.fill(degree, 0);

         for (int j = 0; j < numCourses; j++) {

             List<Integer> tmpList = new ArrayList<Integer>();

             tmpList.add(j);

             adjacencyList[j] = tmpList;

         }

         int length = prerequisites.length;

         for (int j = 0; j < length; j++) {

             int[] pair = prerequisites[j];

             adjacencyList[pair[1]].add(pair[0]);

             degree[pair[0]]++;

         }

         // queue is to store nodes with 0 in-degree

         Queue<Integer> queue = new LinkedList<Integer>();

         for (int j = 0; j < numCourses; j++) {

             if (degree[j] == 0)

                 queue.add(j);

         }

         if (queue.size() == 0)

             return new int[0];

         int i = 0;

         // begin bfs

         while (queue.size() > 0) {

             int current = queue.remove();

             result[i] = current;

             List<Integer> currentList = adjacencyList[current];

             for (int j = 1; j < currentList.size(); j++) {

                 int tmp = currentList.get(j);

                 degree[tmp]--;

                 if (degree[tmp] == 0)

                     queue.add(tmp);

             }

             i++;

         }

         if (i < numCourses)

             return new int[0];

         return result;

     }

 }