From 8beb2b8b43ba8a274aaf3434dce9f7ed8589c6d6 Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Tue, 24 Sep 2024 22:14:31 +0900
Subject: [PATCH 01/19] 217 / Contains Duplicate / easy / 5m

---
 dudwns0213/1week/217.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 dudwns0213/1week/217.js

diff --git a/dudwns0213/1week/217.js b/dudwns0213/1week/217.js
new file mode 100644
index 0000000..048293f
--- /dev/null
+++ b/dudwns0213/1week/217.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ *
+ * 배열에서 중복이 나타날 시, true
+ * 중복이 없을 시, false
+ *
+ * Set을 통해 중복을 확인
+ * for...of 구문을 통해 순차적으로 순회, 비교
+ *
+ */
+var containsDuplicate = function (nums) {
+  const Ex = new Set();
+  for (let num of nums) {
+    if (Ex.has(num)) {
+      return true;
+    }
+    Ex.add(num);
+  }
+
+  return false;
+};

From 6aad3bad250b0876f8fa0cdfe40a94aa864df9e5 Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Tue, 24 Sep 2024 22:20:27 +0900
Subject: [PATCH 02/19] 268 / Missing Number / easy / 4m

---
 dudwns0213/1week/268.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 dudwns0213/1week/268.js

diff --git a/dudwns0213/1week/268.js b/dudwns0213/1week/268.js
new file mode 100644
index 0000000..4be1f65
--- /dev/null
+++ b/dudwns0213/1week/268.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ *
+ * sort를 활용한 배열 오름차순 정렬
+ * 이후 배열 인덱스 길이만큼 전체 순회 후 return
+ * 인덱스의 값과 배열의 시작값이 같아서 편했다(0이 무조건 포함)
+ *
+ */
+
+var missingNumber = function (nums) {
+  nums.sort((a, b) => a - b);
+
+  for (let i = 0; i <= nums.length; i++) {
+    if (nums[i] !== i) {
+      return i;
+    }
+  }
+};

From 6996b4e6d93d04c5cea3e55f3d23bb89f562c2c2 Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Tue, 24 Sep 2024 22:38:36 +0900
Subject: [PATCH 03/19] 121 / Best Time to Buy and Sell Stock / Easy / 12~15m

---
 dudwns0213/1week/121.js | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 dudwns0213/1week/121.js

diff --git a/dudwns0213/1week/121.js b/dudwns0213/1week/121.js
new file mode 100644
index 0000000..22cf7d1
--- /dev/null
+++ b/dudwns0213/1week/121.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ *
+ * 문제 이해가 어려워서 이해에 시간이 많이 걸렸다...
+ *
+ * 최소 가격 / 최대 이익 2개의 변수를 생성
+ * 이후, prices를 순차적으로 순회(for of)
+ * 현재 가격이 min(최소 가격) 보다 낮을 시, min을 현재 price로 변경
+ * 만약 아닐 시(현재 가격이 최소 가격보다 높다), 해당 price - 최소 가격 = 최대 이익으로 계산
+ *
+ * ex) 7 1 5 3 6 4
+ * 7 -> min = 7 max = 0
+ * 1 -> min = 1 max = 0
+ *
+ * 5 -> min = 1 max = 4
+ * 3 ...
+ * 6 -> min = 1 max = 5
+ * 4 ...
+ *
+ * Math.max를 사용하는 이유
+ *
+ * 현재 이익(price - min) 과 최대 이익 (max) 중 더 큰 값을 선택해서 결과를 낼 수 있기 때문
+ * max를 계속 업데이트 할 수 있으므로 사용해야 함
+ *
+ */
+var maxProfit = function (prices) {
+  let max = 0;
+  let min = Infinity;
+
+  for (price of prices) {
+    if (price < min) {
+      min = price;
+    } else {
+      max = Math.max(price - min, max);
+    }
+  }
+
+  return max;
+};

From 9617d0106908a2e0293c4dca30a469703357067d Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Tue, 24 Sep 2024 22:55:24 +0900
Subject: [PATCH 04/19] 252 / Meeting Room / easy / 8m

---
 dudwns0213/1week/252.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 dudwns0213/1week/252.js

diff --git a/dudwns0213/1week/252.js b/dudwns0213/1week/252.js
new file mode 100644
index 0000000..d861956
--- /dev/null
+++ b/dudwns0213/1week/252.js
@@ -0,0 +1,36 @@
+/**
+ * Definition of Interval:
+ * class Interval {
+ *   constructor(start, end) {
+ *     this.start = start;
+ *     this.end = end;
+ *   }
+ * }
+ *
+ * 회의를 겹치지 않게 추가해보자!
+ *
+ * 일단 회의를 정렬해야 한다(사실 까먹고있었다...).
+ * 정렬 후, 루프 범위를 설정한다. i를 int.length까지 반복되도록 해야 한다.
+ * 배열의 인덱스를 초과할 수 있으니 <를 사용, -1을 해주자
+ *
+ * 처음 회의의 종료 시간과 다음 회의의 시작시간을 비교하면 끝!
+ *
+ *
+ */
+
+class Solution {
+  /**
+   * @param {Interval[]} intervals
+   * @returns {boolean}
+   */
+  canAttendMeetings(intervals) {
+    intervals.sort((a, b) => a.start - b.start);
+
+    for (let i = 0; i < intervals.length - 1; i++) {
+      if (intervals[i].end > intervals[i + 1].start) {
+        return false;
+      }
+    }
+    return true;
+  }
+}

From 4cb11025cbae4f1089c5ee19dc230987c360f376 Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Tue, 24 Sep 2024 23:11:34 +0900
Subject: [PATCH 05/19] 15 / 3sum / medium / 30~40m

---
 dudwns0213/1week/15.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 dudwns0213/1week/15.js

diff --git a/dudwns0213/1week/15.js b/dudwns0213/1week/15.js
new file mode 100644
index 0000000..7f92671
--- /dev/null
+++ b/dudwns0213/1week/15.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function (nums) {
+  const result = [];
+  nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < nums.length - 2; i++) {
+    if (i > 0 && nums[i] === nums[i - 1]) continue;
+
+    let left = i + 1;
+    let right = nums.length - 1;
+
+    while (left < right) {
+      const sum = nums[i] + nums[left] + nums[right];
+
+      if (sum === 0) {
+        result.push([nums[i], nums[left], nums[right]]);
+
+        while (left < right && nums[left] === nums[left + 1]) left++;
+        while (left < right && nums[right] === nums[right - 1]) right--;
+
+        left++;
+        right--;
+      } else if (sum < 0) {
+        left++;
+      } else {
+        right--;
+      }
+    }
+  }
+
+  return result;
+};

From bbe8196163908fce191121a4578fa0ee776b2d7b Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Fri, 4 Oct 2024 10:32:59 +0900
Subject: [PATCH 06/19] 242 / Valid Anagram / easy / 7m

---
 dudwns0213/2week/242.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 dudwns0213/2week/242.js

diff --git a/dudwns0213/2week/242.js b/dudwns0213/2week/242.js
new file mode 100644
index 0000000..dc02da2
--- /dev/null
+++ b/dudwns0213/2week/242.js
@@ -0,0 +1,33 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ *
+ * 두 단어의 길이가 다르면 true가 될 수 없으므로 길이 체크부터 해야 한다
+ *
+ * 원래는 배열로만 핸슨데, 유니코드 문자의 경우는 객체로 하면 충돌이 날 수도 있다고 한다...
+ * Map을 사용하도록 하자 (키로 모든 값을 허용한다)
+ *
+ * count.get을 통해 현재 문자의 빈도 수를 가져오고 미리 지정해두기!
+ *
+ * 그렇게까지 어렵진 않았당
+ *
+ */
+var isAnagram = function (s, t) {
+  if (s.length !== t.length) return false;
+
+  const count = new Map();
+
+  for (let char of s) {
+    count.set(char, (count.get(char) || 0) + 1);
+  }
+
+  for (let char of t) {
+    if (!count.has(char) || count.get(char) === 0) {
+      return false;
+    }
+    count.set(char, count.get(char) - 1);
+  }
+
+  return true;
+};

From 9889af3c3554374b7a3e0d0af1230dfc0b99d597 Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Fri, 4 Oct 2024 11:01:14 +0900
Subject: [PATCH 07/19] 238 / Product of Array Except Self / medium / 15m...

---
 dudwns0213/2week/238.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 dudwns0213/2week/238.js

diff --git a/dudwns0213/2week/238.js b/dudwns0213/2week/238.js
new file mode 100644
index 0000000..da57f8a
--- /dev/null
+++ b/dudwns0213/2week/238.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ *
+ * 좀 어려웠습니다...
+ * 아이디어는 떠올랐는데 이걸 코드로 구현하는게 빡센 뇌운동을 하는 느낌이였어요
+ * 왼쪽 오른쪽 나눠서 한다는 게 정말 세상 너무 똑똑한 사람들이 많다는걸 조금 느꼈습니다 ㅠ.ㅠ
+ * 사람들의 풀이 등을 보고 최대한 깔끔하게 작성해볼려고 노력했어요(처음에 직접 한 후에!)
+ *
+ */
+const productExceptSelf = function (nums) {
+  const length = nums.length;
+  const answer = new Array(length);
+
+  let L = 1;
+
+  for (let i = 0; i < length; i++) {
+    answer[i] = L;
+    L *= nums[i];
+  }
+
+  let R = 1;
+
+  for (let i = length - 1; i >= 0; i--) {
+    answer[i] = answer[i] * R;
+    R *= nums[i];
+  }
+
+  return answer;
+};

From fd5783d9cfbbf7e48dc69a7b426e11a4537c4395 Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Fri, 4 Oct 2024 11:12:53 +0900
Subject: [PATCH 08/19] =?UTF-8?q?191=20/=20Number=20of=201=20Bits=20/=20ea?=
 =?UTF-8?q?sy=20/=205m=20(=EC=95=8C=EA=B3=A0=EB=A6=AC=EC=A6=98=20=EB=B3=80?=
 =?UTF-8?q?=EA=B2=BD=206m=3F)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 dudwns0213/2week/191.js | 42 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 dudwns0213/2week/191.js

diff --git a/dudwns0213/2week/191.js b/dudwns0213/2week/191.js
new file mode 100644
index 0000000..10ad479
--- /dev/null
+++ b/dudwns0213/2week/191.js
@@ -0,0 +1,42 @@
+/**
+ * @param {number} n
+ * @return {number}
+ *
+ * 숫자를 받을 시, 해당 숫자에 대한 2진수에서 1 비트에 대한 개수를 확인해서 반환하기
+ *
+ * 2진수로 변환 후(toString?) 거기서 연산을 할까 아니면 비트 연산을 할까?
+ *
+ * 전체적으로 비트만 신경쓰면 된다
+ * >>> 기호를 사용해야 한다(기억이 잘 안 났다)
+ *
+ * 처음에는 2진수 쪽으로 헀는데 검색하니 Brian Kernighan의 알고리즘이 있어서 풀이법을 수정해보았다!
+ * >>>를 사용하지 않아도 됨!
+ *
+ * 알고리즘을 사용한 풀이와 2진수 사용 풀이를 구분해보았다. 확실히... 알고리즘을 알면 도움이 되는구나...
+ *
+ */
+var hammingWeight = function (n) {
+  let count = 0;
+
+  while (n !== 0) {
+    n = n & (n - 1);
+
+    count++;
+  }
+
+  return count;
+};
+
+function hammingWeight(n) {
+  const binary = n.toString(2);
+
+  let count = 0;
+
+  for (let char of binary) {
+    if (char === "1") {
+      count++;
+    }
+  }
+
+  return count;
+}

From fb61a46969d4185664ffdd810d8df1342702ecdb Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Fri, 4 Oct 2024 14:17:36 +0900
Subject: [PATCH 09/19] 100 / Same Tree / easy / 8m

---
 dudwns0213/2week/100.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 dudwns0213/2week/100.js

diff --git a/dudwns0213/2week/100.js b/dudwns0213/2week/100.js
new file mode 100644
index 0000000..8d1f5ea
--- /dev/null
+++ b/dudwns0213/2week/100.js
@@ -0,0 +1,38 @@
+/**
+ * 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} p
+ * @param {TreeNode} q
+ * @return {boolean}
+ *
+ * 뇌가 너무 안 돌아가요 ㅠ.ㅠ
+ *
+ * 처음으로 노드가 아예 없는 경우...? 가 있을지는 모르겠지만 null을 일단 해줬습니다
+ * 한쪽만 null인 경우도 해뒀어요
+ * 그리고 아예 다른 경우도 체크를 했습니당
+ *
+ * 비교 방식을 다 하나하나 뜯어야 하나 했는데 세상에는 여러 가지 좋은 방식이 있더라구요
+ * 그 중 가장 보편적인 재귀를 활용해봤습니다
+ *
+ */
+var isSameTree = function (p, q) {
+  if (p === null && q === null) {
+    return true;
+  }
+
+  if (p === null || q === null) {
+    return false;
+  }
+
+  if (p.val !== q.val) {
+    return false;
+  }
+
+  return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+};

From 228e4606c4e65daed611b0b0d475f4714d9224a8 Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Fri, 4 Oct 2024 14:26:50 +0900
Subject: [PATCH 10/19] 746 / Min Cost Climbing Stairs / easy / 30m

---
 dudwns0213/2week/746.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 dudwns0213/2week/746.js

diff --git a/dudwns0213/2week/746.js b/dudwns0213/2week/746.js
new file mode 100644
index 0000000..4b8298a
--- /dev/null
+++ b/dudwns0213/2week/746.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} cost
+ * @return {number}
+ *
+ * 계단의 최상단에 꼭 가야 할까...?
+ *
+ * 배열로 할려고 했는데 너무 머리가 아파서 구글링의 힘을 빌렸습니다,,, DP는 처음이라 조금 어렵네요...
+ * -1 혹은 -2 하는 부분(한 계단 전인가 두 계단 전인가)이 굉장히 중요하다고 생각됩니다 ㅠ.ㅠ
+ *
+ */
+var minCostClimbingStairs = function (cost) {
+  const n = cost.length;
+
+  const dp = new Array(n + 1);
+
+  dp[0] = 0;
+  dp[1] = 0;
+
+  for (let i = 2; i <= n; i++) {
+    dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
+  }
+
+  return dp[n];
+};

From b17c8ebd2e4268b3ab57e2db34337091631e7a1d Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Wed, 9 Oct 2024 19:04:12 +0900
Subject: [PATCH 11/19] =?UTF-8?q?49=20/=20Group=20Anagrams=20/=20medium=20?=
 =?UTF-8?q?/=203m=F0=9F=98=8E?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 dudwns0213/3week/49.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 dudwns0213/3week/49.js

diff --git a/dudwns0213/3week/49.js b/dudwns0213/3week/49.js
new file mode 100644
index 0000000..36c6413
--- /dev/null
+++ b/dudwns0213/3week/49.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string[]} strs
+ * @return {string[][]}
+ *
+ * 주어진 문자열 배열에서 애너그램을 그룹으로 묶는 문제이다!
+ * 결과 반환 순서가 상관 없다는 점이 좀 생소하다...
+ *
+ * 일단 알파벳 순으로 정렬해야 한다
+ * 해당 요소들이 애너그램이 가능한지 판단할려면 일단 정렬해야 함!
+ *
+ * 각 알파벳들을 key로... 하나...? 하는 거 같다 일단 이렇게 해보자(오류안났음)
+ *
+ * 뒤에서 좀 깔금하게 작성하기 위해 GPT의 힘을 빌렸다 ㅠ.ㅠ
+ */
+var groupAnagrams = function (strs) {
+  const map = {};
+
+  for (const str of strs) {
+    const sortedStr = str.split("").sort().join("");
+
+    if (!map[sortedStr]) {
+      map[sortedStr] = [];
+    }
+    map[sortedStr].push(str);
+  }
+
+  return Object.values(map);
+};

From 487a1abbe189b4329086a5208830316f3ce481f4 Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Wed, 9 Oct 2024 19:10:35 +0900
Subject: [PATCH 12/19]  190 / Reverse Bits / Easy / 10m

---
 dudwns0213/3week/190.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 dudwns0213/3week/190.js

diff --git a/dudwns0213/3week/190.js b/dudwns0213/3week/190.js
new file mode 100644
index 0000000..1e59f1b
--- /dev/null
+++ b/dudwns0213/3week/190.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number} n - a positive integer
+ * @return {number} - a positive integer
+ *
+ * 비트를 반전시키는 문제이다!
+ *
+ * 풀이 방법 자체는 굉장히 간단한 듯?
+ *
+ * 비트를 입력한다 -> 32비트이므로 루프는 32번 돌면 될듯?
+ * 근데 굳이 지정하지 않고 계속 돌려도 어차피 끝이 나지 않을까 한다... 하지만 지정해야 성능이 좋을 것
+ *
+ * 정수의 비트들을 반전시키면 되는 것 같다...?
+ *
+ */
+var reverseBits = function (n) {
+  let result = 0;
+  for (let i = 0; i < 32; i++) {
+    // 결과를 왼쪽으로 시프트하여 비트를 추가할 자리를 만듭니다.
+    result <<= 1;
+    // n의 마지막 비트를 가져옵니다.
+    result |= n & 1;
+    // n을 오른쪽으로 시프트하여 다음 비트를 준비합니다.
+    n >>= 1;
+  }
+  // 부호 없는 32비트 정수로 변환하여 반환합니다.
+  return result >>> 0;
+};

From a0f2beb939e278cbb8f0a3c1f56ebeca240e81cc Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Wed, 9 Oct 2024 19:17:03 +0900
Subject: [PATCH 13/19] 125 / Valid Palindrome / easy / 8m

---
 dudwns0213/3week/125.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 dudwns0213/3week/125.js

diff --git a/dudwns0213/3week/125.js b/dudwns0213/3week/125.js
new file mode 100644
index 0000000..75540c3
--- /dev/null
+++ b/dudwns0213/3week/125.js
@@ -0,0 +1,34 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ *
+ * 회문: 거꾸로 읽어도 제대로 읽은 것과 같은 문장
+ *
+ * 대문자를 소문자로 전부 변환부터 하자!
+ * 공백, 쉼표, 세미콜론, 기타 등등 싹 다 삭제하자
+ *
+ * 회문인지 아닌지를 어떻게 검사하는가?
+ *
+ * 투 포인터를 쓸 수도 있을 듯...?
+ * 원문과 뒤집은 문장이 똑같은지 그냥 비교해도 될 거 같긴 하당
+ *
+ * 처음에는 뒤집은 문장이 할 수 있도록 풀었지만, 그 이후에 투 포인터가 성능적으로 좀 더 좋을 것 같아
+ * GPT의 힘을 빌려서 수정해봤습니다!
+ *
+ */
+var isPalindrome = function (s) {
+  const cleanedStr = s.toLowerCase().replace(/[^a-z0-9]/g, "");
+
+  let left = 0;
+  let right = cleanedStr.length - 1;
+
+  while (left < right) {
+    if (cleanedStr[left] !== cleanedStr[right]) {
+      return false;
+    }
+    left++;
+    right--;
+  }
+
+  return true;
+};

From 5ee16de8dd0eaa66c0c680b02936e2377536e214 Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Wed, 9 Oct 2024 19:23:48 +0900
Subject: [PATCH 14/19] 322 / Coin Change / medium / 30m?

---
 dudwns0213/3week/322.js | 49 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 dudwns0213/3week/322.js

diff --git a/dudwns0213/3week/322.js b/dudwns0213/3week/322.js
new file mode 100644
index 0000000..c991786
--- /dev/null
+++ b/dudwns0213/3week/322.js
@@ -0,0 +1,49 @@
+/**
+ * @param {number[]} coins
+ * @param {number} amount
+ * @return {number}
+ *
+ * 동전을 튕튕 튕기는 문제이다
+ *
+ * 입력된 동전을 통해 amount를 큰 값에서 나누고, 해당 나머지를 두 번쨰로 큰 동전부터 시도하는...?
+ * 걸로 풀이 방법이 생각이 났다.
+ *
+ * 다른 풀이를 보니 dp를 사용하여 푸는 방식이 되게 신기했당
+ *
+ * 알아보니 내가 맨 처음에 푼 방법이 그리디 알고리즘이라는 것이었다!
+ * 하지만 모든 경우에 최적해를 보장하지 않는다고 하여 dp로 갈아엎었다...
+ * (6이고, 동전이 1 3 4 인 경우, 그리디는 4 + 1 + 1을 답으로 내놓지만 사실 3+3이 정답!)
+ *
+ * 풀이 방법 자체는 남겨두자...
+ *
+ */
+var coinChange = function (coins, amount) {
+  const dp = new Array(amount + 1).fill(amount + 1);
+  dp[0] = 0;
+
+  for (let i = 1; i <= amount; i++) {
+    for (const coin of coins) {
+      if (i - coin >= 0) {
+        dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+      }
+    }
+  }
+
+  return dp[amount] === amount + 1 ? -1 : dp[amount];
+};
+
+function coinChangeGreedy(coins, amount) {
+  coins.sort((a, b) => b - a);
+
+  let count = 0;
+  for (let i = 0; i < coins.length; i++) {
+    if (amount === 0) break;
+
+    const coinCount = Math.floor(amount / coins[i]);
+    count += coinCount;
+    amount -= coinCount * coins[i];
+  }
+
+  if (amount !== 0) return -1;
+  return count;
+}

From 54816ab7ef558de320d3a90bac458ad66d82e178 Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Wed, 27 Nov 2024 22:49:18 +0900
Subject: [PATCH 15/19] 102 / Binary Tree Level Order Traversal / Medium / 15m

---
 dudwns0213/9week/102.js | 43 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 dudwns0213/9week/102.js

diff --git a/dudwns0213/9week/102.js b/dudwns0213/9week/102.js
new file mode 100644
index 0000000..2f59b7e
--- /dev/null
+++ b/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;
+};

From 12dee37866a873595d79316f78cf1b7b06bc7140 Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Wed, 27 Nov 2024 22:49:31 +0900
Subject: [PATCH 16/19] 572 / Subtree of Another Tree / Easy / 30m

---
 dudwns0213/9week/572.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 dudwns0213/9week/572.js

diff --git a/dudwns0213/9week/572.js b/dudwns0213/9week/572.js
new file mode 100644
index 0000000..678a8ff
--- /dev/null
+++ b/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에게 한 줄씩 해석을 부탁했습니다...
+ */

From 1f678aa37dd4fe579ef1ae03e3edc2dd0bc8e44c Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Wed, 27 Nov 2024 22:49:42 +0900
Subject: [PATCH 17/19] 213 / House Robber II / Medium / 20m

---
 dudwns0213/9week/213.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 dudwns0213/9week/213.js

diff --git a/dudwns0213/9week/213.js b/dudwns0213/9week/213.js
new file mode 100644
index 0000000..ee5e9e5
--- /dev/null
+++ b/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))
+  );
+};

From 799b6791508be5ab723fe23135c43bce7a3f531f Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Wed, 27 Nov 2024 22:49:55 +0900
Subject: [PATCH 18/19] 207 / Course Schedule / Medium / 10m

---
 dudwns0213/9week/207.js | 42 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 dudwns0213/9week/207.js

diff --git a/dudwns0213/9week/207.js b/dudwns0213/9week/207.js
new file mode 100644
index 0000000..7c862cd
--- /dev/null
+++ b/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;
+};

From 2007a459755b80a4fa1e9224805c79cdc1247ebb Mon Sep 17 00:00:00 2001
From: dudwns0213 <dudwns0213@gmail.com>
Date: Wed, 27 Nov 2024 22:51:17 +0900
Subject: [PATCH 19/19] 56 / Merge Intervals / Medium / 20m

---
 dudwns0213/9week/56.js | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 dudwns0213/9week/56.js

diff --git a/dudwns0213/9week/56.js b/dudwns0213/9week/56.js
new file mode 100644
index 0000000..76f821e
--- /dev/null
+++ b/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;
+};