[tigermint] WEEK 04 Solutions (#2748)

* feat: WEEK 04 solution (merge-two-sorted-lists)

* feat: WEEK 04 solution (maximum-depth-of-binary-tree)

* feat: WEEK 04 solution (find-minimum-in-rotated-sorted-array)

* feat: WEEK 04 solution (word-search)

* feat: WEEK 04 solution (coin-change)

* refactor: WEEK 04 remove unnecessary non-null assertions (!!)

Author: tigermint

coin-change/tigermint.kt

@@ -0,0 +1,16 @@
+class Solution {
+    fun coinChange(coins: IntArray, amount: Int): Int {
+        val dp = IntArray(amount + 1) { amount + 1 }
+        dp[0] = 0
+
+        for (i in 1..amount) {
+            for (c in coins) {
+                if (i - c >= 0) {
+                    dp[i] = minOf(dp[i], dp[i - c] + 1)
+                }
+            }
+        }
+
+        return if (dp[amount] > amount) - 1 else dp[amount]
+    }
+}

find-minimum-in-rotated-sorted-array/tigermint.kt

@@ -0,0 +1,17 @@
+class Solution {
+    fun findMin(nums: IntArray): Int {
+        var left = 0
+        var right = nums.size - 1
+
+        while (left < right) {
+            val mid = (left + right) / 2
+
+            when {
+                nums[mid] > nums[right] -> left = mid + 1 // 오른쪽 존재
+                nums[mid] <= nums[right] -> right = mid // 왼쪽 존재 or 나 자신
+            }
+        }
+
+        return nums[left]
+    }
+}

maximum-depth-of-binary-tree/tigermint.kt

@@ -0,0 +1,30 @@
+/**
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun maxDepth(root: TreeNode?): Int {
+        if (root == null) return 0
+
+        var maxDepth = 0
+
+        fun dfs(node: TreeNode, depth: Int) {
+            //leaf node
+            if (node.left == null && node.right == null) maxDepth = maxOf(maxDepth, depth)
+
+            if (node.left != null) dfs(node.left!!, depth + 1)
+            if (node.right != null) dfs(node.right!!, depth + 1)
+        }
+
+        dfs(root, 1)
+
+        return maxDepth
+    }
+
+}

merge-two-sorted-lists/tigermint.kt

@@ -0,0 +1,33 @@
+/**
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+class Solution {
+    fun mergeTwoLists(list1: ListNode?, list2: ListNode?): ListNode? {
+        val head = ListNode(0)
+        var tail = head
+        var l1 = list1
+        var l2 = list2
+
+        while (l1 != null && l2 != null) {
+            if (l1.`val` <= l2.`val`) {
+                tail.next = l1
+                l1 = l1.next
+            } else {
+                tail.next = l2
+                l2 = l2.next
+            }
+
+            tail = tail.next!!
+        }
+
+        tail.next = l1 ?: l2
+
+        return head.next
+    }
+}

word-search/tigermint.kt

@@ -0,0 +1,53 @@
+class Solution {
+
+    private val dx = intArrayOf(-1, 1, 0, 0)
+    private val dy = intArrayOf(0, 0, -1, 1)
+
+    fun exist(board: Array<CharArray>, word: String): Boolean {
+        val rows = board.size
+        val cols = board[0].size
+        val visited = Array(rows) { BooleanArray(cols) }
+
+        val starts = mutableListOf<Pair<Int, Int>>()
+        for (i in 0 until rows) {
+            for (j in 0 until cols) {
+                if (board[i][j] == word[0]) starts.add(i to j)
+            }
+        }
+
+        if (word.length == 1) return starts.isNotEmpty()
+
+        var flag = false
+
+        fun dfs(start: Pair<Int, Int>, index: Int) {
+            if (flag) return
+            if (index == word.length - 1) {
+                flag = true
+                return
+            }
+
+            for (i in 0 until 4) {
+                val nx = start.first + dx[i]
+                val ny = start.second + dy[i]
+
+                if (nx < 0 || nx >= rows) continue
+                if (ny < 0 || ny >= cols) continue
+                if (visited[nx][ny]) continue
+                if (word[index + 1] != board[nx][ny]) continue
+
+                visited[nx][ny] = true
+                dfs(Pair(nx, ny), index + 1)
+                visited[nx][ny] = false
+            }
+        }
+
+        for (start in starts) {
+            visited[start.first][start.second] = true
+            dfs(start, 0)
+            visited[start.first][start.second] = false
+            if (flag) return true
+        }
+
+        return false
+    }
+}