Merge pull request #1570 from uraflower/main

[uraflower] Week11 Solutions

Author: uraflower

binary-tree-maximum-path-sum/uraflower.js

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const maxPathSum = function (root) {
+    let max = root.val;
+
+    function getMaxSum(node) {
+        if (!node) return 0;
+
+        const leftVal = Math.max(getMaxSum(node.left), 0);
+        const rightVal = Math.max(getMaxSum(node.right), 0);
+
+        max = Math.max(node.val + leftVal + rightVal, max);
+
+        return node.val + Math.max(leftVal, rightVal);
+    }
+
+    getMaxSum(root);
+
+    return max;
+};
+
+// 시간복잡도: O(n)
+// 공간복잡도: O(h) (h: 트리의 높이, 즉 재귀 스택 깊이)

graph-valid-tree/uraflower.js

@@ -0,0 +1,39 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @returns {boolean}
+ */
+function validTree(n, edges) {
+    //  트리의 조건을 만족하는지 확인(V = E + 1)
+    if (edges.length !== n - 1) {
+        return false;
+    }
+
+    const graph = Array.from({ length: n }).map(() => []);
+
+    for (const [u, v] of edges) {
+        graph[u].push(v);
+        graph[v].push(u);
+    }
+
+    const queue = [[-1, 0]]; // 부모 노드, 자식 노드
+    const visited = new Set();
+
+    while (queue.length) {
+        const [parent, current] = queue.shift();
+        if (visited.has(current)) {
+            return false;
+        }
+        visited.add(current);
+
+        for (const neighbor of graph[current]) {
+            if (neighbor === parent) continue;
+            queue.push([current, neighbor]);
+        }
+    }
+
+    return visited.size === n;
+}
+
+// 시간복잡도: O(V + E)
+// 공간복잡도: O(V)

merge-intervals/uraflower.js

@@ -0,0 +1,27 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+const merge = function (intervals) {
+    // 시작점 기준으로 정렬
+    intervals.sort((a, b) => Number(a[0]) - Number(b[0]));
+    const result = [];
+
+    for (const current of intervals) {
+        const last = result[result.length - 1];
+
+        // 겹치는 구간이 있으면, 구간의 끝점을 더 큰 것으로 덮어씌우기
+        if (last && current[0] <= last[1]) {
+            result[result.length - 1][1] = Math.max(current[1], last[1]);
+        }
+        // 겹치는 구간이 없으면, 새로 집어 넣기
+        else {
+            result.push(current);
+        }
+    }
+
+    return result;
+};
+
+// 시간복잡도: O(n * log n)
+// 공간복잡도: O(n)

missing-number/uraflower.js

@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const missingNumber = function(nums) {
+    const n = nums.length;
+    let sum = (n * (n + 1)) / 2;
+
+    for (let num of nums) {
+        sum -= num;
+    }
+    
+    return sum;
+};
+
+// 시간복잡도: O(n)
+// 공간복잡도: O(1)

reorder-list/uraflower.js

@@ -0,0 +1,38 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {void} Do not return anything, modify head in-place instead.
+ */
+var reorderList = function (head) {
+    const nodes = {};
+    let current = head;
+    let n = 0; // 인덱스 역할
+    
+    // 리스트를 순회하면서 각 노드를 객체에 저장
+    while (current) {
+        nodes[n] = current;
+        current = current.next;
+        nodes[n].next = null;   // 여기서 모든 노드의 next를 null로 변경
+                                // 이렇게 안 하면 next 바꾸기 한 다음에 맨 마지막 노드의 next만 null로 바꿔야 함
+        n++
+    }
+
+    // 저장한 노드를 i, n-i, ... 순서로 접근하면서 next 바꾸기
+    for (let i = 0; i < Math.floor(n / 2); i++) {
+        nodes[i].next = nodes[n - i - 1];
+
+        // n-i-1 === i+1 인 경우, node.next = node 처럼 셀프 순환이 될 수 있음
+        if (n - i - 1 !== i + 1) {
+            nodes[n - i - 1].next = nodes[i + 1];
+        }
+    }
+};
+
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)