[HoonDongKang] Week 04 Solutions

coin-change/HoonDongKang.ts

@@ -0,0 +1,72 @@
+/**
+ * [Problem]: [322] Coin Change
+ *
+ * (https://leetcode.com/problems/coin-change/description/)
+ */
+function coinChange(coins: number[], amount: number): number {
+    // 시간복잡도: O(c^a)
+    // 공간복잡도: O(a)
+    // Time Exceed
+    function dfsFunc(coins: number[], amount: number): number {
+        if (!amount) return 0;
+        let result = dfs(amount);
+
+        return result <= amount ? result : -1;
+
+        function dfs(remain: number): number {
+            if (remain === 0) return 0;
+            if (remain < 0) return amount + 1;
+
+            let min_count = amount + 1;
+
+            for (let coin of coins) {
+                const result = dfs(remain - coin);
+                min_count = Math.min(min_count, result + 1);
+            }
+
+            return min_count;
+        }
+    }
+    // 시간복잡도: O(ca)
+    // 공간복잡도: O(a)
+    function dpFunc(coins: number[], amount: number): number {
+        const dp = new Array(amount + 1).fill(amount + 1);
+        dp[0] = 0;
+
+        for (let coin of coins) {
+            for (let i = coin; i <= amount; i++) {
+                dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+            }
+        }
+
+        return dp[amount] <= amount ? dp[amount] : -1;
+    }
+
+    // 시간복잡도: O(ca)
+    // 공간복잡도: O(a)
+    function memoizationFunc(coins: number[], amount: number): number {
+        const memo: Record<number, number> = {};
+
+        const result = dfs(amount);
+        return result <= amount ? result : -1;
+
+        function dfs(remain: number): number {
+            if (remain === 0) return 0;
+            if (remain < 0) return amount + 1;
+            if (remain in memo) return memo[remain];
+
+            let min_count = amount + 1;
+
+            for (let coin of coins) {
+                const res = dfs(remain - coin);
+                min_count = Math.min(min_count, res + 1);
+            }
+
+            memo[remain] = min_count;
+
+            return min_count;
+        }
+    }
+
+    return memoizationFunc(coins, amount);
+}

find-minimum-in-rotated-sorted-array/HoonDongKang.ts

@@ -0,0 +1,32 @@
+/**
+ * [Problem]: [153] Find Minimum in Rotated Sorted Array
+ *
+ * (https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/)
+ */
+
+function findMin(nums: number[]): number {
+    // 실제 Submit은 되나, 문제의 의도와 다름
+    function ggomsuFunc(nums: number[]): number {
+        return Math.min(...nums);
+    }
+
+    //시간복잡도 O(logn)
+    //공간복잡도 O(1)
+    function binarySearchFunc(nums: number[]): number {
+        let left = 0;
+        let right = nums.length - 1;
+
+        while (left < right) {
+            const mid = Math.floor((left + right) / 2);
+            if (nums[mid] > nums[right]) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+
+        return nums[left];
+    }
+
+    return binarySearchFunc(nums);
+}

maximum-depth-of-binary-tree/HoonDongKang.ts

@@ -0,0 +1,46 @@
+/**
+ * [Problem]: [104] Maximum Depth of Binary Tree
+ *
+ * (https://leetcode.com/problems/maximum-depth-of-binary-tree/description/)
+ */
+
+class TreeNode {
+    val: number;
+    left: TreeNode | null;
+    right: TreeNode | null;
+    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+        this.val = val === undefined ? 0 : val;
+        this.left = left === undefined ? null : left;
+        this.right = right === undefined ? null : right;
+    }
+}
+
+function maxDepth(root: TreeNode | null): number {
+    //시간복잡도 O(n)
+    //공간복잡도 O(n)
+    function stackFunc(root: TreeNode | null): number {
+        if (!root) return 0;
+        let max = 0;
+        const stack: [TreeNode, number][] = [[root, 1]];
+
+        while (stack.length > 0) {
+            const [node, depth] = stack.pop()!;
+            max = Math.max(max, depth);
+
+            if (node.left) stack.push([node.left, depth + 1]);
+            if (node.right) stack.push([node.right, depth + 1]);
+        }
+
+        return max;
+    }
+
+    //시간복잡도 O(n)
+    //공간복잡도 O(n)
+    function recursiveFunc(root: TreeNode | null): number {
+        if (!root) return 0;
+
+        return 1 + Math.max(recursiveFunc(root.left), recursiveFunc(root.right));
+    }
+
+    return recursiveFunc(root);
+}

merge-two-sorted-lists/HoonDongKang.ts

@@ -0,0 +1,56 @@
+/**
+ * [Problem]: [21] Merge Two Sorted Lists
+ *
+ * (https://leetcode.com/problems/merge-two-sorted-lists/description/)
+ */
+
+class ListNode {
+    val: number;
+    next: ListNode | null;
+    constructor(val?: number, next?: ListNode | null) {
+        this.val = val === undefined ? 0 : val;
+        this.next = next === undefined ? null : next;
+    }
+}
+
+function mergeTwoLists(list1: ListNode | null, list2: ListNode | null): ListNode | null {
+    //시간복잡도 O(m+n)
+    //공간복잡도 O(1)
+    function loopFunc(list1: ListNode | null, list2: ListNode | null): ListNode | null {
+        let current: ListNode = new ListNode();
+        let dummy = current;
+
+        while (list1 !== null && list2 !== null) {
+            if (list1.val < list2.val) {
+                current.next = list1;
+                list1 = list1.next;
+            } else {
+                current.next = list2;
+                list2 = list2.next;
+            }
+
+            current = current.next;
+        }
+
+        current.next = list1 !== null ? list1 : list2;
+
+        return dummy.next;
+    }
+
+    //시간복잡도 O(m+n)
+    //공간복잡도 O(m+n)
+    function recursionFunc(list1: ListNode | null, list2: ListNode | null): ListNode | null {
+        if (list1 === null) return list2;
+        if (list2 === null) return list1;
+
+        if (list1.val < list2.val) {
+            list1.next = recursionFunc(list1.next, list2);
+            return list1;
+        } else {
+            list2.next = recursionFunc(list1, list2.next);
+            return list2;
+        }
+    }
+
+    return recursionFunc(list1, list2);
+}

word-search/HoonDongKang.ts

@@ -0,0 +1,83 @@
+/**
+ * [Problem]: [79] Word Search
+ *
+ * (https://leetcode.com/problems/word-search/description/)
+ */
+
+function exist(board: string[][], word: string): boolean {
+    //시간복잡도 O(m * n * 4^w)
+    //공간복잡도 O(w)
+    function dfsChangingBoard(board: string[][], word: string): boolean {
+        const rows = board.length;
+        const cols = board[0].length;
+
+        for (let i = 0; i < rows; i++) {
+            for (let j = 0; j < cols; j++) {
+                if (dfs(i, j, 0)) return true;
+            }
+        }
+
+        return false;
+
+        function dfs(i: number, j: number, k: number): boolean {
+            if (k === word.length) return true;
+
+            if (i < 0 || j < 0) return false;
+            if (i >= rows || j >= cols) return false;
+            if (board[i][j] !== word[k]) return false;
+
+            const temp = board[i][j];
+            board[i][j] = "";
+
+            const result =
+                dfs(i + 1, j, k + 1) ||
+                dfs(i - 1, j, k + 1) ||
+                dfs(i, j + 1, k + 1) ||
+                dfs(i, j - 1, k + 1);
+
+            board[i][j] = temp;
+            return result;
+        }
+    }
+
+    //시간복잡도 O(m * n * 4^w)
+    //공간복잡도 O(w)
+    function dfsMaintainingBoard(board: string[][], word: string): boolean {
+        const rows = board.length;
+        const cols = board[0].length;
+
+        // array보다 Set<string>이 더 효율적
+        // Set.has: O(1)  / Array.includes: O(n)
+        const passed = new Set<string>();
+
+        for (let i = 0; i < rows; i++) {
+            for (let j = 0; j < cols; j++) {
+                if (dfs(i, j, 0)) return true;
+            }
+        }
+
+        return false;
+
+        function dfs(i: number, j: number, k: number): boolean {
+            if (k === word.length) return true;
+
+            if (i < 0 || j < 0) return false;
+            if (i >= rows || j >= cols) return false;
+            if (board[i][j] !== word[k]) return false;
+            if (passed.has(`${i},${j}`)) return false;
+
+            passed.add(`${i},${j}`);
+
+            const result =
+                dfs(i + 1, j, k + 1) ||
+                dfs(i - 1, j, k + 1) ||
+                dfs(i, j + 1, k + 1) ||
+                dfs(i, j - 1, k + 1);
+
+            passed.delete(`${i},${j}`);
+            return result;
+        }
+    }
+
+    return dfsMaintainingBoard(board, word);
+}