[dudwns0213] 24.11.26

dudwns0213/9week/102.js

@@ -0,0 +1,43 @@
+/**
+ * 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;
+};

dudwns0213/9week/207.js

@@ -0,0 +1,42 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+
+/**
+ * 수강 과목의 순서 정하기
+ *
+ * 위상 정렬 개념(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;
+};

dudwns0213/9week/213.js

@@ -0,0 +1,27 @@
+/**
+ * @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))
+  );
+};

dudwns0213/9week/56.js

@@ -0,0 +1,37 @@
+/**
+ * @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;
+};

dudwns0213/9week/572.js

@@ -0,0 +1,23 @@
+/**
+ * @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에게 한 줄씩 해석을 부탁했습니다...
+ */