From d4daa7b9e3c0a55c81a4128b2a6c33900ce25319 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E1=84=8C=E1=85=A9=E1=84=92=E1=85=A8=E1=84=85=E1=85=B5?= =?UTF-8?q?=E1=86=AB?= Date: Thu, 2 Oct 2025 18:23:35 +0900 Subject: [PATCH 1/5] missing number solution --- missing-number/hyer0705.ts | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 missing-number/hyer0705.ts diff --git a/missing-number/hyer0705.ts b/missing-number/hyer0705.ts new file mode 100644 index 0000000000..d7800fd814 --- /dev/null +++ b/missing-number/hyer0705.ts @@ -0,0 +1,22 @@ +// Time Complexity: O(n) +// Space Complexity: O(1) +function missingNumber(nums: number[]): number { + const n = nums.length; + + const expectedSum = (n * (n + 1)) / 2; + const currentSum = nums.reduce((acc, curr) => acc + curr, 0); + + return expectedSum - currentSum; +} + +// Time Complexity: O(n^2) +// Space Complexity: O(1) +function missingNumber(nums: number[]): number { + const n = nums.length; + + for (let i = 0; i <= n; i++) { + if (!nums.includes(i)) return i; + } + + return -1; +} From 48385f4227456354b1007c6d83738ea210eaad1d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E1=84=8C=E1=85=A9=E1=84=92=E1=85=A8=E1=84=85=E1=85=B5?= =?UTF-8?q?=E1=86=AB?= Date: Thu, 2 Oct 2025 18:53:32 +0900 Subject: [PATCH 2/5] reorder list solution --- reorder-list/hyer0705.ts | 56 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 reorder-list/hyer0705.ts diff --git a/reorder-list/hyer0705.ts b/reorder-list/hyer0705.ts new file mode 100644 index 0000000000..d63c586815 --- /dev/null +++ b/reorder-list/hyer0705.ts @@ -0,0 +1,56 @@ +/** + * Definition for singly-linked list. + * 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) + * } + * } + */ + +// Time Complexity: O(n) +// Space Complexity: O(1) +/** + Do not return anything, modify head in-place instead. + */ +function reorderList(head: ListNode | null): void { + if (!head || !head.next || !head.next.next) return; + + let slow: ListNode | null = head; + let fast: ListNode | null = head; + + // find central node + while (fast && fast.next) { + slow = slow.next; + fast = fast.next.next; + } + + let secondHalf = slow.next; + slow.next = null; + + // reverse secondHalf + let prev = null; + let curr = secondHalf; + while (curr) { + const nextTemp = curr.next; + curr.next = prev; + prev = curr; + curr = nextTemp; + } + + let first = head; + let second = prev; + + while (second) { + const firstNext = first.next; + const secondNext = second.next; + + first.next = second; + second.next = firstNext; + + first = firstNext; + second = secondNext; + } +} From 791953690a13195955203664abc79cdbad916381 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E1=84=8C=E1=85=A9=E1=84=92=E1=85=A8=E1=84=85=E1=85=B5?= =?UTF-8?q?=E1=86=AB?= Date: Thu, 2 Oct 2025 23:00:36 +0900 Subject: [PATCH 3/5] graph valid tree solution --- graph-valid-tree/hyer0705.ts | 39 ++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 graph-valid-tree/hyer0705.ts diff --git a/graph-valid-tree/hyer0705.ts b/graph-valid-tree/hyer0705.ts new file mode 100644 index 0000000000..6f5aca9520 --- /dev/null +++ b/graph-valid-tree/hyer0705.ts @@ -0,0 +1,39 @@ +// Time Complexity: O(n) +// Space Complexity: O(n) +export class Solution { + /** + * @param n: An integer + * @param edges: a list of undirected edges + * @return: true if it's a valid tree, or false + */ + validTree(n: number, edges: number[][]): boolean { + if (n === 0) return true; + if (edges.length !== n - 1) return false; + + const graph: number[][] = Array.from({ length: n }, () => []); + + for (const [s, e] of edges) { + graph[s].push(e); + graph[e].push(s); + } + + const visited = new Set(); + + const queue = [0]; + visited.add(0); + + let pointer = 0; + while (pointer < queue.length) { + const currentNode = queue[pointer++]; + + for (const nextNode of graph[currentNode]) { + if (!visited.has(nextNode)) { + queue.push(nextNode); + visited.add(nextNode); + } + } + } + + return visited.size === n; + } +} From b1977606fe045e099f34a42c4e23b9a3a83b4610 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E1=84=8C=E1=85=A9=E1=84=92=E1=85=A8=E1=84=85=E1=85=B5?= =?UTF-8?q?=E1=86=AB?= Date: Fri, 3 Oct 2025 23:31:46 +0900 Subject: [PATCH 4/5] merge intervals solution --- merge-intervals/hyer0705.ts | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 merge-intervals/hyer0705.ts diff --git a/merge-intervals/hyer0705.ts b/merge-intervals/hyer0705.ts new file mode 100644 index 0000000000..c779cc56d3 --- /dev/null +++ b/merge-intervals/hyer0705.ts @@ -0,0 +1,18 @@ +// Time Complexity: O(n log n) +// Space Complexity: O(n) +function merge(intervals: number[][]): number[][] { + const merged: number[][] = []; + + intervals.sort((a, b) => a[0] - b[0]); + + for (const [currentStart, currentEnd] of intervals) { + if (merged.length === 0 || merged[merged.length - 1][1] < currentStart) { + merged.push([currentStart, currentEnd]); + } else { + const lastMerged = merged[merged.length - 1]; + lastMerged[1] = Math.max(lastMerged[1], currentEnd); + } + } + + return merged; +} From 9df0c8a19fdb8bc8b0e94bc9b1ad9ad4e24ab556 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E1=84=8C=E1=85=A9=E1=84=92=E1=85=A8=E1=84=85=E1=85=B5?= =?UTF-8?q?=E1=86=AB?= Date: Fri, 3 Oct 2025 23:52:30 +0900 Subject: [PATCH 5/5] binary tree maximum path sum solution --- binary-tree-maximum-path-sum/hyer0705.ts | 37 ++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 binary-tree-maximum-path-sum/hyer0705.ts diff --git a/binary-tree-maximum-path-sum/hyer0705.ts b/binary-tree-maximum-path-sum/hyer0705.ts new file mode 100644 index 0000000000..34b2c0a34a --- /dev/null +++ b/binary-tree-maximum-path-sum/hyer0705.ts @@ -0,0 +1,37 @@ +/** + * Definition for a binary tree node. + * 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) + * } + * } + */ + +// Time Complexity: O(n) +// Space Complexity: O(h) where h is the height of the tree +function maxPathSum(root: TreeNode | null): number { + let maximumSum = -Infinity; + + const dfs = (node: TreeNode | null) => { + if (!node) return 0; + + let leftResult = dfs(node.left); + let rightResult = dfs(node.right); + + leftResult = Math.max(0, leftResult); + rightResult = Math.max(0, rightResult); + + maximumSum = Math.max(maximumSum, node.val + leftResult + rightResult); + + return node.val + Math.max(leftResult, rightResult); + }; + + dfs(root); + + return maximumSum; +}