[ganu] Week11

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

@@ -0,0 +1,47 @@
+// Time complexity: O(n)
+// Space complexity: O(n)
+
+/**
+ * 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}
+ */
+var maxPathSum = function (root) {
+  let answer = Number.MIN_SAFE_INTEGER;
+
+  const dfs = (current) => {
+    const candidates = [current.val];
+
+    if (current.left) {
+      dfs(current.left);
+      candidates.push(current.left.val + current.val);
+    }
+
+    if (current.right) {
+      dfs(current.right);
+      candidates.push(current.right.val + current.val);
+    }
+
+    // 현재 노드가 루트일 경우
+    if (current.left && current.right) {
+      answer = Math.max(
+        answer,
+        current.left.val + current.right.val + current.val
+      );
+    }
+
+    current.val = Math.max(...candidates);
+    answer = Math.max(answer, current.val);
+  };
+
+  dfs(root);
+
+  return answer;
+};

maximum-depth-of-binary-tree/gwbaik9717.js

@@ -0,0 +1,39 @@
+// Time complexity: O(n)
+// Space complexity: O(n)
+
+/**
+ * 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}
+ */
+var maxDepth = function (root) {
+  let answer = 0;
+
+  const dfs = (current, depth) => {
+    if (!current) {
+      return;
+    }
+
+    if (answer < depth) {
+      answer = depth;
+    }
+
+    if (current.left) {
+      dfs(current.left, depth + 1);
+    }
+
+    if (current.right) {
+      dfs(current.right, depth + 1);
+    }
+  };
+
+  dfs(root, 1);
+  return answer;
+};

merge-intervals/gwbaik9717.js

@@ -0,0 +1,33 @@
+// Time complexity: O(nlogn)
+// Space complexity: O(n)
+
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+var merge = function (intervals) {
+  intervals.sort((a, b) => {
+    if (a[0] === b[0]) {
+      return a[1] - b[1];
+    }
+
+    return a[0] - b[0];
+  });
+
+  const answer = [intervals[0]];
+
+  for (let i = 1; i < intervals.length; i++) {
+    const current = intervals.at(i);
+    const prev = answer.at(-1);
+
+    // No overlapping
+    if (current[0] > prev[1]) {
+      answer.push(current);
+      continue;
+    }
+
+    answer[answer.length - 1] = [prev[0], Math.max(prev[1], current[1])];
+  }
+
+  return answer;
+};

reorder-list/gwbaik9717.js

@@ -0,0 +1,46 @@
+// Time complexity: O(n)
+// Space complexity: O(n)
+
+/**
+ * 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 n = 0;
+
+  {
+    let current = head;
+    while (current) {
+      n++;
+      nodes.push(current);
+      current = current.next;
+    }
+  }
+
+  const answer = head;
+
+  {
+    let current = answer;
+    for (let i = 1; i < n; i++) {
+      if (i % 2 !== 0) {
+        current.next = nodes.at(n - Math.ceil(i / 2));
+      } else {
+        current.next = nodes.at(i / 2);
+      }
+
+      current = current.next;
+    }
+
+    current.next = null;
+  }
+
+  return answer;
+};