[mallayon] Week 14

binary-tree-level-order-traversal/mmyeon.ts

@@ -0,0 +1,86 @@
+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;
+  }
+}
+
+/**
+ *@link https://leetcode.com/problems/binary-tree-level-order-traversal/
+ *
+ * 접근 방법 : DFS 사용
+ *  - 같은 높이의 노드들을 result 배열에 넣기 위해서 dfs로 재귀 호출
+ *  - result 배열에 현재 level에 대한 배열이 없으면 추가하고, 현재 노드의 값을 push
+ *  - 하위 자식 노드가 존재하면 dfs 재귀 호출 (level은 1 증가)
+ *
+ * 시간복잡도 : O(n)
+ *  - n = 노드의 개수, 모든 노드 순회
+ *
+ * 공간복잡도 : O(n)
+ *  - 트리 기울어진 경우, 재귀 호출 n번 만큼 스택 사용
+ */
+
+function levelOrder(root: TreeNode | null): number[][] {
+  const result: number[][] = [];
+
+  const dfs = (node: TreeNode | null, level: number) => {
+    if (!node) return;
+
+    if (!result[level]) result[level] = [];
+
+    result[level].push(node.val);
+
+    if (node.left) dfs(node.left, level + 1);
+    if (node.right) dfs(node.right, level + 1);
+  };
+
+  dfs(root, 0);
+
+  return result;
+}
+
+/**
+ *
+ * 접근 방법 : BFS 사용
+ *  - 동일 레벨의 노드 값 담기 위해서 큐를 사용
+ *  - 탐색할 노드를 큐에 먼저 담고, 큐에서 하나씩 꺼내면서 동일 레벨의 노드 값 담기
+ *  - 노드의 자식노드가 존재하면 다시 큐에 추가해서 탐색할 수 있도록 함
+ *  - 이 과정 반복하기
+ *
+ * 시간복잡도 : O(n)
+ *  - n = 노드의 개수, 모든 노드 순회
+ *
+ * 공간복잡도 : O(n)
+ *  - 큐에 모든 노드 저장함
+ */
+
+function levelOrder(root: TreeNode | null): number[][] {
+  if (!root) return [];
+
+  // 탐색할 노드 담아놓는 대기줄
+  const queue: TreeNode[] = [root];
+  const result: number[][] = [];
+
+  while (queue.length > 0) {
+    // 동일 레벨에 있는 노드 값 담는 용도
+    const currentLevel: number[] = [];
+    // queue 사이즈가 동적으로 변하기 때문에 미리 계산한 값 변수에 저장
+    const size = queue.length;
+
+    for (let i = 0; i < size; i++) {
+      const node = queue.shift()!;
+      currentLevel.push(node.val);
+
+      if (node.left) queue.push(node.left);
+      if (node.right) queue.push(node.right);
+    }
+
+    result.push(currentLevel);
+  }
+
+  return result;
+}

house-robber-ii/mmyeon.ts

@@ -0,0 +1,36 @@
+/**
+ *@link https://leetcode.com/problems/house-robber-ii/description/
+ *
+ * 접근 방법 :
+ *  - DP를 활용해서 현재 위치까지의 최대값을 업데이트
+ *  - 원형 구조로 첫 번째 집과 마지막 집이 둘다 포함될 수 없기 때문에, 첫 번째 집만 포함하는 경우와 첫 번째 집을 제외하는 경우를 나눠서 계산하고 최대값 비교
+ *
+ * 시간복잡도 : O(n)
+ *  - n = numbs 배열의 길이,  n번 반복하면서 최대값 계산
+ *
+ * 공간복잡도 : O(1)
+ *  - dp 배열을 사용하는 대신 고정된 배열(prev, doublePrev)을 사용
+ */
+const calculateMaxMoney = (houses: number[]) => {
+  let prev = 0;
+  let doublePrev = 0;
+
+  for (let i = 0; i < houses.length; i++) {
+    const current = Math.max(prev, doublePrev + houses[i]);
+
+    doublePrev = prev;
+    prev = current;
+  }
+
+  return prev;
+};
+
+function rob(nums: number[]): number {
+  if (nums.length === 1) return nums[0];
+  if (nums.length === 2) return Math.max(nums[0], nums[1]);
+
+  const robWithFirstHouse = calculateMaxMoney(nums.slice(0, nums.length - 1));
+  const robWithoutFirstHouse = calculateMaxMoney(nums.slice(1, nums.length));
+
+  return Math.max(robWithFirstHouse, robWithoutFirstHouse);
+}

meeting-rooms-ii/mmyeon.ts

@@ -0,0 +1,27 @@
+/**
+ * 접근 방법 :
+ *  - 시작 시간과 종료 시간을 각각 배열로 분리한다음 오름차순으로 정렬한다.
+ *  - 시작 시간이 가장 빠른 종료 시간보다 빠르다면 다른 회의룸 필요하니까 카운트 증가한다.
+ *  - 시작 시간이 종료 시간보다 느리면 회의룸 재사용할 수 있으니까 종료시간 인덱스 증가한다.
+ *
+ * 시간복잡도 : O(nlogn)
+ *  - n = intervals의 길이, 오름차순 정렬
+ *
+ * 공간복잡도 : O(n)
+ * - 인터벌 길이만큼 배열 필요
+ */
+
+function minMeetingRooms(intervals: number[][]): number {
+  const starts = intervals.map((interval) => interval[0]).sort((a, b) => a - b);
+  const ends = intervals.map((interval) => interval[1]).sort((a, b) => a - b);
+
+  let roomCount = 0;
+  let endIndex = 0;
+
+  for (let i = 0; i < starts.length; i++) {
+    if (starts[i] < ends[endIndex]) roomCount++;
+    else endIndex++;
+  }
+
+  return roomCount;
+}