add 2192

Author: fishercoder1534

Diff for: paginated_contents/algorithms/3rd_thousand/README.md

@@ -119,6 +119,7 @@
 | 2200 | [Find All K-Distant Indices in an Array](https://leetcode.com/problems/find-all-k-distant-indices-in-an-array/)                                                                              | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2200.java)                                       || Easy                                 ||
 | 2196 | [Create Binary Tree From Descriptions](https://leetcode.com/problems/create-binary-tree-from-descriptions/)                                                                                      | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2196.java)                                       || Medium                               | HashTable, Tree                
 | 2194 | [Cells in a Range on an Excel Sheet](https://leetcode.com/problems/cells-in-a-range-on-an-excel-sheet/)                                                                                      | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2194.java)                                       || Easy                                 ||
+| 2192 | [All Ancestors of a Node in a Directed Acyclic Graph](https://leetcode.com/problems/all-ancestors-of-a-node-in-a-directed-acyclic-graph/)                                                                                      | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2192.java)                                       || Medium                               | Topological Sort, Graph
 | 2190 | [Most Frequent Number Following Key In an Array](https://leetcode.com/problems/most-frequent-number-following-key-in-an-array/)                                                              | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2190.java)                                       || Easy                                 ||
 | 2186 | [Minimum Number of Steps to Make Two Strings Anagram II](https://leetcode.com/problems/minimum-number-of-steps-to-make-two-strings-anagram-ii/)                                              | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2186.java)                                       || Medium                               ||
 | 2185 | [Counting Words With a Given Prefix](https://leetcode.com/problems/counting-words-with-a-given-prefix/)                                                                                      | [Java](https://github.com/fishercoder1534/Leetcode/blob/master/src/main/java/com/fishercoder/solutions/thirdthousand/_2185.java)                                       || Easy                                 ||

Diff for: src/main/java/com/fishercoder/solutions/thirdthousand/_2192.java

@@ -0,0 +1,59 @@
+package com.fishercoder.solutions.thirdthousand;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.TreeSet;
+
+public class _2192 {
+    public static class Solution1 {
+        /**
+         * My completely original solution:
+         * topological sort template comes in handy here.
+         */
+        public List<List<Integer>> getAncestors(int n, int[][] edges) {
+            List<Integer>[] adjList = new ArrayList[n];
+            for (int i = 0; i < n; i++) {
+                adjList[i] = new ArrayList<>();
+            }
+            int[] indegree = new int[n];
+            for (int[] edge : edges) {
+                indegree[edge[1]]++;
+                adjList[edge[0]].add(edge[1]);
+            }
+            Queue<Integer> q = new LinkedList<>();
+            for (int i = 0; i < n; i++) {
+                if (indegree[i] == 0) {
+                    q.offer(i);
+                }
+            }
+            List<TreeSet<Integer>> treeSetList = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                treeSetList.add(new TreeSet<>());
+            }
+            while (!q.isEmpty()) {
+                Integer curr = q.poll();
+                for (int v : adjList[curr]) {
+                    indegree[v]--;
+                    treeSetList.get(v).add(curr);
+                    treeSetList.get(v).addAll(treeSetList.get(curr));
+                    if (indegree[v] == 0) {
+                        q.offer(v);
+                    }
+                }
+            }
+            List<List<Integer>> result = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                Iterator<Integer> it = treeSetList.get(i).iterator();
+                List<Integer> list = new ArrayList<>();
+                while (it.hasNext()) {
+                    list.add(it.next());
+                }
+                result.add(list);
+            }
+            return result;
+        }
+    }
+}

Diff for: src/test/java/com/fishercoder/thirdthousand/_2192Test.java

@@ -0,0 +1,36 @@
+package com.fishercoder.thirdthousand;
+
+import com.fishercoder.common.utils.CommonUtils;
+import com.fishercoder.solutions.thirdthousand._2192;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class _2192Test {
+    private static _2192.Solution1 solution1;
+
+    @BeforeEach
+    public void setup() {
+        solution1 = new _2192.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(Arrays.asList(
+                Arrays.asList(),
+                Arrays.asList(),
+                Arrays.asList(),
+                Arrays.asList(0, 1),
+                Arrays.asList(0, 2),
+                Arrays.asList(0, 1, 3),
+                Arrays.asList(0, 1, 2, 3, 4),
+                Arrays.asList(0, 1, 2, 3)
+        ), solution1.getAncestors(8,
+                CommonUtils.convertLeetCodeRegularRectangleArrayInputIntoJavaArray(
+                        "[0,3],[0,4],[1,3],[2,4],[2,7],[3,5],[3,6],[3,7],[4,6]")));
+    }
+
+}