add TopologicalSortV2, update cheatsheet, progress

Author: yennanliu

data/progress.txt

@@ -1,4 +1,4 @@
-20241109: 210(todo),444
+20241109: 207,210(todo),444
 20241108: 1188,130,855(again)
 20241104: 207
 20241103: 900

data/to_review.txt

@@ -1,37 +1,37 @@
-2025-01-03 -> ['210(todo),444']
+2025-01-03 -> ['207,210(todo),444']
 2025-01-02 -> ['1188,130,855(again)']
 2024-12-28 -> ['900']
 2024-12-27 -> ['26,27', '802,1197,26']
 2024-12-21 -> ['855,846']
 2024-12-20 -> ['932']
 2024-12-18 -> ['951,792']
 2024-12-14 -> ['163,1048']
-2024-12-13 -> ['210(todo),444', '298,729']
+2024-12-13 -> ['207,210(todo),444', '298,729']
 2024-12-12 -> ['1188,130,855(again)', '1146']
 2024-12-08 -> ['737']
 2024-12-07 -> ['900', '686,734,737']
 2024-12-06 -> ['26,27', '802,1197,26', '353']
 2024-12-05 -> ['528,334']
 2024-12-03 -> ['1145']
-2024-11-30 -> ['210(todo),444', '855,846', '1145,1219']
+2024-11-30 -> ['207,210(todo),444', '855,846', '1145,1219']
 2024-11-29 -> ['1188,130,855(again)', '932']
 2024-11-27 -> ['951,792', '524,221,889']
 2024-11-26 -> ['743,889']
 2024-11-25 -> ['837']
 2024-11-24 -> ['900']
 2024-11-23 -> ['26,27', '802,1197,26', '163,1048', '981']
-2024-11-22 -> ['210(todo),444', '298,729', '1087']
+2024-11-22 -> ['207,210(todo),444', '298,729', '1087']
 2024-11-21 -> ['1188,130,855(again)', '1146']
 2024-11-20 -> ['939']
 2024-11-18 -> ['430']
-2024-11-17 -> ['210(todo),444', '855,846', '737', '363']
+2024-11-17 -> ['207,210(todo),444', '855,846', '737', '363']
 2024-11-16 -> ['1188,130,855(again)', '900', '932', '686,734,737', '1032,844,1011']
 2024-11-15 -> ['26,27', '802,1197,26', '353', '947']
-2024-11-14 -> ['210(todo),444', '951,792', '528,334']
+2024-11-14 -> ['207,210(todo),444', '951,792', '528,334']
 2024-11-13 -> ['1188,130,855(again)']
-2024-11-12 -> ['210(todo),444', '1145', '753']
-2024-11-11 -> ['210(todo),444', '1188,130,855(again)', '900', '727']
-2024-11-10 -> ['210(todo),444', '1188,130,855(again)', '26,27', '802,1197,26', '163,1048']
+2024-11-12 -> ['207,210(todo),444', '1145', '753']
+2024-11-11 -> ['207,210(todo),444', '1188,130,855(again)', '900', '727']
+2024-11-10 -> ['207,210(todo),444', '1188,130,855(again)', '26,27', '802,1197,26', '163,1048']
 2024-11-09 -> ['1188,130,855(again)', '855,846', '298,729', '1145,1219']
 2024-11-08 -> ['900', '932', '1146']
 2024-11-07 -> ['26,27', '802,1197,26']

doc/cheatsheet/topology_sorting.md

@@ -1,12 +1,15 @@
 # Topology sorting
 
-## 0) Concept  
-- Topological Sort is a algorithm can find "ordering" on an "order dependency" graph
+## 0) Concept
+
+- Topological Sort is a algorithm can find `ordering` based on `order dependency` graph
+
 - Concept
 	- [techbridge : topological-sort](https://blog.techbridge.cc/2020/05/10/leetcode-topological-sort/)
 	- [do topological-sort via DFS](https://alrightchiu.github.io/SecondRound/graph-li-yong-dfsxun-zhao-dagde-topological-sorttuo-pu-pai-xu.html)
 - Code
-	- [algorithm/python/topological_sort.py](https://github.com/yennanliu/CS_basics/blob/master/algorithm/python/topological_sort.py)
+	- [topological_sort.py](https://github.com/yennanliu/CS_basics/blob/master/algorithm/python/topological_sort.py)
+    - [TopologicalSort.java](https://github.com/yennanliu/CS_basics/blob/master/leetcode_java/src/main/java/AlgorithmJava/TopologicalSort.java)
 
 ### 0-1) Types
 - Courses

leetcode_java/src/main/java/AlgorithmJava/TopologicalSort.java

@@ -37,6 +37,17 @@ public class TopologicalSort {
      */
     public int[] topologicalSort(int numCourses, int[][] prerequisites) {
 
+        /**  NOTE !!!
+         *
+         *   we create 2 things for topological sort
+         *
+         *   1) List<List<Integer>> graph : for tracking nodes and their "prerequisite" node
+         *
+         *   2) int[] inDegree = new int[numCourses] : for tracking "degree" of a node,
+         *                                             when degree==0, the node CAN be ACCESSED
+         *
+         */
+
         // Step 1: Build the graph
         List<List<Integer>> graph = new ArrayList<>();
         for (int i = 0; i < numCourses; i++) {
@@ -60,8 +71,8 @@ public int[] topologicalSort(int numCourses, int[][] prerequisites) {
              *
              *    int[][] prerequisites = { {1, 0}, {2, 0}, {3, 1}, {3, 2} };
              *
-             *    -> 0 is a prerequisite for 1 and 2.
-             *    -> 1 and 2 are prerequisites for 3.
+             *    -> 0 is the prerequisite for 1 and 2.
+             *    -> 1 and 2 are the prerequisites for 3.
              *
              */
             // int dest = prereq[0];: dest represents the course that depends on src.

leetcode_java/src/main/java/AlgorithmJava/TopologicalSortV2.java

@@ -0,0 +1,55 @@
+package AlgorithmJava;
+
+import java.util.*;
+
+public class TopologicalSortV2 {
+
+    // V2
+    // Function to perform Topological Sort (GPT)
+    public static List<Integer> topologicalSort(int numNodes, List<List<Integer>> edges) {
+        // Step 1: Build the graph and calculate in-degrees
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        int[] inDegree = new int[numNodes];
+
+        for (int i = 0; i < numNodes; i++) {
+            graph.put(i, new ArrayList<>());
+        }
+
+        for (List<Integer> edge : edges) {
+            int from = edge.get(0);
+            int to = edge.get(1);
+            graph.get(from).add(to);
+            inDegree[to]++;
+        }
+
+        // Step 2: Initialize a queue with nodes that have in-degree 0
+        Queue<Integer> queue = new LinkedList<>();
+        for (int i = 0; i < numNodes; i++) {
+            if (inDegree[i] == 0) {
+                queue.offer(i);
+            }
+        }
+
+        List<Integer> topologicalOrder = new ArrayList<>();
+
+        // Step 3: Process the nodes in topological order
+        while (!queue.isEmpty()) {
+            int current = queue.poll();
+            topologicalOrder.add(current);
+
+            for (int neighbor : graph.get(current)) {
+                inDegree[neighbor]--;
+                if (inDegree[neighbor] == 0) {
+                    queue.offer(neighbor);
+                }
+            }
+        }
+
+        // If topologicalOrder does not contain all nodes, there was a cycle in the graph
+        if (topologicalOrder.size() != numNodes) {
+            throw new IllegalArgumentException("The graph has a cycle, so topological sort is not possible.");
+        }
+
+        return topologicalOrder;
+    }
+}

leetcode_java/src/main/java/dev/workspace5.java

@@ -2720,6 +2720,12 @@ public boolean sequenceReconstruction(int[] nums, List<List<Integer>> sequences)
         return false;
     }
 
+    // LC 207
+    // https://leetcode.com/problems/course-schedule/
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        return false;
+    }
+
 
 }