Merge pull request #1643 from eunhwa99/main

[eunhwa99] WEEK 14 solutions

Author: eunhwa99

binary-tree-level-order-traversal/eunhwa99.kt

@@ -0,0 +1,33 @@
+// https://leetcode.com/problems/binary-tree-level-order-traversal/description/
+/**
+ * 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 levelOrder(root: TreeNode?): List<List<Int>> {
+        val result = mutableListOf<List<Int>>()
+        if(root == null) return result
+
+        val queue: ArrayDeque<TreeNode> = ArrayDeque()
+        queue.add(root)
+        
+        while (queue.isNotEmpty()) {
+            val levelSize = queue.size
+            val level = mutableListOf<Int>()
+            repeat(levelSize) {
+                val node = queue.removeFirst()
+                level.add(node.`val`)
+                node.left?.let { queue.add(it) }
+                node.right?.let { queue.add(it) }
+            }
+            result.add(level)
+        }
+        return result
+    }
+}

house-robber-ii/eunhwa99.kt

@@ -0,0 +1,19 @@
+// https://leetcode.com/problems/house-robber-ii/description/
+class Solution {
+    fun rob(nums: IntArray): Int {
+        if (nums.size == 1) return nums[0]
+        return maxOf(rob(nums, 0, nums.size - 2), rob(nums, 1, nums.size - 1))
+    }
+
+    private fun rob(nums: IntArray, start: Int, end: Int): Int {
+        val dp = IntArray(nums.size) { 0 }
+        dp[start] = nums[start]
+        dp[start + 1] = maxOf(nums[start], nums[start + 1])
+        for (i in start + 2..end) {
+            dp[i] = maxOf(dp[i - 1], dp[i - 2] + nums[i])
+        }
+        return dp[end]
+    }
+}
+// TC: O(n)
+// SC: O(n)