[oh-chaeyeon] 24.11.26

[oh-chaeyeon]

📌 푼 문제

• 56. Merge Intervals
• 1584. Min Cost to Connect all points
• 235. Lowest Common ancestor of a Binary Search Tree
• 139. Word Break
• 215. Kth largest element in an Array

---

📝 간단한 풀이 과정

56. Merge Intervals

• 문제 설명 : 주어진 여러 개의 구간에서 겹치는 구간들을 병합하여 겹치지 않는 구간으로 반환하는 문제
• 풀이 설명 : 주어진 구간을 시작값 기준으로 정렬한 후, 각 구간을 순회하며 마지막 구간과 겹치는지 확인하고, 겹친다면 끝 값을 병합하고, 겹치지 않으면 새로운 구간을 결과에 추가하여 최종적으로 병합된 구간들을 반환하는 순으로.

var merge = function (intervals) {
  if (intervals.length === 0) return [];
  intervals.sort((a, b) => a[0] - b[0]); // 시작값 기준으로 정렬하는 부분

  const merged = [intervals[0]];

  for (let i = 1; i < intervals.length; i++) {
    const current = intervals[i];

    // 현재 구간이 마지막 구간과 겹치는지 확인하고 겹친다면 마지막 구간의 끝 값을 업데이트
    if (current[0] <= merged[merged.length - 1][1]) {
      merged[merged.length - 1][1] = Math.max(
        merged[merged.length - 1][1],
        current[1]
      );
    } else { // 겹치지 않는다면, 현재 구간을 추가
      merged.push(current);
    }
  }

  return merged;
};

---

1584. Min Cost to Connect all points

(문제 풀다가 챗과 함꼐하는 시간으로.. 도움을 받았습니다.)

• 문제 설명 : 주어진 여러 점들을 최소 비용으로 연결하여 모든 점이 연결된 상태를 만드는 문제
• 접근법 : 점들을 최소 비용으로 연결하기 위해 프림 알고리즘을 사용하여 각 점까지의 최소 거리를 계산합니다. 방문하지 않은 점 중 최소 거리를 가진 점을 선택하고, 이를 통해 전체 비용을 누적합니다. 모든 점이 연결될 때까지 반복하여 최소 비용을 반환합니다.
• 프림 알고리즘이란? 프림 알고리즘은 가중치가 있는 그래프에서 최소 신장 트리를 찾는 효율적인 방법으로, 매 단계에서 가장 낮은 가중치의 간선을 선택하여 정점을 추가합니다.
• 가중치(weight) 란? 그래프에서 각 간선이나 노드에 부여된 값으로, 주로 거리, 비용, 시간 등과 같은 특정한 양
• 간선 가중치 : 두 노드(정점) 사이의 연결을 나타내는 간선에 부여된 값. 예를 들어, 두 도시 간의 거리, 두 작업 간의 소요 시간 등이 될 수 있음.

프림 알고리즘 작동방식

1. 시작 정점 선택 : 그래프의 임의의 정점에서 시작합니다.
2. 가장 낮은 가중치 간선 선택 : 현재 선택된 정점과 연결된 간선 중에서 가장 가벼운(가중치가 가장 낮은) 간선을 선택합니다. 이 간선을 통해 연결된 정점을 추가합니다.
3. 반복 : 추가된 정점에서 다시 인접한 간선들을 확인하고, 그 중에서 가장 낮은 가중치의 간선을 선택하여 새로운 정점을 계속 추가합니다 .
4. 종료 조건 : 모든 정점이 연결될 때까지 이 과정을 반복합니다.

var minCostConnectPoints = function(points) {
    const n = points.length; // 점의 개수
    const dist = new Array(n).fill(Infinity); // 각 점까지의 최소 거리 초기화
    const visited = new Array(n).fill(false); // 방문 여부 배열
    dist[0] = 0; // 첫 번째 점의 거리 0으로 설정
    let cost = 0; // 총 비용 초기화

    for (let i = 0; i < n; i++) {
        let minCost = Infinity; // 최소 거리 초기화
        let currentNode = -1; // 현재 선택된 점

        // 방문하지 않은 점 중에서 최소 거리를 가진 점 선택
        for (let j = 0; j < n; j++) {
            if (!visited[j] && dist[j] < minCost) {
                minCost = dist[j];
                currentNode = j;
            }
        }

        visited[currentNode] = true; // 선택된 점 방문 처리
        cost += minCost; // 총 비용에 추가

        // 선택된 점과 다른 점들 간의 거리 계산 및 업데이트
        for (let nextNode = 0; nextNode < n; nextNode++) {
            if (!visited[nextNode]) {
                const manhattanDistance = Math.abs(points[currentNode][0] - points[nextNode][0]) +
                                          Math.abs(points[currentNode][1] - points[nextNode][1]);
                dist[nextNode] = Math.min(dist[nextNode], manhattanDistance); // 최소 거리 업데이트
            }
        }
    }

    return cost; // 최소 비용 반환
};

---

235. Lowest Common ancestor of a Binary Search Tree

• 문제 설명 : 주어진 이진 탐색 트리에서 두 노드의 최소 공통 조상을 찾는 문제
• 접근 : 이진 탐색 트리의 특성 이용 -> 왼쪽 자식의 값이 부모보다 작고, 오른쪽 자식의 값이 부모보다 크다는 성질

var lowestCommonAncestor = function (root, p, q) {
  while (root) {
    if (p.val < root.val && q.val < root.val) { // p와 q가 현재 노드보다 작으면 왼쪽으로 이동
      root = root.left;
    } else if (p.val > root.val && q.val > root.val) {  // p와 q가 현재 노드보다 크면 오른쪽으로 이동
      root = root.right;
    } else {
      return root; // p와 q가 서로 다른 쪽에 있으면 현재 노드가 최소 공통 조상임
    }
  }
  return null; 
};

---

139. Word Break

• 문제 : 주어진 문자열 s를 사전의 단어들로 나누어 구성할 수 있는지를 판단하는 문제
• 접근 : 또 만난 동적 프로그래밍을 이용하는 문제,, 동적 프로그래밍을 사용하여 문자열을 사전의 단어로 나누는 가능성을 확인하는 로직으로, dp 배열을 활용해 각 인덱스까지 나눌 수 있는지를 기록하고, 마지막 인덱스의 값을 통해 결과를 판단함.

var wordBreak = function (s, wordDict) {
  const wordSet = new Set(wordDict);
  const dp = new Array(s.length + 1).fill(false);
  dp[0] = true; // 빈 문자열은 항상 나눌 수 있음

  for (let i = 1; i <= s.length; i++) {
    for (const word of wordSet) {
      const wordLength = word.length;

      //현재 인덱스에서 단어를 뺀 인덱스가 유효하고, 해당 부분이 단어와 일치하는지 확인
      if (
        i >= wordLength &&
        dp[i - wordLength] &&
        s.substring(i - wordLength, i) === word
      ) {
        dp[i] = true;  //나눌 수 있으면 true로 설정
        break;
      }
    }
  }

  return dp[s.length];
};

---

215. Kth largest element in an Array

• 문제 : 주어진 정수 배열 nums에서 k번째로 큰 요소를 찾는 문제
• 접근 : 원래는 heap을 사용해서 문제를 풀었는데, 런타임이 148~183ms까지 나와서 heap으로 런타임을 100ms이하로 하기 위해 여러 방법을 썼는데,,안되서 챗GPT 이용해서 다른 풀이방법을 찾다가 수정한 풀이가 밑에 있는 풀이입니다.

Heap 이용해서 한 풀이

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
var findKthLargest = function(nums, k) {
    const maxHeap = new MaxPriorityQueue();

    for (const num of nums) {
        maxHeap.enqueue(num);
    }
    
    for (let i = 0; i < k - 1; i++) {
        maxHeap.dequeue();
    }
    return maxHeap.front().element; 
};

주어진 배열의 값이 -10,000부터 10,000까지 있기에, 계수 정렬을 사용한 풀이

• 풀이 : 계수 정렬을 활용하여 주어진 배열의 각 요소의 빈도를 기록한 후, 역순으로 탐색하여 k번째로 큰 요소를 찾습니다.

• 계수 정렬 : 정수의 범위가 제한된 경우에 매우 효율적으로 작동하는 정렬 알고리즘으로, 배열의 각 요소가 몇 번 나타나는지를 세어서 정렬을 수행함.

• 오프셋 : 특정 값에 일정한 수를 더하거나 빼서 값의 범위를 조정하는 방법, 주로 배열의 인덱스가 음수가 될 때, 이를 양수로 변환하기 위해 사용됨.

var findKthLargest = function (nums, k) {
  const offset = 10000; // 값의 범위를 맞추기 위한 오프셋
  const count = new Array(20001).fill(0);  // 빈도 배열 초기화

  // 각 숫자의 빈도를 기록
  for (let num of nums) {
    count[num + offset]++;  // 각 숫자의 빈도 증가
  }

  let total = 0;

  // 배열을 역순으로 탐색
  for (let i = count.length - 1; i >= 0; i--) {
    total += count[i];  // 빈도 누적
    if (total >= k) return i - offset;  // k번째 큰 요소 반환
  }
};

---