[uraflower] Week 14 Solutions

binary-tree-level-order-traversal/uraflower.js

@@ -0,0 +1,66 @@
+/**
+ * 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 levelOrder = function(root) {
+    if (!root) return [];
+
+    const queue = [[root]];
+    const result = [];
+
+    while (queue.length) {
+        const curNodes = queue.shift();
+        const newNodes = []; // 나중에 queue에 넣을 배열로 child node들이 들어감
+        const newResult = []; // 나중에 result에 넣을 배열로 node.val이 들어감
+
+        curNodes.forEach((node) => {
+            newResult.push(node.val);
+            if (node.left) newNodes.push(node.left);
+            if (node.right) newNodes.push(node.right);
+        });
+
+        if (newNodes.length) queue.push(newNodes);
+        result.push(newResult)
+    }
+
+    return result;
+};
+
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)
+
+/*
+위 풀이는 배열을 4개 사용하고 있음
+아래 풀이는 배열을 줄인 방식
+*/
+const levelOrder = function(root) {
+    if (!root) return [];
+
+    const queue = [root];
+    const result = [];
+
+    while (queue.length) {
+        const level = [];
+
+        // queue에 있는 노드 다 꺼내기
+        for (let i = 0; i < queue.length; i++) {
+            const node = queue.shift();
+            level.push(node.val);
+
+            if (node.left) queue.push(node.left);
+            if (node.right) queue.push(node.right);
+        }
+
+        result.push(level);
+    }
+
+    return result;
+};

counting-bits/uraflower.js

@@ -0,0 +1,45 @@
+/**
+ * 두 번째 풀이
+ * 시간복잡도: O(n)
+ * 공간복잡도: O(n)
+ * @param {number} n
+ * @return {number[]}
+ */
+const countBits = function (n) {
+    const arr = [0];
+
+    for (let i = 1; i < n + 1; i++) {
+        arr[i] = arr[i >> 1] + (i & 1);
+        // i >> 1: 최하위 비트를 제외한 값. 이걸 이용해서 이전 인덱스 사용(dp)
+        //         i // 2 (2로 나눈 몫)와 같음.
+        // i & 1: 최하위 비트 (1 또는 0)
+    }
+
+    return arr;
+};
+
+/**
+ * 첫 번째 풀이
+ * 시간복잡도: O(n * log n)
+ * 공간복잡도: O(n)
+ * @param {number} n
+ * @return {number[]}
+ */
+const countBits = function (n) {
+    const arr = [];
+
+    for (let i = 0; i < n + 1; i++) {
+        const bin = i.toString(2); // O(log n)
+
+        let num = 0;
+
+        // O(log n)
+        for (let char of bin) {
+            if (char === '1') num++;
+        }
+
+        arr.push(num);
+    }
+
+    return arr;
+};

house-robber-ii/uraflower.js

@@ -0,0 +1,25 @@
+// 최대 금액은 ...
+// nums[0]을 터는 경우:    rob(nums[2] ~ nums[last - 1]) + nums[0]
+// nums[0]을 안 터는 경우:  rob(nums[1] ~ nums[last])
+// 따라서 nums[0]을 털지 말지 여부를 기준으로 나누어 계산
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const rob = function (nums) {
+    if (nums.length === 1) return nums[0];
+
+    const dp1 = [nums[0]]; // 첫 집을 터는 경우 최대 금액
+    const dp2 = [0]; // 첫 집을 안 터는 경우 최대 금액
+
+    for (let i = 1; i < nums.length; i++) {
+        dp1[i] = Math.max(dp1[i - 1], (dp1[i - 2] || 0) + nums[i]);
+        dp2[i] = Math.max(dp2[i - 1], (dp2[i - 2] || 0) + nums[i]);
+    }
+
+    return Math.max(dp1[dp1.length - 2], dp2[dp2.length - 1]);
+}
+
+// 시간복잡도: O(n)
+// 공간복잡도: O(n)

meeting-rooms-ii/uraflower.js

@@ -0,0 +1,24 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const minMeetingRooms = function(intervals) {
+    const starts = intervals.map(i => i[0]).sort((a, b) => a - b);
+    const ends = intervals.map(i => i[1]).sort((a, b) => a - b);
+
+    let rooms = 0;
+    let endIdx = 0;
+
+    for (let i = 0; i < starts.length; i++) {
+        if (starts[i] < ends[endIdx]) {
+            rooms++; // 새로운 방이 필요
+        } else {
+            endIdx++; // 기존 방 재사용 가능
+        }
+    }
+
+    return rooms;
+};
+
+// 시간복잡도: O(n * log n) (정렬)
+// 공간복잡도: O(n)