[wjsdncl] 24.12.03

[wjsdncl]

📌 푼 문제

문제이름	문제링크
Reverse integer	https://leetcode.com/problems/reverse-integer
Network Delay Time	https://leetcode.com/problems/network-delay-time
Combination Sum	https://leetcode.com/problems/combination-sum
Detect Squares	https://leetcode.com/problems/detect-squares
Insert Interval	https://leetcode.com/problems/insert-interval

저번주에 못 올린 문제까지 풀었는데 확인은 이번주꺼만 해주시면 될거같습니다 🫡

---

📝 간단한 풀이 과정

7 Reverse integer

/**
 * 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; // 부호 복원
};

743 Network Delay Time

/**
 * 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;
};

39 Combination Sum

/**
 * 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;
};

2013 Detect Squares

/**
 * 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;
};

57 Insert Interval

/**

• 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;
};

---

풀이 고생하셨습니다 화이팅