add a solution for 210

Author: fishercoder1534

Diff for: src/main/java/com/fishercoder/solutions/firstthousand/_210.java

@@ -1,19 +1,23 @@
 package com.fishercoder.solutions.firstthousand;
 
-import java.util.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
 
 public class _210 {
     public static class Solution1 {
         public int[] findOrder(int numCourses, int[][] prerequisites) {
             int[] indegree = new int[numCourses];
             Map<Integer, List<Integer>> adjacencyList = new HashMap<>();
             for (int[] pre : prerequisites) {
-                int src = pre[1];
-                int dest = pre[0];
-                List<Integer> list = adjacencyList.getOrDefault(src, new ArrayList<>());
-                list.add(dest);
-                adjacencyList.put(src, list);
-                indegree[src]++;
+                List<Integer> list = adjacencyList.getOrDefault(pre[1], new ArrayList<>());
+                list.add(pre[0]);
+                adjacencyList.put(pre[1], list);
+                indegree[pre[0]]++;
             }
             Queue<Integer> q = new LinkedList<>();
             for (int i = 0; i < numCourses; i++) {
@@ -41,4 +45,44 @@ public int[] findOrder(int numCourses, int[][] prerequisites) {
             return new int[]{};
         }
     }
+
+    public static class Solution2 {
+        /**
+         * Instead of using a map, we can use an array of list type, it turned out to be even faster on LeetCode.
+         */
+        public int[] findOrder(int numCourses, int[][] prerequisites) {
+            List<Integer>[] adjList = new ArrayList[numCourses];
+            for (int i = 0; i < numCourses; i++) {
+                adjList[i] = new ArrayList<>();
+            }
+            int[] indegree = new int[numCourses];
+            for (int[] pre : prerequisites) {
+                indegree[pre[0]]++;
+                adjList[pre[1]].add(pre[0]);
+            }
+            Queue<Integer> q = new LinkedList<>();
+            for (int i = 0; i < indegree.length; i++) {
+                if (indegree[i] == 0) {
+                    q.offer(i);
+                }
+            }
+            int index = 0;
+            int[] order = new int[numCourses];
+            while (!q.isEmpty()) {
+                Integer curr = q.poll();
+                order[index++] = curr;
+                for (int v : adjList[curr]) {
+                    indegree[v]--;
+                    if (indegree[v] == 0) {
+                        q.offer(v);
+                    }
+                }
+            }
+            if (index == numCourses) {
+                return order;
+            }
+            return new int[]{};
+        }
+
+    }
 }

Diff for: src/test/java/com/fishercoder/firstthousand/_210Test.java

@@ -0,0 +1,29 @@
+package com.fishercoder.firstthousand;
+
+import com.fishercoder.solutions.firstthousand._210;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+public class _210Test {
+    private static _210.Solution1 solution1;
+    private static _210.Solution2 solution2;
+
+    @BeforeEach
+    public void setup() {
+        solution1 = new _210.Solution1();
+        solution2 = new _210.Solution2();
+    }
+
+    @Test
+    public void test1() {
+        assertArrayEquals(new int[]{0, 1}, solution1.findOrder(2, new int[][]{
+                {1, 0}
+        }));
+        assertArrayEquals(new int[]{0, 1}, solution2.findOrder(2, new int[][]{
+                {1, 0}
+        }));
+    }
+
+}