Merge pull request #1548 from HoonDongKang/main

[HoonDongKang] Week 10 Solutions

Author: HoonDongKang

course-schedule/HoonDongKang.ts

@@ -0,0 +1,42 @@
+/**
+ * [Problem]: [207] Course Schedule
+ * (https://leetcode.com/problems/course-schedule/description/)
+ */
+
+function canFinish(numCourses: number, prerequisites: number[][]): boolean {
+    // 시간복잡도 O(n+m)
+    // 공간복잡도 O(n+m)
+    function graphFunc(numCourses: number, prerequisites: number[][]): boolean {
+        const graph: number[][] = Array.from({ length: numCourses }, () => []);
+
+        for (const [course, prerequisite] of prerequisites) {
+            graph[prerequisite].push(course);
+        }
+
+        let traversing = new Array(numCourses).fill(false);
+        let visited = new Array(numCourses).fill(false);
+
+        function dfs(course: number): boolean {
+            if (traversing[course]) return false;
+            if (visited[course]) return true;
+
+            traversing[course] = true;
+            for (let pre of graph[course]) {
+                if (!dfs(pre)) {
+                    return false;
+                }
+            }
+
+            traversing[course] = false;
+            visited[course] = true;
+            return true;
+        }
+
+        for (let i = 0; i < numCourses; i++) {
+            if (!visited[i] && !dfs(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

invert-binary-tree/HoonDongKang.ts

@@ -0,0 +1,53 @@
+/**
+ * [Problem]: [226] Invert Binary Tree
+ * (https://leetcode.com/problems/invert-binary-tree/)
+ */
+
+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 invertTree(root: TreeNode | null): TreeNode | null {
+    // 시간복잡도 O(n)
+    // 공간복잡도 O(n)
+    function recursiveFunc(root: TreeNode | null): TreeNode | null {
+        if (root === null) {
+            return null;
+        }
+
+        const temp = root.left;
+        root.left = invertTree(root.right);
+        root.right = invertTree(temp);
+
+        return root;
+    }
+    // 시간복잡도 O(n)
+    // 공간복잡도 O(n)
+    function stackFunc(root: TreeNode | null): TreeNode | null {
+        if (root === null) {
+            return null;
+        }
+
+        const stack: Array<TreeNode | null> = [root];
+
+        while (stack.length > 0) {
+            const node = stack.pop()!;
+
+            if (node === null) {
+                continue;
+            }
+
+            [node.left, node.right] = [node.right, node.left];
+            stack.push(node.left, node.right);
+        }
+
+        return root;
+    }
+}

jump-game/HoonDongKang.ts

@@ -0,0 +1,71 @@
+/**
+ * [Problem]: [55] Jump Game
+ * (https://leetcode.com/problems/jump-game/description/)
+ */
+function canJump(nums: number[]): boolean {
+    // 시간복잡도 O(N^N)
+    // 공간복잡도 O(N)
+    // Time Limit Exceeded
+    function dfsFunc(nums: number[]): boolean {
+        function dfs(start: number): boolean {
+            if (start === nums.length - 1) return true;
+            for (let i = 1; i <= nums[start]; i++) {
+                if (dfs(start + i)) return true;
+            }
+            return false;
+        }
+        return dfs(0);
+    }
+    // 시간복잡도 O(N^2)
+    // 공간복잡도 O(N)
+    function dpFunc(nums: number[]): boolean {
+        const n = nums.length;
+        const dp = Array(n).fill(false);
+        dp[0] = true;
+
+        for (let i = 1; i < n; i++) {
+            for (let j = 0; j < i; j++) {
+                if (dp[j] && j + nums[j] >= i) {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+
+        return dp[n - 1];
+    }
+    // 시간복잡도 O(N^2)
+    // 공간복잡도 O(N)
+    function memoFunc(nums: number[]): boolean {
+        let memo = new Map<number, boolean>();
+
+        function dfs(start: number): boolean {
+            if (start === nums.length - 1) return true;
+            if (memo.has(start)) return memo.get(start)!;
+            for (let i = 1; i <= nums[start]; i++) {
+                if (dfs(start + i)) {
+                    memo.set(start, true);
+                    return true;
+                }
+            }
+
+            memo.set(start, false);
+            return false;
+        }
+
+        return dfs(0);
+    }
+
+    // 시간복잡도 O(N)
+    // 공간복잡도 O(1)
+    function greedyFunc(nums: number[]): boolean {
+        let reach = 0;
+        for (let i = 0; i < nums.length; i++) {
+            if (i <= reach) {
+                reach = Math.max(reach, i + nums[i]);
+            }
+        }
+
+        return nums.length - 1 <= reach;
+    }
+}

merge-k-sorted-lists/HoonDongKang.ts

@@ -0,0 +1,101 @@
+/**
+ * [Problem]: [23] Merge k Sorted Lists
+ * (https://leetcode.com/problems/merge-k-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 mergeKLists(lists: Array<ListNode | null>): ListNode | null {
+    //시간복잡도: O(n log n)
+    //공간복잡도: O(n)
+    function bruteForceFunc(lists: Array<ListNode | null>): ListNode | null {
+        const arr: number[] = [];
+        let dummy = new ListNode(0);
+        let current = dummy;
+
+        if (!lists.length) return null;
+
+        for (let i = 0; i < lists.length; i++) {
+            let currentNode = lists[i];
+            while (currentNode) {
+                arr.push(currentNode.val);
+                currentNode = currentNode.next;
+            }
+        }
+
+        arr.sort((a, b) => a - b);
+
+        for (let j = 0; j < arr.length; j++) {
+            current.next = new ListNode(arr[j]);
+            current = current.next;
+        }
+
+        return dummy.next;
+    }
+
+    //시간복잡도: O(nk)
+    //공간복잡도: O(n)
+    function mergeFunc(lists: Array<ListNode | null>): ListNode | null {
+        let dummy = new ListNode(0);
+        let cur = dummy;
+
+        while (lists.some((node) => node !== null)) {
+            let minVal = Infinity;
+            let minIdx = -1;
+
+            for (let i = 0; i < lists.length; i++) {
+                if (lists[i] && lists[i]!.val < minVal) {
+                    minVal = lists[i]!.val;
+                    minIdx = i;
+                }
+            }
+
+            if (minIdx !== -1) {
+                cur.next = new ListNode(minVal);
+                cur = cur.next;
+                lists[minIdx] = lists[minIdx]!.next;
+            }
+        }
+
+        return dummy.next;
+    }
+    //시간복잡도: O(n log k)
+    //공간복잡도: O(log k)
+    function divideAndConqureFunc(lists: Array<ListNode | null>): ListNode | null {
+        if (!lists.length) return null;
+        if (lists.length === 1) return lists[0];
+
+        const mid = Math.floor(lists.length / 2);
+        const left = divideAndConqureFunc(lists.slice(0, mid));
+        const right = divideAndConqureFunc(lists.slice(mid));
+
+        function mergeTwoLists(list1: ListNode | null, list2: ListNode | null): ListNode | null {
+            const dummy = new ListNode(-1);
+            let cur = dummy;
+
+            while (list1 && list2) {
+                if (list1.val < list2.val) {
+                    cur.next = list1;
+                    list1 = list1.next;
+                } else {
+                    cur.next = list2;
+                    list2 = list2.next;
+                }
+
+                cur = cur.next;
+            }
+
+            cur.next = list1 ?? list2;
+            return dummy.next;
+        }
+
+        return mergeTwoLists(left, right);
+    }
+}

search-in-rotated-sorted-array/HoonDongKang.ts

@@ -0,0 +1,32 @@
+/**
+ * [Problem]: [33] Search in Rotated Sorted Array
+ * (https://leetcode.com/problems/search-in-rotated-sorted-array/description/)
+ */
+function search(nums: number[], target: number): number {
+    //시간복잡도 O(log n)
+    //공간복잡도 O(1)
+    let left = 0;
+    let right = nums.length - 1;
+
+    while (left <= right) {
+        let mid = Math.floor((left + right) / 2);
+
+        if (nums[mid] === target) return mid;
+
+        if (nums[left] <= nums[mid]) {
+            if (nums[left] <= target && target < nums[mid]) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        } else {
+            if (nums[mid] < target && target <= nums[right]) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+    }
+
+    return -1;
+}