[oh-chaeyeon] 24.12.03

[oh-chaeyeon]

📌 푼 문제

• 7. Reverse integer
• 743. Network Delay Time
• 39. Combination Sum
• 2013. Detect Squares
• 57. Insert Interval

---

📝 간단한 풀이 과정

7. Reverse integer

• 문제 : 32비트 정수 x의 숫자 자릿수를 뒤집어 새로운 정수를 반환해라~
• 접근 : 주어진 정수의 마지막 자릿수를 x % 10 을 통해 추출해서, 결과값에 10을 곱해 자릿수를 한 칸 올리고 추출된 자릿수를 더해 뒤집어 새로운 정수를 만들어가도록 했음.

var reverse = function (x) {
  let num = 0; //결과값을 저장할 변수 초기화
  const INT_MIN = -Math.pow(2, 31); //32비트 정수의 최소값
  const INT_MAX = Math.pow(2, 31) - 1; //32비트 정수의 최대값

  while (x !== 0) {   // x가 0이 될 때까지 반복
    let digit = x % 10;
    x = (x - digit) / 10;

    num = num * 10 + digit;

    if (num < INT_MIN || num > INT_MAX) { // 결과값이 범위를 벗어나면
      return 0;
    }
  }

  return num;
};

---

743. Network Delay Time

• 문제 : 주어진 노드 네트워크에서 특정 노드에서 신호를 보낼 때, 모든 노드가 신호를 받는 데 걸리는 최소 시간을 구하는 문제 (만약 모든 노드가 신호를 받을 수 없다면 -1을 반환)

• 접근 : 벨만-포드 알고리즘 활용 - 모든 간선을 최대 n-1번 반복하며 최단 경로를 갱신하는 방식으로 동작 (+챗gpt)

• 예제 : 입력: times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
  과정
  초기화 : minTime = [Infinity, Infinity, 0, Infinity, Infinity]
  -> 반복 1 :
  2 → 1: minTime[1] = 0 + 1 = 1
2 → 3: minTime[3] = 0 + 1 = 1
3 → 4: minTime[4] = 1 + 1 = 2
  결과 : [Infinity, 1, 0, 1, 2]
  -> 반복 종료 (더 이상 갱신 없음).
  결과 : 최대 시간 = 2

var networkDelayTime = function (times, n, k) { 
  const minTime = new Array(n + 1).fill(Infinity); //각 노드까지의 최소 도달 시간을 무한대로 설정
  minTime[k] = 0;

  for (let i = 1; i < n; i++) {
    for (const [u, v, w] of times) { // 모든 간선을 순회하도록
      if (minTime[u] !== Infinity && minTime[u] + w < minTime[v]) {
        minTime[v] = minTime[u] + w;  // 더 짧은 경로가 발견되면 갱신됨
      }
    }
  }

  const maxTime = Math.max(...minTime.slice(1)); //1번 노드부터 n번 노드까지의 최대 시간 계산
  return maxTime === Infinity ? -1 : maxTime;  //도달 불가능한 노드가 있으면 -1 반환, 아니면 최대 시간 반환
};

---

39. Combination Sum

• 문제 : 주어진 숫자 배열에서 목표 숫자를 만들기 위한 모든 고유한 조합을 찾는 문제 (목표 숫자를 만들 수 없는 경우에는 빈 배열을 반환하도록)

var combinationSum = function (candidates, target) {
  const dp = Array.from({ length: target + 1 }, () => []); //dp 배열 초기화
  dp[0] = [[]]; //합이 0인 경우-> 빈배열

  for (let i = 0; i < candidates.length; i++) {
    for (let j = candidates[i]; j <= target; j++) {
      const combinations = dp[j - candidates[i]]; //현재 숫자부터 목표값까지
      for (const combination of combinations) { //현재 숫자를 빼고 남은 값에서 가능한 조합들
        dp[j].push([...combination, candidates[i]]);
      }
    }
  }

  return dp[target]; // 최종적으로 목표값에 도달하는 모든 조합 반환
};

---

2013. Detect Squares

• 문제 : 주어진 점을 추가하고, 특정 점을 기준으로 세 점을 선택해 축에 맞춘 정사각형을 만들 수 있는 경우의 수를 세는 문제
• 접근 : 점의 좌표와 해당 점의 개수를 저장하기 위해 Map을 사용함.

var DetectSquares = function () {
  this.pointCount = new Map();
};

/**
 * @param {number[]} point
 * @return {void}
 */
DetectSquares.prototype.add = function (point) {
  const [x, y] = point;
  const key = `${x},${y}`;
  this.pointCount.set(key, (this.pointCount.get(key) || 0) + 1);
};

/**
 * @param {number[]} point
 * @return {number}
 */
DetectSquares.prototype.count = function (point) {
  const [x, y] = point;
  let totalSquares = 0;

  for (const key of this.pointCount.keys()) {
    const [px, py] = key.split(",").map(Number);

    if (Math.abs(px - x) !== Math.abs(py - y) || px === x || py === y) continue;

    const corner1 = `${px},${y}`;
    const corner2 = `${x},${py}`;

    const countCurrent = this.pointCount.get(key) || 0;
    const countCorner1 = this.pointCount.get(corner1) || 0;
    const countCorner2 = this.pointCount.get(corner2) || 0;

    totalSquares += countCurrent * countCorner1 * countCorner2;
  }

  return totalSquares;
};

---

57. Insert Interval

• 문제 : 주어진 비어있지 않은 구간 배열에 새 구간을 추가하고, 겹치는 구간이 있으면 병합하는 문제
• 접근 : 새 구간이 시작되기 전에 끝나는 모든 구간을 결과 배열에 추가한 다음, 새 구간과 겹치는 구간을 찾아 병합하여 새 구간의 시작과 끝을 업데이트.. 최종적으로, 남아 있는 구간을 결과 배열에 추가하고 최종 결과를 반환하도록 함.

var insert = function (intervals, newInterval) {
  const result = [];
  let i = 0;

  while (i < intervals.length && intervals[i][1] < newInterval[0]) {
    result.push(intervals[i]);
    i++;
  }

  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);

  while (i < intervals.length) {
    result.push(intervals[i]);
    i++;
  }

  return result;
};

---

어렵다.....