Merge branch 'DaleStudy:main' into main

Author: wogha95

course-schedule/HC-kang.ts

@@ -0,0 +1,34 @@
+/**
+ * https://leetcode.com/problems/course-schedule/
+ * T.C. O(V + E)
+ * S.C. O(V + E)
+ */
+function canFinish(numCourses: number, prerequisites: number[][]): boolean {
+  const graph: number[][] = Array.from({ length: numCourses }, () => []);
+  for (const [course, pre] of prerequisites) {
+    graph[pre].push(course);
+  }
+
+  const visited = new Array(numCourses).fill(false);
+  const visiting = new Array(numCourses).fill(false);
+
+  const dfs = (course: number): boolean => {
+    if (visited[course]) return true;
+    if (visiting[course]) return false;
+
+    visiting[course] = true;
+    for (const neighbor of graph[course]) {
+      if (!dfs(neighbor)) return false;
+    }
+    visiting[course] = false;
+    visited[course] = true;
+
+    return true;
+  };
+
+  for (let i = 0; i < numCourses; i++) {
+    if (!visited[i] && !dfs(i)) return false;
+  }
+
+  return true;
+}

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/flynn.go

@@ -0,0 +1,65 @@
+/*
+풀이
+- 각 course를 node로 생각하고, prerequisite 관계에 있는 node를 간선으로 이어주면 단방향 간선으로 연결된 node 집합의 graph를 떠올릴 수 있습니다
+- 이 문제는 위에서 설명한 graph에 loop가 있냐 없느냐를 판단하는 문제입니다
+- 함수의 재귀호출 및 백트래킹을 이용해서 풀이할 수 있습니다
+
+Big O
+- N: 과목 수 (node의 개수)
+- M: 배열 prerequisites의 길이 (간선의 개수)
+- Time compleixty: O(N + M)
+  - prereqMap을 초기화 -> O(M)
+  - 함수의 재귀호출을 통해 우리는 각 node를 최대 한번씩 조회합니다 -> O(N)
+- Space complexity: O(N + M)
+  - prereqMap -> O(M)
+  - checkingSet, checkedSet -> O(N)
+*/
+
+func canFinish(numCourses int, prerequisites [][]int) bool {
+	// 주어진 prerequisites 배열로 `a_i: b_0, b_1, ...` 형태의 맵을 짭니다
+	prereqMap := make(map[int][]int, numCourses)
+	for _, pair := range prerequisites {
+		prereqMap[pair[0]] = append(prereqMap[pair[0]], pair[1])
+	}
+
+	// checkingSet으로 현재 탐색하고 있는 구간에 loop가 생겼는지 여부를 판단하고, checkedSet으로 이미 탐색한 node인지를 판단합니다
+	checkingSet, checkedSet := make(map[int]bool, 0), make(map[int]bool, 0)
+
+	// 특정 과목 c를 듣기 위한 선행 과목들을 탐색했을 때 loop가 생기는지 여부를 판단하는 함수입니다
+	// (Go 언어 특성상 L:20-21 처럼 함수를 선언합니다 (함수 내부에서 함수를 선언할 땐 익명 함수를 사용 + 해당 함수를 재귀호출하기 위해서 선언과 초기화를 분리))
+	var checkLoop func(int) bool // loop가 있다면 true
+	checkLoop = func(c int) bool {
+		// 과목 c가 현재 탐색하고 있는 구간에 존재한다면 loop가 있다고 판단 내릴 수 있습니다
+		_, checkingOk := checkingSet[c]
+		if checkingOk {
+			return true
+		}
+		// 과목 c가 이미 탐색이 완료된 과목이라면 과목 c를 지나는 하위 구간에는 loop가 없다고 판단할 수 있습니다
+		_, checkedOk := checkedSet[c]
+		if checkedOk {
+			return false
+		}
+		// 과목 c를 checkingSet에 추가합니다
+		// 만약 하위 구간에서 과목 c를 다시 만난다면 loop가 있다고 판단할 수 있습니다
+		checkingSet[c] = true
+		// 각 선행과목 별로 하위구간을 만들어 탐색을 진행합니다
+		// 하위구간 중 하나라도 loop가 발생하면 현재 구간에는 loop가 있다고 판단할 수 있습니다
+		for _, prereq := range prereqMap[c] {
+			if checkLoop(prereq) {
+				return true
+			}
+		}
+		// 만약 loop가 발견되지 않았다면 checkedSet에 과목 c를 추가함으로써 과목 c를 지나는 구간이 안전하다고 표시합니다
+		checkedSet[c] = true
+		// checkingSet에서 과목 c를 지워줍니다
+		delete(checkingSet, c)
+		return false
+	}
+
+	for i := 0; i < numCourses; i++ {
+		if checkLoop(i) {
+			return false
+		}
+	}
+	return true
+}

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

find-minimum-in-rotated-sorted-array/hwanmini.js

@@ -0,0 +1,32 @@
+// 시간복잡도: O(log n)
+// 공간복잡도: O(1)
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMin = function(nums) {
+    let leftIdx = 0;
+    let rightIdx = nums.length - 1;
+
+    if (nums.length === 1) return nums[0]
+
+    while (leftIdx <= rightIdx) {
+        if (nums[leftIdx] < nums[rightIdx]) return nums[leftIdx]
+
+        let midIdx = Math.floor((leftIdx + rightIdx) / 2);
+
+        if (nums[midIdx] > nums[midIdx+1]) {
+            return nums[midIdx+1]
+        }
+
+        if (nums[leftIdx] < nums[midIdx] && nums[leftIdx] > nums[rightIdx]) {
+            leftIdx = midIdx
+        } else {
+            rightIdx = midIdx
+        }
+    }
+
+    return nums[0]
+};
+