2문제 추가

Author: jdalma

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

jump-game/jdalma.kt

@@ -0,0 +1,54 @@
+package leetcode_study
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+import kotlin.math.max
+
+class `jump-game` {
+
+    fun canJump(nums: IntArray): Boolean {
+        return usingGreedy(nums)
+    }
+
+    /**
+     * TC: O(n), SC: O(1)
+     */
+    private fun usingGreedy(nums: IntArray): Boolean {
+        var reachable = 0
+        for (index in nums.indices) {
+            if (index > reachable) return false
+            reachable = max(reachable, index + nums[index])
+        }
+
+        return true
+    }
+
+    /**
+     * TC: O(n^2), SC: O(n)
+     */
+    private fun usingMemoization(nums: IntArray): Boolean {
+        val memo = IntArray(nums.size) { -1 }
+        fun dfs(now: Int): Boolean {
+            if (now >= nums.size - 1) {
+                return true
+            } else if (memo[now] != -1) {
+                return memo[now] != 0
+            }
+            for (next in 1 .. nums[now]) {
+                if (dfs(now + next)) {
+                    memo[now] = 1
+                    return true
+                }
+            }
+            memo[now] = 0
+            return false
+        }
+        return dfs(0)
+    }
+
+    @Test
+    fun `첫 번째 인덱스에서 마지막 인덱스에 도달할 수 있는지 여부를 반환한다`() {
+        canJump(intArrayOf(2,3,1,1,4)) shouldBe true
+        canJump(intArrayOf(3,2,1,0,4)) shouldBe false
+    }
+}