update for more clean

Author: realdennis

src/topological-sort/course-schedule-II.ts

@@ -1,27 +1,27 @@
 function findOrder(N: number, A: number[][]): number[] {
-    const ret = [];
+    const ret: number[] = [];
 
-    // do topological sort using in-degree
+    const indegree: number[] = Array.from({ length: N }, () => 0);
+    const adjG: number[][] = Array.from<any, number[]>({ length: N }, () => []);
 
-    const degree = Array.from({ length: N }, () => 0); // indegree
-    const adj: number[][] = Array.from({ length: N }, () => []);
-
-    for (const [from, to] of A) {
-        degree[to]++;
-        adj[from].push(to);
+    for (const [F, L] of A) {
+        indegree[F]++;
+        adjG[F].push(L);
+        adjG[L].push(F);
     }
 
-    // topological sort
-
     for (let i = 0; i < N; i++) {
-        const node = degree.findIndex((val) => val === 0);
-        if (node === -1) return []; // impossible to finish
+        const zeroDegreeIdx = indegree.findIndex((deg) => deg === 0);
 
-        degree[node]--; // de-dup
-        ret.push(node);
+        if (zeroDegreeIdx === -1) return [];
 
-        for (const next of adj[node]) degree[next]--;
-    }
+        ret.push(zeroDegreeIdx);
+        indegree[zeroDegreeIdx]--; // de-dup;
 
-    return ret.reverse();
+        // relax adj
+        for (const adj of adjG[zeroDegreeIdx]) {
+            indegree[adj]--;
+        }
+    }
+    return ret;
 }

src/topological-sort/course-schedule-IV.ts

@@ -1,32 +1,31 @@
-function checkIfPrerequisite(
-    numCourses: number,
-    prerequisites: number[][],
-    queries: number[][]
-): boolean[] {
-    const N = numCourses;
-    const degree = Array.from({ length: N }, () => 0); // collect the outdegree;
-    const graph: number[][] = Array.from({ length: N }, () => []); // coleect avl incoming node;
-    const preSet: Set<number>[] = Array.from({ length: N }, () => new Set());
-    for (const pair of prerequisites) {
-        const [from, to] = pair;
-        graph[to].push(from);
-        degree[from]++;
+function checkIfPrerequisite(N: number, A: number[][], queries: number[][]): boolean[] {
+    const degree = Array.from({ length: N }, () => 0);
+    const adjG = Array.from<any, number[]>({ length: N }, () => []);
+
+    for (const [F, L] of A) {
+        degree[F]++;
+        //  adjG[F].push(L); --> only record direct graph to prevent break the inherit logic
+        adjG[L].push(F);
     }
 
-    // start from out degree 0 and keep collect the prerequisites
+    const sets = Array.from({ length: N }, () => new Set());
+
     for (let i = 0; i < N; i++) {
-        const start = degree.findIndex((val) => val === 0);
+        const start = degree.findIndex((deg) => deg === 0);
         if (start === -1) break;
-        degree[start]--;
-        const queue = Array.from(graph[start]);
-        while (queue.length !== 0) {
-            const node = queue.shift()!;
-            degree[node]--;
-            preSet[node].add(start);
-            for (const key of preSet[start]) {
-                preSet[node].add(key);
+
+        degree[start]--; // de-dup;
+
+        for (const adj of adjG[start]) {
+            degree[adj]--;
+            sets[adj].add(start);
+
+            // inherit the parent node's parents
+            for (const key of sets[start]) {
+                sets[adj].add(key);
             }
         }
     }
-    return queries.map((pair) => preSet[pair[0]].has(pair[1]));
+
+    return queries.map(([p1, p2]) => sets[p1].has(p2));
 }

src/topological-sort/course-schedule.ts

@@ -1,26 +1,20 @@
 function canFinish(N: number, A: number[][]): boolean {
-    // keep the in-degree state, and do the topological sort (relax the degree 0)
-
-    // initial in-degree state / adj graph
     const degree = Array.from({ length: N }, () => 0);
-    const adj: number[][] = Array.from({ length: N }, () => []);
+    const adjG: number[][] = Array.from({ length: N }, () => []);
 
-    for (const [from, to] of A) {
-        degree[to]++;
-        adj[from].push(to);
+    for (const [F, L] of A) {
+        degree[F]++;
+        adjG[F].push(L);
+        adjG[L].push(F);
     }
 
-    // do topological sort
     for (let i = 0; i < N; i++) {
-        // find the zero degree node
-        const node = degree.findIndex((val) => val === 0);
-        if (node === -1) return false;
+        const zDeg = degree.findIndex((deg) => deg === 0);
+        if (zDeg === -1) return false;
 
-        degree[node]--; // de-dup
+        degree[zDeg]--; // de-dup
 
-        for (const to of adj[node]) {
-            degree[to]--;
-        }
+        for (const adj of adjG[zDeg]) degree[adj]--; // relax adjacent nodes
     }
     return true;
 }