[gomgom22] Week14

binary-tree-level-order-traversal/Yjason-K.ts

@@ -0,0 +1,52 @@
+/**
+ * 이진 트리 노드의 정의입니다.
+ * 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);
+ *     }
+ * }
+ */
+
+/**
+ * 이진트리 깊이별 노드 값들을 배열로 저장하는 함수.
+ * 
+ * @param {TreeNode | null} root - 이진 트리의 루트 노드
+ * @returns {number[][]} - 각 레벨별 노드 값들이 담긴 2차원 배열 반환
+ * 
+ * 시간 복잡도: O(n) 
+ *   - 모든 노드를 한 번씩 방문
+ * 공간 복잡도: O(n) 
+ *   - 재귀 호출 스택 및 결과 배열 사용
+ */
+function levelOrder(root: TreeNode | null): number[][] {
+    // idx -> 각 깊이별 노드 값들을 저장
+    const result: number[][] = [];
+
+    const dfs = (node: TreeNode | null, depth: number): void => {
+        // 노드가 null이면 재귀 종료
+        if (node === null) return;
+
+        // 현재 depth를 처음 방문되는 경우, 결과 배열에 새로운 depth 배열을 추가
+        if (result.length === depth) {
+            result.push([]);
+        }
+
+        // 현재 노드의 값을 해당 레벨 배열에 추가
+        result[depth].push(node.val);
+
+        // 왼쪽 자식 노드를 방문 (depth 1 증가시킴)
+        dfs(node.left, depth + 1);
+        // 오른쪽 자식 노드를 방문 (depth 1 증가시킴)
+        dfs(node.right, depth + 1);
+    }
+
+    // depth 0부터 탐색 시작
+    dfs(root, 0);
+    return result;
+};
+

counting-bits/Yjason-K.ts

@@ -0,0 +1,25 @@
+/**
+ * 각 수의 비트의 개수를 계산하는 함수
+ * @param {number} nums - 최대 수
+ * @returns {number[]} - 각 수의 비트의 개수 배열
+ *
+ * 시간 복잡도: O(n)
+ * - nums 만큼 반복하며, 각 수의 비트의 개수를 계산
+ *
+ * 공간 복잡도: O(n)
+ * - dp 배열을 사용하여 O(n) 만큼 추가 공간이 필요
+ */
+function countBits(nums: number): number[] {
+  // dp 배열을 생성하고, 모두 0으로 초기화합니다.
+  const dp: number[] = new Array(nums + 1).fill(0);
+
+  // 각 수에 대해, 비트의 개수를 계산합니다.
+  for (let num = 1; num <= nums; num++) {
+    // num을 2진수로 표현했을 때, 1의 개수는 2진수로 변환하여 문자열로 변환 후,
+    // '1'이 포함된 문자열의 길이를 계산합니다.
+    dp[num] = dp[Math.floor(num / 2)] + (num % 2);
+  }
+
+  return dp;
+}
+

house-robber-ii/Yjason-K.ts

@@ -0,0 +1,43 @@
+/**
+ * 처음 집과 끝 집은 연결되어 있음.
+ * 주어진 배열에서 인접한 집을 털지 않고 훔칠 수 있는 최대 금액을 계산하는 함수
+ * 
+ * @param {number[]} nums - 각 집에 있는 돈의 양을 나타내는 배열
+ * @returns {number} - 경보를 울리지 않고 훔칠 수 있는 최대 금액
+ * 
+ * 시간 복잡도: O(n)
+ *   - 모든 집을 한 번씩 방문
+ * 
+ * 공간 복잡도: O(1)
+ *  - 상수 개의 변수만 사용
+ */
+function rob(nums: number[]): number {
+    const houses = nums.length;
+
+    if (houses === 1) return nums[0];
+
+    const robber = (nums: number[], start: number, end: number) => {
+        let prevMax = 0; // 바로 이전 집까지 털어서 얻은 최대 금액
+        let currMax = 0; // 현재 집까지 털어서 얻은 최대 금액
+
+        // start부터 end까지 반복하며 DP 진행
+        for (let i = start; i <= end; i++) {
+            // 현재 집(i)을 털 경우와 털지 않을 경우의 최대 금액 계산
+            const temp = currMax;
+            currMax = Math.max(currMax, prevMax + nums[i]);
+            prevMax = temp;
+        }
+
+        return currMax;
+    }
+
+
+    // 원형 구조이므로, 첫 번째 집을 털 경우와 마지막 집을 털 경우는 동시에 불가능
+    // 두 구간을 따로 계산하고 최대값을 반환
+    const max1 = robber(nums, 0, houses - 2); // 첫 번째 집부터 마지막에서 두 번째 집까지 고려
+    const max2 = robber(nums, 1, houses - 1); // 두 번째 집부터 마지막 집까지 고려
+
+    return Math.max(max1, max2);
+
+};
+