From bdba92dceea15a4f138e7431310633c2719ac3d5 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Mon, 21 Apr 2025 15:04:53 +0900 Subject: [PATCH 1/8] Add Merge Two Sorted Lists solution --- merge-two-sorted-lists/HoonDongKang.ts | 56 ++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 merge-two-sorted-lists/HoonDongKang.ts diff --git a/merge-two-sorted-lists/HoonDongKang.ts b/merge-two-sorted-lists/HoonDongKang.ts new file mode 100644 index 000000000..c291b5e0e --- /dev/null +++ b/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); +} From 2a1b4dc425e5522f72e7614cdbaf788e4833b322 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Tue, 22 Apr 2025 13:17:21 +0900 Subject: [PATCH 2/8] add Maximum Depth of Binary Tree solution --- maximum-depth-of-binary-tree/HoonDongKang.ts | 46 ++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 maximum-depth-of-binary-tree/HoonDongKang.ts diff --git a/maximum-depth-of-binary-tree/HoonDongKang.ts b/maximum-depth-of-binary-tree/HoonDongKang.ts new file mode 100644 index 000000000..da8051af1 --- /dev/null +++ b/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); +} From dc1b06e7e64cc1d8d52de97aed4a9f4a6df7d66e Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Wed, 23 Apr 2025 13:55:08 +0900 Subject: [PATCH 3/8] add Find Minimum in Rotated Sorted Array solution --- .../ HoonDongKang.ts | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 find-minimum-in-rotated-sorted-array/ HoonDongKang.ts diff --git a/find-minimum-in-rotated-sorted-array/ HoonDongKang.ts b/find-minimum-in-rotated-sorted-array/ HoonDongKang.ts new file mode 100644 index 000000000..fb7690c1c --- /dev/null +++ b/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); +} From e140ac1ff9d0b9a5f60bc61bb88e63328375488d Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Thu, 24 Apr 2025 13:43:40 +0900 Subject: [PATCH 4/8] fix linelint --- find-minimum-in-rotated-sorted-array/ HoonDongKang.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/find-minimum-in-rotated-sorted-array/ HoonDongKang.ts b/find-minimum-in-rotated-sorted-array/ HoonDongKang.ts index fb7690c1c..29bb4b6ea 100644 --- a/find-minimum-in-rotated-sorted-array/ HoonDongKang.ts +++ b/find-minimum-in-rotated-sorted-array/ HoonDongKang.ts @@ -29,4 +29,4 @@ function findMin(nums: number[]): number { } return binarySearchFunc(nums); -} +}; From a54daa33dd331007e8ae22920a4d43bae434e4a8 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Thu, 24 Apr 2025 13:44:52 +0900 Subject: [PATCH 5/8] fix linelint --- find-minimum-in-rotated-sorted-array/ HoonDongKang.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/find-minimum-in-rotated-sorted-array/ HoonDongKang.ts b/find-minimum-in-rotated-sorted-array/ HoonDongKang.ts index 29bb4b6ea..fb7690c1c 100644 --- a/find-minimum-in-rotated-sorted-array/ HoonDongKang.ts +++ b/find-minimum-in-rotated-sorted-array/ HoonDongKang.ts @@ -29,4 +29,4 @@ function findMin(nums: number[]): number { } return binarySearchFunc(nums); -}; +} From 52df6bb1ed6728f52973990925a3723fe91bf0d2 Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Thu, 24 Apr 2025 13:48:13 +0900 Subject: [PATCH 6/8] fix: remove leading space in file name --- .../{ HoonDongKang.ts => HoonDongKang.ts} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename find-minimum-in-rotated-sorted-array/{ HoonDongKang.ts => HoonDongKang.ts} (100%) diff --git a/find-minimum-in-rotated-sorted-array/ HoonDongKang.ts b/find-minimum-in-rotated-sorted-array/HoonDongKang.ts similarity index 100% rename from find-minimum-in-rotated-sorted-array/ HoonDongKang.ts rename to find-minimum-in-rotated-sorted-array/HoonDongKang.ts From 8fee1b1ef55b30f3cefcc91e77efe1af4328b34d Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Thu, 24 Apr 2025 15:19:20 +0900 Subject: [PATCH 7/8] add Word Search --- word-search/HoonDongKang.ts | 83 +++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 word-search/HoonDongKang.ts diff --git a/word-search/HoonDongKang.ts b/word-search/HoonDongKang.ts new file mode 100644 index 000000000..15502a6b5 --- /dev/null +++ b/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이 더 효율적 + // Set.has: O(1) / Array.includes: O(n) + const passed = new Set(); + + 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); +} From 7eecb662bccdb7a6ff7a447a6ec4675ad6fb2ccb Mon Sep 17 00:00:00 2001 From: HoonDongKang Date: Fri, 25 Apr 2025 12:04:41 +0900 Subject: [PATCH 8/8] add Coin Change solution --- coin-change/HoonDongKang.ts | 72 +++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 coin-change/HoonDongKang.ts diff --git a/coin-change/HoonDongKang.ts b/coin-change/HoonDongKang.ts new file mode 100644 index 000000000..babbdc2d5 --- /dev/null +++ b/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 = {}; + + 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); +}