[wjsdncl] 24.12.03 (#114)

* 217 / Contains Duplicate / easy / 22m

* 268 / Missing Number / easy / 13m

* 121 / Best Time to Buy and Sell Stock / easy / 16m

* 252 / Meeting Room / easy / 26m

* 15 / 3sum / medium / 42m

* 242 / Valid Anagram / Easy / 15m33

* 238 / Product of Array Except Self / Medium / 35m16

* 191 / Number of 1 Bits / Easy / 14m32s

* 100 / Same Tree / Easy / 24m40s

* 746 / Min Cost Climbing Stairs / Easy / 29m35s

* 746 / Min Cost Climbing Stairs / Easy / 29m35s (수정)

* 1 / Two Sum / easy / 20m 31s

* 104 / Maximun Depth of Binary Tree / easy / 38m 21s

* 141 / Linked List Cycle / easy / 32m 15s

* 202 / Happy Number / Easy / 29m 21s

* 20 / Valid Parentheses / easy / 22m 41s

* 338 / Counting Bits / Easy / 17m

* 70 / Climbing Stairs / Easy / 19m

* 21 / Merge Two Sorted Lists / easy / 28m

* 48 / Rotate Image / medium / 31m

* 1046 / Last Stone Weight / easy / 21m

* 136 / Single Number / Easy / 12m

* 110 / Balanced Binary Tree / Easy / 35m

* 54 / Spiral Matrix / Medium / 38m

* 973 / K Closest Points to Origin / Medium / 21m

* 155 / Min Stack / Medium / 31m

* 128 / Longest Consecutive Sequence / Medium / 26m

* 371 / Sum of Two Integers / Medium / 17m

* 208 / Implement Trie (Prefix Tree) / Medium / 24m

* 226 / Invert Binary Tree / Easy / 13m

* 543 / Diameter of Binary Tree / Easy / 26m

* 102 / Binary Tree Level Order Traversal / Medium / 32m

* 572 / Subtree Of Another Tree / Easy / 23m

* 213 / House Robber II / Medium / 36m

* 207 / Course Schedule / Medium / 39m

* 150 / Evaluate Reverse Polish Notation / Medium / 19m

* 56 / Merge Intervals / medium / 21m

* 1584 / Min Cost to Connect All Points / Medium / 38m

* 235 / Lowest Common Ancestor of a Binary Search Tree / Medium / 28m

* 139 / Word Break / Medium / 13m

* 215 / Kth Largest Element in an Array / Medium / 13m

* 7 / Reverse Interger / Medium / 14m

* 743 / Network Delay Time / Medium / 37m

* 39 / Combination Sum / Medium / 29m

* 2013 / Detect Squares / Medium / 51m

* 57 / Insert Interval / Medium / 32m

Author: wjsdncl

wjsdncl/139_word_break.js

@@ -0,0 +1,33 @@
+/**
+ * 13m38s 소요
+ *
+ * 시간복잡도: O(n^2)
+ *
+ * 단어 s가 주어지고, 단어 사전 wordDict가 주어집니다.
+ * 단어 s를 단어 사전을 이용하여 구성할 수 있는지 여부를 반환하는 문제입니다.
+ *
+ * dp를 사용하여 풀 수 있습니다.
+ * dp[i]는 s의 0부터 i까지의 부분 문자열이 단어 사전을 이용하여 구성 가능한지 여부를 나타냅니다.
+ * dp[0]은 빈 문자열이므로 true로 초기화합니다.
+ * dp[i]를 구하기 위해 dp[j]를 검사합니다. (0 <= j < i)
+ * dp[j]가 true이고, s의 j부터 i까지의 부분 문자열이 단어 사전에 있는 경우 dp[i]를 true로 설정합니다.
+ * dp[s.length]를 반환합니다.
+ */
+var wordBreak = function (s, wordDict) {
+  const wordSet = new Set(wordDict); // 빠른 검색을 위한 Set 생성
+  const dp = new Array(s.length + 1).fill(false);
+  dp[0] = true; // 빈 문자열은 항상 구성 가능
+
+  // dp[i]를 구하기 위해 dp[j]를 검사
+  for (let i = 1; i <= s.length; i++) {
+    // dp[j]가 true이고, s의 j부터 i까지의 부분 문자열이 단어 사전에 있는 경우 dp[i]를 true로 설정
+    for (let j = 0; j < i; j++) {
+      if (dp[j] && wordSet.has(s.slice(j, i))) {
+        dp[i] = true;
+        break; // 가능한 경우를 찾으면 더 이상 탐색하지 않음
+      }
+    }
+  }
+
+  return dp[s.length];
+};

wjsdncl/1584_min_cost_to_connect_all_points.js

@@ -0,0 +1,50 @@
+/**
+ * 38m17s 소요
+ *
+ * 시간 복잡도: O(N^2)
+ *
+ * 어떻게 풀어야 할지 감이 안와서 풀이와 GPT의 도움을 받았습니다.
+ * Prim's Algorithm 또는 Kruskal's Algorithm 중 하나를 사용하여 풀 수 있다고 합니다.
+ *
+ * 모든 점들을 연결하는 최소 비용을 구하는 문제입니다.
+ *
+ * 시작점을 0으로 설정하고, 시작점에서 가장 가까운 점을 선택하여 MST에 추가합니다.
+ * 이후 추가된 점에서 가장 가까운 점을 선택하여 MST에 추가합니다.
+ * 이를 반복하여 모든 점을 연결할 때까지 반복합니다.
+ * 최종적으로 MST에 추가된 비용의 합을 반환합니다.
+ */
+var minCostConnectPoints = function (points) {
+  const n = points.length;
+  const minCost = new Array(n).fill(Infinity); // 최소 비용 배열
+  const visited = new Array(n).fill(false); // 방문 여부
+  minCost[0] = 0; // 시작점의 비용은 0
+  let totalCost = 0;
+
+  // 모든 점을 연결할 때까지 반복
+  for (let i = 0; i < n; i++) {
+    let currMin = Infinity;
+    let currPoint = -1;
+
+    // 최소 비용으로 연결할 점 선택
+    for (let j = 0; j < n; j++) {
+      if (!visited[j] && minCost[j] < currMin) {
+        currMin = minCost[j];
+        currPoint = j;
+      }
+    }
+
+    // 현재 점을 MST에 추가
+    visited[currPoint] = true;
+    totalCost += currMin;
+
+    // 다른 점들의 최소 비용 업데이트
+    for (let j = 0; j < n; j++) {
+      if (!visited[j]) {
+        const dist = Math.abs(points[currPoint][0] - points[j][0]) + Math.abs(points[currPoint][1] - points[j][1]);
+        minCost[j] = Math.min(minCost[j], dist);
+      }
+    }
+  }
+
+  return totalCost;
+};

wjsdncl/2013_detect_squares.js

@@ -0,0 +1,51 @@
+/**
+ * 51m18s 소요
+ *
+ * 시간복잡도: O(n) (n: 점의 개수)
+ *
+ * 주어진 점들로부터 정사각형을 만들 수 있는 경우의 수를 구하는 문제입니다.
+ *
+ * 어떻게 풀어야 할지 감이 전혀 안와서 풀이랑 GPT의 도움을 받았습니다.
+ *
+ * 점들의 빈도를 저장하기 위한 맵을 생성합니다.
+ * 새로운 점을 추가할 때마다 빈도를 증가시킵니다.
+ * 정사각형을 만들 수 있는 경우의 수를 구합니다.
+ * 대각선의 조건을 만족하는 점들을 찾습니다.
+ * 대각선 점을 기준으로 나머지 두 점의 빈도를 곱하여 더합니다.
+ * 결과를 반환합니다.
+ */
+var DetectSquares = function () {
+  // 점들의 빈도를 저장하기 위한 맵
+  this.points = new Map();
+};
+
+DetectSquares.prototype.add = function (point) {
+  const [x, y] = point;
+  const key = `${x},${y}`;
+  if (!this.points.has(key)) {
+    this.points.set(key, 0);
+  }
+  this.points.set(key, this.points.get(key) + 1);
+};
+
+DetectSquares.prototype.count = function (point) {
+  const [px, py] = point;
+  let count = 0;
+
+  // 모든 점을 탐색하며 정사각형의 가능성을 확인
+  for (let [key, freq] of this.points) {
+    const [x, y] = key.split(",").map(Number);
+
+    // x나 y가 같으면 대각선이 될 수 없으므로 스킵
+    if (x === px || y === py) continue;
+
+    // 대각선의 조건: 두 점 간의 x, y 차이가 같아야 함
+    if (Math.abs(x - px) === Math.abs(y - py)) {
+      // 대각선 점을 기준으로 나머지 두 점의 빈도를 곱함
+      const point1 = `${x},${py}`;
+      const point2 = `${px},${y}`;
+      count += (this.points.get(point1) || 0) * (this.points.get(point2) || 0) * freq;
+    }
+  }
+  return count;
+};

wjsdncl/215_kth_largest_element_in_an_array.js

@@ -0,0 +1,27 @@
+/**
+ * 13m25s 소요
+ *
+ * 시간복잡도: O(N log K) (N: nums의 길이, K: k)
+ *
+ * 배열에서 k번째로 큰 요소를 찾는 문제입니다.
+ *
+ * 최소 힙을 사용하여 풀 수 있습니다.
+ * 배열을 순회하며 힙에 요소를 삽입합니다.
+ * 힙 크기가 k를 초과하면 가장 작은 값을 제거합니다.
+ * 힙의 첫 번째 요소가 k번째로 큰 값입니다
+ */
+var findKthLargest = function (nums, k) {
+  const minHeap = new MinPriorityQueue(); // 최소 힙 생성
+
+  for (let num of nums) {
+    minHeap.enqueue(num); // 힙에 삽입
+
+    // 힙 크기가 k를 초과하면 가장 작은 값 제거
+    if (minHeap.size() > k) {
+      minHeap.dequeue();
+    }
+  }
+
+  // 힙의 첫 번째 요소가 k번째로 큰 값
+  return minHeap.front().element;
+};

wjsdncl/235_lowest_common_ancestor_of_a_binary_search_tree.js

@@ -0,0 +1,32 @@
+/**
+ * 28m41s 소요
+ *
+ * 시간복잡도: O(n) (n: 트리의 높이)
+ *
+ * 트리 문제라 어려울 줄 알았는데 생각보다 쉬웠습니다.
+ *
+ * 이진 탐색 트리에서 두 노드의 가장 가까운 공통 조상을 찾는 문제입니다.
+ *
+ * 현재 노드의 값이 두 노드보다 크면 왼쪽으로 이동하고,
+ * 현재 노드의 값이 두 노드보다 작으면 오른쪽으로 이동합니다.
+ * 현재 노드가 두 노드 사이에 있는 경우 현재 노드가 최소 공통 조상입니다.
+ *
+ * 최소 공통 조상을 찾지 못한 경우 null을 반환합니다.
+ */
+var lowestCommonAncestor = function (root, p, q) {
+  while (root) {
+    // 현재 노드 값이 두 노드보다 크면 왼쪽으로 이동
+    if (root.val > p.val && root.val > q.val) {
+      root = root.left;
+    }
+    // 현재 노드 값이 두 노드보다 작으면 오른쪽으로 이동
+    else if (root.val < p.val && root.val < q.val) {
+      root = root.right;
+    }
+    // 현재 노드가 LCA인 경우
+    else {
+      return root;
+    }
+  }
+  return null; // 트리 순회가 끝난 경우
+};

wjsdncl/39_combination_sum.js

@@ -0,0 +1,33 @@
+/**
+ * 29m41s 소요
+ *
+ * 시간복잡도: O(2^n)
+ *
+ * 주어진 숫자 배열에서 합이 target이 되는 모든 조합을 구하는 문제입니다.
+ *
+ * 백트래킹을 사용하여 모든 조합을 구합니다.
+ * 현재 합이 target과 같으면 결과 배열에 추가합니다.
+ * 현재 합이 target보다 크면 더 이상 탐색하지 않습니다.
+ * 현재 합이 target보다 작으면 다음 인덱스부터 탐색합니다.
+ * 탐색이 끝나면 결과 배열을 반환합니다.
+ */
+var combinationSum = function (candidates, target) {
+  const result = [];
+
+  const backtrack = (current, remain, start) => {
+    if (remain === 0) {
+      result.push([...current]);
+      return;
+    }
+    if (remain < 0) return;
+
+    for (let i = start; i < candidates.length; i++) {
+      current.push(candidates[i]);
+      backtrack(current, remain - candidates[i], i); // 같은 위치에서 다시 시작
+      current.pop(); // 탐색이 끝난 후 원래 상태로 복구
+    }
+  };
+
+  backtrack([], target, 0);
+  return result;
+};

wjsdncl/56_merge_intervals.js

@@ -0,0 +1,34 @@
+/**
+ * 21m41s 소요
+ *
+ * 시간복잡도: O(n log n)
+ *
+ * 배열의 모든 겹치는 구간을 병합하고 겹치지 않는 구간은 그대로 반환하는 문제입니다.
+ *
+ * 시작점을 기준으로 구간을 정렬하고, 결과 배열에 첫 구간을 넣어둡니다.
+ * 그 다음 구간부터 시작점이 이전 구간의 끝점보다 작거나 같은 경우 두 구간을 병합하고,
+ * 그렇지 않은 경우 결과 배열에 추가합니다.
+ */
+var merge = function (intervals) {
+  if (intervals.length <= 1) return intervals;
+
+  // 시작점 기준으로 구간 정렬
+  intervals.sort((a, b) => a[0] - b[0]);
+
+  const result = [intervals[0]]; // 초기 결과 배열
+
+  for (let i = 1; i < intervals.length; i++) {
+    const prev = result[result.length - 1]; // 결과 배열의 마지막 구간
+    const curr = intervals[i]; // 현재 구간
+
+    if (prev[1] >= curr[0]) {
+      // 겹치는 경우 병합
+      prev[1] = Math.max(prev[1], curr[1]);
+    } else {
+      // 겹치지 않는 경우 결과 배열에 추가
+      result.push(curr);
+    }
+  }
+
+  return result;
+};

wjsdncl/57_Insert_Interval.js

@@ -0,0 +1,39 @@
+/**
+ * 32m31s 소요
+ *
+ * 시간복잡도 : O(n) (n: intervals의 길이)
+ *
+ * 구간들의 배열과 새로운 구간이 주어질 때, 구간들을 병합한 결과를 반환하는 문제입니다.
+ *
+ * 구간들을 순회하면서 새로운 구간과 겹치는 구간을 병합합니다.
+ * 새로운 구간이 구간들보다 클 때까지 구간들을 병합합니다.
+ * 새로운 구간이 구간들보다 작을 때까지 구간들을 병합합니다.
+ * 나머지 구간들을 결과에 추가합니다.
+ * 결과를 반환합니다.
+ */
+var insert = function (intervals, newInterval) {
+  const result = [];
+  let i = 0;
+
+  // newInterval 이전의 겹치지 않는 구간 추가
+  while (i < intervals.length && intervals[i][1] < newInterval[0]) {
+    result.push(intervals[i]);
+    i++;
+  }
+
+  // newInterval과 겹치는 구간 병합
+  while (i < intervals.length && intervals[i][0] <= newInterval[1]) {
+    newInterval[0] = Math.min(newInterval[0], intervals[i][0]);
+    newInterval[1] = Math.max(newInterval[1], intervals[i][1]);
+    i++;
+  }
+  result.push(newInterval); // 병합된 구간 추가
+
+  // newInterval 이후의 겹치지 않는 구간 추가
+  while (i < intervals.length) {
+    result.push(intervals[i]);
+    i++;
+  }
+
+  return result;
+};

wjsdncl/743_network_delay_time.js

@@ -0,0 +1,58 @@
+/**
+ * 37m26s 소요
+ *
+ * 시간복잡도: O(n^2)
+ *
+ * 그래프 형태로 주어진 배열에서 k번 노드에서 모든 노드로 가는 최단 시간을 구하는 문제입니다.
+ *
+ * 어떻게 풀어야 할지 감이 잘 안와서 풀이랑 GPT의 도움을 받았습니다.
+ * 다익스트라 알고리즘을 사용하면 풀 수 있다고 합니다.
+ *
+ * 다익스트라 알고리즘은 최단 경로를 찾는 알고리즘 중 하나입니다.
+ * 시작 노드에서 다른 노드로 가는 최단 경로를 찾을 때 사용합니다.
+ *
+ * 그래프를 초기화합니다.
+ * 다익스트라 알고리즘을 사용하여 최단 경로를 찾습니다.
+ * 최단 경로 배열 중 최대값을 찾아 반환합니다.
+ */
+var networkDelayTime = function (times, n, k) {
+  const graph = new Map(); // 그래프 생성
+
+  // 그래프 초기화
+  for (let i = 1; i <= n; i++) {
+    graph.set(i, []);
+  }
+  for (let [u, v, w] of times) {
+    graph.get(u).push([v, w]);
+  }
+
+  // 다익스트라 알고리즘
+  const dist = Array(n + 1).fill(Infinity);
+  dist[k] = 0;
+
+  const pq = new MinPriorityQueue({ priority: (x) => x[1] }); // [노드, 거리]
+  pq.enqueue([k, 0]);
+
+  // 우선순위 큐에서 노드를 꺼내면서 최단 거리 갱신
+  while (!pq.isEmpty()) {
+    const [current, time] = pq.dequeue().element;
+
+    // 현재 노드의 거리가 최단 거리보다 크면 무시
+    if (time > dist[current]) continue;
+
+    // 인접 노드를 순회하며 최단 거리 갱신
+    for (let [neighbor, weight] of graph.get(current)) {
+      const newTime = time + weight;
+
+      // 최단 거리 갱신
+      if (newTime < dist[neighbor]) {
+        dist[neighbor] = newTime;
+        pq.enqueue([neighbor, newTime]);
+      }
+    }
+  }
+
+  // 최종 거리 배열에서 최대값 확인
+  const result = Math.max(...dist.slice(1)); // 1번 노드부터 n번 노드까지
+  return result === Infinity ? -1 : result;
+};

wjsdncl/7_reverse_integer.js

@@ -0,0 +1,20 @@
+/**
+ * 14m51s 소요
+ *
+ * 시간복잡도 : O(log n) (n: x의 길이)
+ *
+ * 32비트 정수 x를 뒤집어서 반환하는 문제입니다.
+ *
+ * 32비트 정수의 범위를 벗어나면 0을 반환합니다.
+ * 숫자를 문자열로 변환하여 뒤집은 뒤, 다시 숫자로 변환합니다.
+ * 32비트 정수 범위를 벗어나는지 확인합니다.
+ * 음수인 경우 부호를 복원합니다.
+ */
+var reverse = function (x) {
+  const isNegative = x < 0; // 음수 여부 확인
+  const reversed = parseInt(Math.abs(x).toString().split("").reverse().join("")); // 절댓값 뒤집기
+
+  if (reversed > 2 ** 31 - 1) return 0; // 32비트 정수 범위 확인
+
+  return isNegative ? -reversed : reversed; // 부호 복원
+};