[dudwns0213] 24.11.26

[dudwns0213]

📌 푼 문제

문제이름	문제링크
Merge Intervals	https://leetcode.com/problems/merge-intervals
Binary Tree Level Order Traversal	https://leetcode.com/problems/binary-tree-level-order-traversal
Subtree Of Another Tree	https://leetcode.com/problems/subtree-of-another-tree
House Robber II	https://leetcode.com/problems/house-robber-ii
Course Schedule	https://leetcode.com/problems/course-schedule

---

📝 간단한 풀이 과정

56 . Merge Intervals

/**
 * @param {number[][]} intervals
 * @return {number[][]}
 */

/**
 * intervals 배열에서 interval[i] = [start, end] 의 경우 시작점, 끝 점
 * 겹치는 구간을 병합해서 겹치지 않는 구간의 배열을 반환해야 하는 문제!
 *
 * 정렬 후 병합하는 방법, 스위핑을 하는 방법 2가지가 존재한다고 한다.
 */

var merge = function (intervals) {
  if (intervals.length <= 1) return intervals;

  intervals.sort((a, b) => a[0] - b[0]);
  // 오름차순 정렬

  const result = [];

  let currentInterval = intervals[0];

  for (let i = 1; i < intervals.length; i++) {
    const [start, end] = intervals[i];

    if (currentInterval[1] >= start) {
      currentInterval[1] = Math.max(currentInterval[1], end);
    } else {
      result.push(currentInterval);
      currentInterval = intervals[i];
    }
  }

  result.push(currentInterval);

  return result;
};

102. Binary Tree Level Order Traversal

/**
 * 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 levelOrder = function (root) {
  if (!root) return [];

  const result = [];
  const queue = [root];

  while (queue.length > 0) {
    const level = [];
    const levelSize = queue.length;

    for (let i = 0; i < levelSize; 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;
};

572. Subtree of Another Tree

• 좀 어려웠습니다...

/**
 * @param {TreeNode} root
 * @param {TreeNode} subRoot
 * @return {boolean}
 */
var isSubtree = function (root, subRoot) {
  if (!root) return false; // root가 null이면 false 반환
  if (isSameTree(root, subRoot)) return true; // 현재 노드에서 동일한 트리인지 확인
  return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot); // 왼쪽 또는 오른쪽에서 찾기
};

// 두 트리가 동일한지 확인하는 함수
var isSameTree = function (tree1, tree2) {
  if (!tree1 && !tree2) return true; // 둘 다 null이면 동일
  if (!tree1 || !tree2 || tree1.val !== tree2.val) return false; // 값이 다르거나 한쪽이 null이면 다름
  return (
    isSameTree(tree1.left, tree2.left) && isSameTree(tree1.right, tree2.right)
  ); // 좌/우 자식 비교
};

/**
 * 문제를 푼 다음 GPT에게 한 줄씩 해석을 부탁했습니다...
 */

213. House Robber II

• prev에 대한 개념을 새로 공부해서 좋았어용

/**
 * @param {number[]} nums
 * @return {number}
 */

// 최적값이 너무 어려워서 GPT와 문제 풀이 사이트의 힘을 빌려봤어요...

var rob = function (nums) {
  // 여기 생각 못 하고 있었는데 나중에 알아서 급하게 추가...
  if (nums.length === 1) return nums[0];

  const robLinear = (houses) => {
    let prev2 = 0;
    let prev1 = 0;
    for (let money of houses) {
      const temp = Math.max(prev1, prev2 + money);
      prev2 = prev1;
      prev1 = temp;
    }
    return prev1;
  };

  return Math.max(
    robLinear(nums.slice(1)),
    robLinear(nums.slice(0, nums.length - 1))
  );
};

207. Course Schedule

• 진짜 너무 어려워요 ㅠㅠ 머리가아파요
• GPT와 구글에 돌아다니는 문제 해석을 좀 많이 읽었습니다

/**
 * @param {number} numCourses
 * @param {number[][]} prerequisites
 * @return {boolean}
 */

/**
 * 수강 과목의 순서 정하기
 *
 * 위상 정렬 개념(BFS)을 사용해서 풀어야 한다!
 * BFS를 활용한 위상 정렬이라고 해야 하는데 오타가...
 *
 * 가능과 불가능의 경우를 생각해보자!
 */

var canFinish = function (numCourses, prerequisites) {
  const graph = Array.from({ length: numCourses }, () => []);
  const inDegree = Array(numCourses).fill(0);

  // 그래프 생성
  for (const [course, pre] of prerequisites) {
    graph[pre].push(course);
    inDegree[course] += 1;
  }

  const queue = [];
  for (let i = 0; i < numCourses; i++) {
    if (inDegree[i] === 0) queue.push(i);
  }

  let count = 0;
  while (queue.length > 0) {
    const node = queue.shift();
    count += 1;

    for (const neighbor of graph[node]) {
      inDegree[neighbor] -= 1;
      if (inDegree[neighbor] === 0) queue.push(neighbor);
    }
  }

  return count === numCourses;
};

---