Merge branch 'main' of https://github.com/HC-kang/leetcode-study

Author: HC-kang

course-schedule/TonyKim9401.java

@@ -0,0 +1,37 @@
+// TC: O(n + p)
+// n -> number of courses, p -> the length of prerequisites
+// SC: O(n + m)
+// n -> the length of the graph size, m -> the length of nested list's size
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        List<List<Integer>> graph = new ArrayList<>();
+        int[] inDegree = new int[numCourses];
+
+        for (int i = 0; i < numCourses; i++) graph.add(new ArrayList<>());
+
+        for (int[] prerequisite : prerequisites) {
+            int course = prerequisite[0];
+            int pre = prerequisite[1];
+            graph.get(pre).add(course);
+            inDegree[course] += 1;
+        }
+
+        Queue<Integer> q = new LinkedList<>();
+        for (int i = 0; i < numCourses; i++) {
+            if (inDegree[i] == 0) q.offer(i);
+        }
+
+        int visitedCourses = 0;
+        while (!q.isEmpty()) {
+            int course = q.poll();
+            visitedCourses += 1;
+
+            for (int nextCourse : graph.get(course)) {
+                inDegree[nextCourse] -= 1;
+                if (inDegree[nextCourse] == 0) q.offer(nextCourse);
+            }
+        }
+
+        return visitedCourses == numCourses;
+    }
+}

course-schedule/haklee.py

@@ -0,0 +1,31 @@
+"""TC: O(node + edge), SC: O(node + edge)
+
+유명한 위상 정렬 알고리즘이므로 설명은 생략한다.
+"""
+
+
+class Solution:
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        # 위상 정렬.
+
+        # init
+        adj_list = [[] for _ in range(numCourses)]  # SC: O(edge)
+        in_deg = [0] * numCourses  # SC: O(node)
+
+        for edge in prerequisites:
+            adj_list[edge[0]].append(edge[1])
+            in_deg[edge[1]] += 1
+
+        node_to_search = [i for i, v in enumerate(in_deg) if v == 0]  # TC: O(node)
+        sorted_list = []
+
+        # process
+        while node_to_search:
+            cur = node_to_search.pop()  # TC: 최악의 경우 총 O(node)만큼 실행
+            sorted_list.append(cur)
+            for node in adj_list[cur]:
+                in_deg[node] -= 1  # TC: 최악의 경우 총 O(edge)만큼 실행
+                if in_deg[node] == 0:
+                    node_to_search.append(node)
+
+        return len(sorted_list) == numCourses

course-schedule/jdalma.kt

@@ -0,0 +1,79 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class `course-schedule` {
+
+    /**
+     * TC: O(node + edge), SC: O(node + edge)
+     */
+    fun canFinish(numCourses: Int, prerequisites: Array<IntArray>): Boolean {
+        if (prerequisites.isEmpty()) return true
+
+        return usingTopologySort(numCourses, prerequisites)
+    }
+
+    private fun usingTopologySort(numCourses: Int, prerequisites: Array<IntArray>): Boolean {
+        val adj = List(numCourses) { mutableListOf<Int>() }
+        val degree = IntArray(numCourses)
+        for (e in prerequisites) {
+            val (course, pre) = e[0] to e[1]
+            adj[pre].add(course)
+            degree[course]++
+        }
+
+        val queue = ArrayDeque<Int>().apply {
+            degree.forEachIndexed { index, i ->
+                if (i == 0) {
+                    this.add(index)
+                }
+            }
+        }
+
+        var answer = 0
+        while (queue.isNotEmpty()) {
+            val now = queue.removeFirst()
+            answer++
+
+            queue.addAll(adj[now].filter { --degree[it] == 0 })
+        }
+
+        return answer == numCourses
+    }
+
+    @Test
+    fun `코스의 개수와 코스 간 의존성을 전달하면 코스를 완료할 수 있는지 여부를 반환한다`() {
+        canFinish(5,
+            arrayOf(
+                intArrayOf(0,1),
+                intArrayOf(0,2),
+                intArrayOf(1,3),
+                intArrayOf(1,4),
+                intArrayOf(3,4)
+            )
+        ) shouldBe true
+        canFinish(5,
+            arrayOf(
+                intArrayOf(1,4),
+                intArrayOf(2,4),
+                intArrayOf(3,1),
+                intArrayOf(3,2)
+            )
+        ) shouldBe true
+        canFinish(2, arrayOf(intArrayOf(1, 0))) shouldBe true
+        canFinish(2, arrayOf(intArrayOf(1, 0), intArrayOf(0, 1))) shouldBe false
+        canFinish(20,
+            arrayOf(
+                intArrayOf(0,10),
+                intArrayOf(3,18),
+                intArrayOf(5,5),
+                intArrayOf(6,11),
+                intArrayOf(11,14),
+                intArrayOf(13,1),
+                intArrayOf(15,1),
+                intArrayOf(17,4)
+            )
+        ) shouldBe false
+    }
+}

course-schedule/kayden.py

@@ -0,0 +1,33 @@
+from collections import deque
+class Solution:
+    # 시간복잡도: O(numCourses + prerequisites의 길이)
+    # 공간복잡도: O(numCourses + prerequisites의 길이)
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+
+        reachable = [0 for _ in range(numCourses)]
+        graph = [[] for _ in range(numCourses)]
+
+        for a, b in prerequisites:
+            reachable[a] += 1
+            graph[b].append(a)
+
+        q = deque()
+        visited = set()
+        for i in range(numCourses):
+            if reachable[i] == 0:
+                q.append(i)
+                visited.add(i)
+
+        while q:
+            node = q.popleft()
+
+            for next_node in graph[node]:
+                reachable[next_node] -= 1
+                if next_node not in visited and reachable[next_node] == 0:
+                    q.append(next_node)
+                    visited.add(next_node)
+
+        if len(visited) == numCourses:
+            return True
+
+        return False

course-schedule/sunjae95.js

@@ -0,0 +1,47 @@
+/**
+ * @description
+ * memoization + dfs
+ *
+ * n = length of nums
+ * p = length of prerequisites
+ *
+ * time complexity: O(n)
+ * space complexity: O(p)
+ */
+var canFinish = function (numCourses, prerequisites) {
+  const memo = Array.from({ length: numCourses + 1 }, () => false);
+  const visited = Array.from({ length: numCourses + 1 }, () => false);
+  // graph setting
+  const graph = prerequisites.reduce((map, [linkedNode, current]) => {
+    const list = map.get(current) ?? [];
+    list.push(linkedNode);
+    map.set(current, list);
+    return map;
+  }, new Map());
+
+  const dfs = (current) => {
+    const linkedNode = graph.get(current);
+
+    if (memo[current] || !linkedNode || linkedNode.length === 0) return true;
+
+    for (const node of linkedNode) {
+      if (visited[node]) return false;
+
+      visited[node] = true;
+      if (!dfs(node)) return false;
+      visited[node] = false;
+      memo[node] = true;
+    }
+
+    return true;
+  };
+
+  for (const [current] of graph) {
+    visited[current] = true;
+    if (!dfs(current)) return false;
+    visited[current] = false;
+    memo[current] = true;
+  }
+
+  return true;
+};

course-schedule/wogha95.js

@@ -0,0 +1,49 @@
+/**
+ * TC: O(V + E)
+ * SC: O(V + E)
+ * N: numCourses(all of vertex), P: prerequisites(all of edge)
+ */
+
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+var canFinish = function (numCourses, prerequisites) {
+  const STEP = {
+    before: 0,
+    ing: 1,
+    after: 2,
+  };
+  const stepBoard = Array.from({ length: numCourses }, () => STEP.before);
+  const board = Array.from({ length: numCourses }, () => []);
+
+  for (const [a, b] of prerequisites) {
+    board[a].push(b);
+  }
+
+  for (let index = 0; index < numCourses; index++) {
+    if (isCycle(index)) {
+      return false;
+    }
+  }
+  return true;
+
+  function isCycle(current) {
+    if (stepBoard[current] === STEP.end) {
+      return false;
+    }
+    if (stepBoard[current] === STEP.ing) {
+      return true;
+    }
+
+    stepBoard[current] = STEP.ing;
+    for (const next of board[current]) {
+      if (isCycle(next)) {
+        return true;
+      }
+    }
+    stepBoard[current] = STEP.end;
+    return false;
+  }
+};

invert-binary-tree/TonyKim9401.java

@@ -0,0 +1,16 @@
+// TC: O(n)
+// -> visit all nodes to invert
+// SC: O(n)
+// -> create all nodes again to exchange
+class Solution {
+    public TreeNode invertTree(TreeNode root) {
+        if (root == null) return null;
+        invertTree(root.left);
+        invertTree(root.right);
+        TreeNode left = root.left;
+        TreeNode right = root.right;
+        root.left = right;
+        root.right = left;
+        return root;
+    }
+}

invert-binary-tree/gitsunmin.ts

@@ -0,0 +1,34 @@
+/**
+ * https://leetcode.com/problems/invert-binary-tree/
+ * time complexity : O(n)
+ * space complexity : O(log N)
+ */
+
+class TreeNode {
+    val: number
+    left: TreeNode | null
+    right: TreeNode | null
+    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+        this.val = (val === undefined ? 0 : val)
+        this.left = (left === undefined ? null : left)
+        this.right = (right === undefined ? null : right)
+    }
+}
+
+export const dfs = (root: TreeNode | null, inverted: TreeNode | null): TreeNode | null => {
+    if (!root) return null;
+
+    const left = dfs(root.left, inverted);
+    const right = dfs(root.right, inverted);
+
+    root.left = right;
+    root.right = left;
+
+    return root;
+};
+
+function invertTree(root: TreeNode | null): TreeNode | null {
+    if (!root) return null;
+
+    return dfs(root, new TreeNode(0));
+};

invert-binary-tree/haklee.py

@@ -0,0 +1,32 @@
+"""TC: O(n), SC: O(h)
+
+h는 이진 트리의 높이. 
+n이 전체 노드 개수라고 할때
+- 최악의 경우 한 쪽 자식 노드만 채워짐. 이 경우 h = n.
+- 최선의 경우 완전 이진 트리. h = log(n).
+
+아이디어:
+양쪽 자식 노드에 접근해서 재귀적으로 invert를 진행하고, 두 자식 노드를 바꾼다.
+
+SC:
+- 호출 스택 깊이는 트리의 깊이까지 깊어질 수 있다. 즉, O(h).
+
+TC:
+- 모든 노드에 접근. O(n).
+"""
+
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        def invert(node: Optional[TreeNode]) -> None:
+            if node is not None:
+                node.left, node.right = invert(node.right), invert(node.left)
+            return node
+
+        return invert(root)