Merge branch 'DaleStudy:main' into main

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/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;
+};

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/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)

invert-binary-tree/jdalma.kt

@@ -0,0 +1,58 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class `invert-binary-tree` {
+
+    fun invertTree(root: TreeNode?): TreeNode? {
+        if (root == null) return null
+
+        return usingStack(root)
+    }
+
+    /**
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingDFS(node: TreeNode?): TreeNode? {
+        if (node == null) return null
+
+        val (left, right) = node.left to node.right
+        node.left = usingDFS(right)
+        node.right = usingDFS(left)
+
+        return node
+    }
+
+    /**
+     * TC: O(n), SC: O(n)
+     */
+    private fun usingStack(node: TreeNode): TreeNode {
+        val stack= ArrayDeque<TreeNode>().apply {
+            this.add(node)
+        }
+
+        while (stack.isNotEmpty()) {
+            val now = stack.removeLast()
+            val tmp = now.left
+            now.left = now.right
+            now.right = tmp
+
+            now.left?.let { stack.add(it) }
+            now.right?.let { stack.add(it) }
+        }
+        return node
+    }
+
+    @Test
+    fun `전달된 노드의 하위 노드들의 반전된 값을 반환한다`() {
+        val actual = TreeNode.of(4,2,7,1,3,6,9)
+        val expect = TreeNode.of(4,7,2,9,6,3,1)
+        invertTree(actual) shouldBe expect
+
+        val actual1 = TreeNode.of(1,2)
+        val expect1 = TreeNode.of(1,null,2)
+
+        invertTree(actual1) shouldBe expect1
+    }
+}

invert-binary-tree/sunjae95.js

@@ -0,0 +1,23 @@
+/**
+ * @description
+ * brainstorming:
+ * preorder traverse
+ *
+ * n = length of root
+ * time complexity: O(n)
+ * space complexity: O(n)
+ */
+var invertTree = function (root) {
+  const preOrder = (tree) => {
+    if (tree === null) return null;
+
+    const currentNode = new TreeNode(tree.val);
+
+    currentNode.right = preOrder(tree.left);
+    currentNode.left = preOrder(tree.right);
+
+    return currentNode;
+  };
+
+  return preOrder(root);
+};

jump-game/TonyKim9401.java

@@ -0,0 +1,13 @@
+// TC: O(n)
+// SC: O(1)
+class Solution {
+    public boolean canJump(int[] nums) {
+        int jump = 0;
+
+        for (int i = 0; i < nums.length; i++) {
+            if (i > jump) return false;
+            jump = Math.max(jump, i + nums[i]);
+        }
+        return true;
+    }
+}

jump-game/haklee.py

@@ -0,0 +1,44 @@
+"""TC: O(n), SC: O(1)
+
+n은 주어진 리스트의 길이
+
+아이디어:
+- 끝에 있는 아이템부터 시작해서 '최소 어디까지는 도달해야 끝 칸까지 점프 가능한지'를 업데이트 한다.
+- example들로 이해해보자. index는 0부터 시작.
+    - example 1: [2,3,1,1,4]
+        - 4번째 칸에 도달할 수 있으면 성공이다. reach_at_least 값을 4로 초기화 한다.
+        - 3번째 칸에서는 최대 4번째 칸까지 갈 수 있다. 즉, 적어도 3번 칸까지 가면 성공이므로
+        reach_at_least를 3으로 업데이트 한다.
+        - 2번째 칸에서는 최대 3번째 칸까지 갈 수 있다. reach_at_least를 2로 업데이트 한다.
+        - 1번째 칸에서는 최대 1+3=4번째 칸까지 갈 수 있다. 이 칸에서 현 reach_at_least 값인 2번째 칸까지
+        충분히 갈 수 있으므로 reach_at_least 값을 1로 업데이트 한다.
+        - 0번째 칸에서는 최대 0+2=2번째 칸까지 갈 수 있다. 현 reach_at_least 값인 1번째 칸까지 충분히
+        갈 수 있으므로 reach_at_least 값을 0으로 업데이트 한다.
+        - 0번째 칸에서 끝 칸까지 갈 수 있다.
+    - example 2: [3,2,1,0,4]
+        - 4번째 칸에 도달할 수 있으면 성공이다. reach_at_least 값을 4로 초기화 한다.
+        - 3번째 칸에서는 최대 3번째 칸까지 갈 수 있다. 여기서는 현 reach_at_least 값인 4까지 갈 수 없으니
+          아무 일도 일어나지 않는다.
+        - 2번째 칸에서는 최대 2+1=3번째 칸까지 갈 수 있다. 여기서도 현 reach_at_least 값인 4까지 갈 수 없고,
+          아무 일도 일어나지 않는다.
+        - 1번째 칸에서는 최대 1+2=3번째 칸까지 갈 수 있다. 비슷하게 아무 일도 일어나지 않는다.
+        - 0번째 칸에서는 최대 0+3=3번째 칸까지 갈 수 있다. 비슷하게 아무 일도 일어나지 않는다.
+        - reach_at_least 값이 0이 아니다. 즉, 0번째 칸에서는 끝 칸까지 갈 수 없다.
+
+SC:
+- reach_at_least 값에 인덱스 하나만 관리한다. 즉, O(1).
+
+TC:
+- nums의 끝에서 두 번째 아이템부터 첫 번째 아이템까지 순차적으로 접근하면서 reach_at_least값을 업데이트 한다. O(n).
+"""
+
+
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        reach_at_least = len(nums) - 1
+
+        for i in range(len(nums) - 2, -1, -1):
+            if nums[i] + i >= reach_at_least:
+                reach_at_least = i
+
+        return reach_at_least == 0