자바스크립트 코딩테스트 강좌, 세그먼트 트리

문제 설명

문제: 일정 범위의 합 구하기

n개의 정수가 담긴 배열 arr가 주어질 때,
다음 쿼리들을 처리하는 함수를 작성하시오:

  • 1. update(index, value) : 배열 arrindex번째 값을 value로 갱신합니다.
  • 2. rangeSum(left, right) : 배열 arrleft번째부터 right번째(0-indexing)까지의 합을 계산합니다.

주어진 배열과 쿼리들을 사용하여 updaterangeSum의 요구 사항을 효율적으로 처리하세요.
배열의 크기는 최대 10^5이고, 쿼리의 개수는 최대 10^5입니다.

해결 방법

이 문제는 범위 합을 효율적으로 구하고 업데이트를 처리해야 하므로, 세그먼트 트리를 사용할 수 있습니다.
세그먼트 트리는 주어진 배열을 구간(구간 합 쿼리) 단위로 나누어 저장하는 이진트리 기반의 자료구조입니다.

세그먼트 트리의 정의

세그먼트 트리는 다음과 같은 속성을 가집니다:

  • 각 노드는 하나의 배열 구간에 대한 정보를 저장합니다. 이 정보는 구간의 합 혹은 최소, 최대 등으로 설정할 수 있습니다.
  • 트리의 높이는 O(log n)이며, 이는 쿼리 연산과 업데이트 연산 모두에 대해 O(log n)의 시간이 소요됨을 의미합니다.

세그먼트 트리 구현 단계

세그먼트 트리를 구현하기 위해 다음과 같은 절차를 따릅니다:

  1. 초기화: 주어진 배열을 기반으로 세그먼트 트리를 초기화합니다.
  2. 구간 합 쿼리: 특정 구간의 합을 계산하기 위해 필요한 레벨의 노드들을 재귀적으로 가져옵니다.
  3. 업데이트: 특정 인덱스의 값을 업데이트하고 관련 세그먼트 노드들을 갱신합니다.

JavaScript 코드 구현


class SegmentTree {
    constructor(arr) {
        this.n = arr.length;
        this.tree = new Array(this.n * 4);
        this.build(arr, 0, 0, this.n - 1);
    }

    build(arr, node, start, end) {
        if (start === end) {
            // 리프 노드에 정수 값 저장
            this.tree[node] = arr[start];
        } else {
            const mid = Math.floor((start + end) / 2);
            // 왼쪽 자식 정의
            this.build(arr, node * 2 + 1, start, mid);
            // 오른쪽 자식 정의
            this.build(arr, node * 2 + 2, mid + 1, end);
            // 부모 노드는 두 자식의 합으로 정의
            this.tree[node] = this.tree[node * 2 + 1] + this.tree[node * 2 + 2];
        }
    }

    rangeSum(left, right) {
        return this.sum(0, 0, this.n - 1, left, right);
    }

    sum(node, start, end, left, right) {
        if (right < start || end < left) {
            // 요청된 범위와 겹치지 않으면 0 반환
            return 0;
        }
        if (left <= start && end <= right) {
            // 요청된 범위가 구간 안에 포함되면 노드 반환
            return this.tree[node];
        }
        const mid = Math.floor((start + end) / 2);
        const leftSum = this.sum(node * 2 + 1, start, mid, left, right);
        const rightSum = this.sum(node * 2 + 2, mid + 1, end, left, right);
        return leftSum + rightSum;
    }

    update(index, value) {
        this.updateValue(0, 0, this.n - 1, index, value);
    }

    updateValue(node, start, end, index, value) {
        if (start === end) {
            // 리프 노드 업데이트
            this.tree[node] = value;
        } else {
            const mid = Math.floor((start + end) / 2);
            if (index <= mid) {
                this.updateValue(node * 2 + 1, start, mid, index, value);
            } else {
                this.updateValue(node * 2 + 2, mid + 1, end, index, value);
            }
            // 부모 노드 업데이트
            this.tree[node] = this.tree[node * 2 + 1] + this.tree[node * 2 + 2];
        }
    }
}

// 사용 예시
const arr = [1, 3, 5, 7, 9, 11];
const segmentTree = new SegmentTree(arr);
console.log(segmentTree.rangeSum(1, 3)); // 15
segmentTree.update(1, 10);
console.log(segmentTree.rangeSum(1, 3)); // 22

결론

세그먼트 트리는 배열의 구간 합을 효율적으로 처리할 수 있는 강력한 도구입니다.
이 자료구조를 통해 O(log n)의 시간복잡도로 알림 처리 및 구간 합 계산이 가능합니다.
실전에서의 복잡한 문제들이 요구할 때, 세그먼트 트리를 활용하여 많은 이점을 얻을 수 있습니다.

추가 연습 문제

다음 문제들을 연습해 보세요:

  • 세그먼트 트리를 사용하여 주어진 배열의 최소값 구하기
  • 구간에서 특정 값을 더하는 쿼리 추가
  • 세그먼트 트리로 최대값 구하기

자바스크립트 코딩테스트 강좌, 확장 유클리드 호제법

안녕하세요, 여러분! 오늘은 자바스크립트를 사용한 코딩테스트에서 중요한 알고리즘 중 하나인 확장 유클리드 호제법(Extended Euclidean Algorithm)에 대해 알아보겠습니다. 이 강좌에서는 확장 유클리드 호제법의 개념, 이를 이용한 문제풀이 과정, 그리고 실질적인 코드 예제를 제공합니다.

1. 문제 설명

문제를 다음과 같이 정의하겠습니다. 두 정수 A와 B가 주어지면, AX + BY = GCD(A, B)를 만족하는 정수 X와 Y를 구하는 문제입니다. 여기서 GCD는 최대공약수를 의미합니다.

예제

입력: A = 30, B = 21

출력: X = 1, Y = -1, GCD = 3

풀이: 30 * 1 + 21 * (-1) = 3

2. 개념 설명

확장 유클리드 호제법은 두 정수의 최대공약수(GCD)를 계산할 뿐만 아니라, 이로부터 특정 계수들을 찾는 방법입니다. 이는 주로 다음의 수식에서 사용됩니다:

AX + BY = GCD(A, B)

여기서 A와 B는 주어진 두 정수, X와 Y는 우리가 찾고자 하는 정수입니다. 만약 GCD가 1이라면, A와 B는 서로 소이므로 X와 Y는 모듈러 역수를 찾는 데에도 사용됩니다.

3. 접근 방법

우리는 GCD를 구하는 일반적인 유클리드 알고리즘을 기반으로 확장 유클리드 알고리즘을 구현할 것입니다. 알고리즘의 주요 아이디어는 다음과 같습니다:

  1. 두 정수 A와 B를 입력받습니다.
  2. If B는 0이면, GCD는 A이며, X는 1, Y는 0입니다.
  3. 그렇지 않으면, 유클리드 호제법을 사용하여 B와 A % B로 재귀 호출합니다.
  4. 재귀 호출의 결과를 이용해 X와 Y의 값을 계산합니다.

4. 알고리즘 구현

다음은 확장 유클리드 알고리즘을 자바스크립트로 구현한 예제입니다:


function extendedGCD(a, b) {
    if (b === 0) { // Base case
        return { gcd: a, x: 1, y: 0 };
    }
    // Recur with the new parameters b and a % b
    const { gcd, x: x1, y: y1 } = extendedGCD(b, a % b);
    const x = y1;
    const y = x1 - Math.floor(a / b) * y1;
    return { gcd, x, y };
}

// Test the function with example values
const a = 30;
const b = 21;
const { gcd, x, y } = extendedGCD(a, b);
console.log(`GCD: ${gcd}, X: ${x}, Y: ${y}`);

5. 코드 설명

위 코드에서 우리는 재귀적으로 GCD를 구하고 있습니다. 기본 조건에서는 B가 0일 때 GCD는 A가 되고, 이 때 X는 1, Y는 0이 됩니다. 그 후, 반환된 X와 Y 값을 이용해 새로운 X와 Y를 계산하여 최종적으로 우리가 원하는 결과를 얻습니다.

6. 테스트 케이스

이제 다양한 테스트 케이스를 통해 위의 함수를 검증해보겠습니다.


// Test cases
const testCases = [
    { a: 30, b: 21 },
    { a: 48, b: 18 },
    { a: 56, b: 15 },
    { a: 101, b: 10 },
];

testCases.forEach(({ a, b }) => {
    const { gcd, x, y } = extendedGCD(a, b);
    console.log(`A: ${a}, B: ${b} => GCD: ${gcd}, X: ${x}, Y: ${y}`);
});

7. 정리

오늘은 확장 유클리드 호제법에 대해 알아보았습니다. 이 알고리즘은 두 정수의 최대공약수를 구하고, 이에 대한 특정 계수를 찾는 데 매우 유용합니다. 특히 모듈러 연산이나 복잡한 알고리즘 문제에서 종종 활용되므로, 충분히 이해하고 연습하는 것이 중요합니다.

이 글에서 사용한 알고리즘이 여러분의 코딩 시험 준비에 도움이 되길 바랍니다. 추가 질문이 있다면 댓글로 남겨주세요!

자바스크립트 코딩테스트 강좌, 트리 순회하기

개요

코딩테스트에서는 다양한 자료구조와 알고리즘 문제가 출제됩니다. 그 중 트리는 자주 등장하는 자료구조입니다.
트리 구조는 컴퓨터 과학에서 매우 중요한 역할을 하며, 파일 시스템, 데이터베이스 등의 다양한 분야에서 활용됩니다.
이 강좌에서는 자바스크립트를 이용하여 트리를 순회하는 방법에 대해 배워보겠습니다.

트리 구조란?

트리(Tree)란 노드(Node)와 엣지(Edge)로 구성된 비선형 데이터 구조로, 계층적인 관계를 표현하는 데 최적화되어 있습니다.
트리는 루트 노드(root node)와 자식 노드(child node), 부모 노드(parent node), 잎 노드(leaf node) 등의 개념을 가지고 있습니다.

트리의 주요 특징은 다음과 같습니다:

  • 트리는 하나의 루트를 가지고 있으며, 자식 노드들이 이 루트로부터 연결됩니다.
  • 노드는 0개 이상의 자식 노드를 가질 수 있습니다.
  • 리프 노드는 자식이 없는 노드입니다.

트리의 순회 방법

트리를 순회하는 방법에는 여러 가지가 있으며, 가장 일반적으로 사용되는 방식은 다음과 같습니다:

  • 전위 순회(Pre-order Traversal)
  • 중위 순회(In-order Traversal)
  • 후위 순회(Post-order Traversal)
  • 레벨 순회(Level-order Traversal)

각각의 순회 방법은 노드를 방문하는 순서가 다릅니다. 각 방법에 대해 자세히 살펴보겠습니다.

전위 순회(Pre-order Traversal)

전위 순회의 방식은 다음과 같습니다:

  1. 현재 노드를 방문한다.
  2. 왼쪽 서브트리를 전위 순회한다.
  3. 오른쪽 서브트리를 전위 순회한다.

예를 들어, 다음과 같은 트리 구조가 있다고 가정해봅시다.

                공공
                ├── 사용자 1
                │   ├── 사용자 1.1
                │   └── 사용자 1.2
                └── 사용자 2
                    ├── 사용자 2.1
                    └── 사용자 2.2
                

전위 순회 결과는 “공공, 사용자 1, 사용자 1.1, 사용자 1.2, 사용자 2, 사용자 2.1, 사용자 2.2″입니다.

중위 순회(In-order Traversal)

중위 순회의 방식은 다음과 같습니다:

  1. 왼쪽 서브트리를 중위 순회한다.
  2. 현재 노드를 방문한다.
  3. 오른쪽 서브트리를 중위 순회한다.

예를 들어, 같은 트리 구조에서 중위 순회 결과는 “사용자 1.1, 사용자 1, 사용자 1.2, 공공, 사용자 2.1, 사용자 2, 사용자 2.2″입니다.

후위 순회(Post-order Traversal)

후위 순회의 방식은 다음과 같습니다:

  1. 왼쪽 서브트리를 후위 순회한다.
  2. 오른쪽 서브트리를 후위 순회한다.
  3. 현재 노드를 방문한다.

같은 트리 구조에서 후위 순회 결과는 “사용자 1.1, 사용자 1.2, 사용자 1, 사용자 2.1, 사용자 2.2, 사용자 2, 공공”입니다.

레벨 순회(Level-order Traversal)

레벨 순회의 방식은 다음과 같습니다:

  1. 루트 노드를 방문한다.
  2. 현재 노드의 자식 노드들을 방문한다.
  3. 모든 자식 노드를 방문한 후, 다음 깊이로 이동한다.

같은 트리 구조에서 레벨 순회 결과는 “공공, 사용자 1, 사용자 2, 사용자 1.1, 사용자 1.2, 사용자 2.1, 사용자 2.2″입니다.

프로그래밍 문제: 이진 트리 순회

다음과 같은 이진 트리 구조가 주어졌을 때, 다양한 순회 방법을 이용하여 트리를 순회하는 함수를 작성하시오.
이진 트리는 다음과 같은 노드로 구성됩니다:

            class TreeNode {
                constructor(value) {
                    this.value = value;
                    this.left = null;
                    this.right = null;
                }
            }
            

입력 예시:

            const root = new TreeNode(1);
            root.left = new TreeNode(2);
            root.right = new TreeNode(3);
            root.left.left = new TreeNode(4);
            root.left.right = new TreeNode(5);
            

문제

위의 트리를 전위 순회, 중위 순회, 후위 순회, 레벨 순회하는 함수를 각각 작성하시오.

문제 풀이 과정

1. 전위 순회 구현

전위 순회를 수행하기 위해서는 재귀적 접근이 필요합니다. 아래는 이를 구현한 코드입니다:

            function preOrderTraversal(node) {
                if (node === null) return;
                console.log(node.value); // 현재 노드 방문
                preOrderTraversal(node.left); // 왼쪽 서브트리 방문
                preOrderTraversal(node.right); // 오른쪽 서브트리 방문
            }
            

위 코드는 노드를 순회하면서 현재 노드를 먼저 방문한 후 왼쪽과 오른쪽 노드를 순회합니다.

2. 중위 순회 구현

중위 순회도 재귀적으로 구현합니다. 아래는 중위 순회 코드입니다:

            function inOrderTraversal(node) {
                if (node === null) return;
                inOrderTraversal(node.left); // 왼쪽 서브트리 방문
                console.log(node.value); // 현재 노드 방문
                inOrderTraversal(node.right); // 오른쪽 서브트리 방문
            }
            

이 코드는 왼쪽 서브트리를 먼저 방문한 후 현재 노드를 방문합니다.

3. 후위 순회 구현

후위 순회 역시 재귀적으로 구현합니다. 다음은 구현된 코드입니다:

            function postOrderTraversal(node) {
                if (node === null) return;
                postOrderTraversal(node.left); // 왼쪽 서브트리 방문
                postOrderTraversal(node.right); // 오른쪽 서브트리 방문
                console.log(node.value); // 현재 노드 방문
            }
            

후위 순회에서는 두 자식 서브트리를 방문한 후에 현재 노드를 방문합니다.

4. 레벨 순회 구현

레벨 순회는 큐 자료구조를 이용하여 구현합니다. 큐를 사용하면 각 노드를 층층이 방문할 수 있습니다. 다음은 레벨 순회 코드입니다:

            function levelOrderTraversal(root) {
                if (root === null) return;
                const queue = [root]; // 큐 초기화
                while (queue.length > 0) {
                    const current = queue.shift(); // 큐에서 노드 제거
                    console.log(current.value); // 현재 노드 방문
                    if (current.left) queue.push(current.left); // 왼쪽 자식 추가
                    if (current.right) queue.push(current.right); // 오른쪽 자식 추가
                }
            }
            

큐를 통해 각 노드를 레벨별로 차례대로 방문할 수 있습니다.

결론

이 강좌에서는 자바스크립트를 활용하여 트리를 순회하는 다양한 방법에 대해 알아보았습니다.
트리 순회는 많은 프로그래밍 문제에서 기본적인 부분을 차지하므로, 충분히 연습하는 것이 중요합니다.
위에서 다룬 전위, 중위, 후위, 레벨 순회 알고리즘을 잘 이해하고 구현하는 것이 코딩테스트에서 좋은 성과를 낼 수 있는 방법입니다.

앞으로도 연습을 통해 다양한 알고리즘 문제를 해결해보세요. 연습과 반복은 최고의 스승입니다!

자바스크립트 코딩테스트 강좌, 계단 수 구하기

안녕하세요, 오늘은 자바스크립트 코딩테스트 준비에 유용한 알고리즘 문제 중 하나인 “계단 수 구하기”를 풀어보겠습니다. 이 문제는 동적 프로그래밍(Dynamic Programming)과 조합적으로 접근할 수 있는 흥미로운 문제입니다. 이 글에서는 문제 설명, 풀이 과정, 그리고 최적화 방안을 포함하여 자세히 설명하겠습니다.

문제 설명

계단 수는 n 자리 수 중, 인접한 두 자리의 차이가 1인 수를 의미합니다. 예를 들어, 123, 321과 같이 인접한 자리의 숫자 차이가 1일 경우 이 수는 계단 수입니다. 주어진 n에 대해 n 자리 계단 수를 구하는 프로그램을 작성하세요.

입력

정수 n (1 ≤ n ≤ 1000)

출력

n 자리의 계단 수의 개수를 1,000,000,000으로 나눈 나머지를 출력합니다.

문제 풀이 전략

이 문제를 해결하기 위해서는 동적 프로그래밍 접근 방식을 사용할 수 있습니다. 계단 수는 다음과 같이 상태를 정의하여 해결할 수 있습니다:

  • dp[i][j]: i자리 계단 수 중, j로 끝나는 수의 개수

계단 수를 구성하는 규칙을 다음과 같이 세울 수 있습니다:

  • j가 0일 때(0으로 시작하는 수 없음): dp[i][0] = dp[i-1][1]
  • j가 9일 때: dp[i][9] = dp[i-1][8]
  • 그 외의 경우: dp[i][j] = dp[i-1][j-1] + dp[i-1][j+1]

동적 프로그래밍 테이블 초기화

이제 dp 테이블을 초기화해보겠습니다. 1자리 수의 경우, 숫자는 0부터 9까지 가능하므로 dp[1][0] 부터 dp[1][9]까지 각각 1로 초기화합니다.

풀이 코드


function countStairNumbers(n) {
    const MOD = 1000000000;
    const dp = Array.from({ length: n + 1 }, () => Array(10).fill(0));

    // 1자리 수 초기화
    for (let j = 0; j < 10; j++) {
        dp[1][j] = 1;
    }

    // dp 테이블 채우기
    for (let i = 2; i <= n; i++) {
        for (let j = 0; j < 10; j++) {
            if (j > 0) dp[i][j] += dp[i - 1][j - 1]; // j-1에서 이동
            if (j < 9) dp[i][j] += dp[i - 1][j + 1]; // j+1에서 이동
            dp[i][j] %= MOD; // modulo 연산
        }
    }

    // n자리 모든 계단 수의 합
    let result = 0;
    for (let j = 0; j < 10; j++) {
        result += dp[n][j];
    }

    return result % MOD;
}

// 함수 호출 예시
console.log(countStairNumbers(3)); // 24

시간 복잡도

위 코드의 시간 복잡도는 O(n)이며, 공간 복잡도는 O(n)입니다. 각 자리 수의 조합을 통해 결과를 도출하기 때문에 n이 커질수록 시간과 공간을 효율적으로 사용할 수 있습니다.

최적화 방안

현재 구현된 코드에서 메모리 사용량을 줄이기 위해 dp 배열을 2차원에서 1차원으로 변경할 수 있습니다. 각 i에 대해 이전의 dp 상태만 필요하기 때문에, 이를 이용해 최적화할 수 있습니다.


function countStairNumbersOptimized(n) {
    const MOD = 1000000000;
    const dp = Array(10).fill(0);
    const temp = Array(10).fill(0);

    // 1자리 수 초기화
    for (let j = 0; j < 10; j++) {
        dp[j] = 1;
    }

    for (let i = 2; i <= n; i++) {
        for (let j = 0; j < 10; j++) {
            temp[j] = 0;
            if (j > 0) temp[j] += dp[j - 1]; // j-1에서 이동
            if (j < 9) temp[j] += dp[j + 1]; // j+1에서 이동
            temp[j] %= MOD; // modulo 연산
        }
        for (let j = 0; j < 10; j++) {
            dp[j] = temp[j]; // 다음 단계로 업데이트
        }
    }

    // n자리 모든 계단 수의 합
    let result = 0;
    for (let j = 0; j < 10; j++) {
        result += dp[j];
    }

    return result % MOD;
}

마치며

이번 글에서는 “계단 수 구하기” 문제를 통해 자바스크립트로 동적 프로그래밍을 활용하여 문제를 해결하는 방법을 배웠습니다. 초기화, dp 테이블 구성, 그리고 최적화 과정을 자세히 설명하였으며, 다양한 테크닉을 사용하여 알고리즘의 효율성을 높일 수 있는 방법도 소개하였습니다. 알고리즘 문제를 풀 때는 항상 다양한 접근 방식을 고민하고 최적화할 방안을 모색해 보세요. 감사합니다!

자바스크립트 코딩테스트 강좌, 가장 빠른 버스 노선 구하기

문제 소개

당신은 A 지점에서 B 지점까지 가는 가장 빠른 버스 노선을 찾는 프로그램을 작성해야 합니다. 여러 개의 버스 노선이 있고 각각의 노선은 정해진 정류소를 지나며, 정류소 간의 이동 시간은 모두 다르게 설정되어 있습니다. 최종 목표는 특정한 A 지점에서 B 지점까지의 가장 빠른 경로를 찾고, 해당 경로의 소요시간을 반환하는 것입니다.

문제 설명

주어진 노선은 다음과 같이 표현됩니다. 각 노선은 정류소 간의 이동 시간을 가지며, 정류소는 다음과 같은 형태로 표현됩니다:

        [
            {busRoute: "1", stops: [{stop: "A", time: 0}, {stop: "B", time: 5}, {stop: "C", time: 10}]},
            {busRoute: "2", stops: [{stop: "A", time: 0}, {stop: "D", time: 3}, {stop: "B", time: 8}]},
            {busRoute: "3", stops: [{stop: "B", time: 0}, {stop: "C", time: 4}, {stop: "E", time: 6}]},
            {busRoute: "4", stops: [{stop: "D", time: 0}, {stop: "E", time: 2}, {stop: "B", time: 7}]},
        ]
    

입력

첫 번째 매개변수로는 버스 노선의 배열, 두 번째 매개변수로는 A 지점과 B 지점이 주어집니다.

출력

가장 빠른 경로의 소요 시간을 출력합니다. 경로가 없다면 -1을 출력합니다.

예제

        입력: 
        const routes = [
            {busRoute: "1", stops: [{stop: "A", time: 0}, {stop: "B", time: 5}, {stop: "C", time: 10}]},
            {busRoute: "2", stops: [{stop: "A", time: 0}, {stop: "D", time: 3}, {stop: "B", time: 8}]},
            {busRoute: "3", stops: [{stop: "B", time: 0}, {stop: "C", time: 4}, {stop: "E", time: 6}]},
            {busRoute: "4", stops: [{stop: "D", time: 0}, {stop: "E", time: 2}, {stop: "B", time: 7}]},
        ];
        const start = "A";
        const end = "B";

        출력: 
        5
    

해결 방법

이 문제를 해결하기 위해 우리는 그래프 탐색 알고리즘을 사용할 수 있습니다. 정류소는 노드로, 정류소 간 시간은 그 노드들 간의 엣지의 가중치로 표현할 수 있습니다. 적절한 알고리즘으로는 BFS(너비 우선 탐색)나 Dijkstra 알고리즘이 있습니다. 이 문제에서는 Dijkstra 알고리즘이 더 효과적입니다, 왜냐하면 모든 간선의 가중치가 다를 수 있어서 가장 짧은 경로를 찾기 위해 최적화된 방법이 필요하기 때문입니다.

Dijkstra 알고리즘 개요

Dijkstra는 가중치가 있는 그래프에서 최단 경로를 찾기 위한 알고리즘으로, 현재 노드에서 인접 노드로 이동할 때의 비용을 계속 업데이트하면서 최종 목표 노드로 가는 경로를 탐색합니다. 이를 위해 우리는 각 정류소와 비용을 기록할 수 있는 우선순위 큐를 사용합니다.

코드 구현

        function getFastestBusRoute(routes, start, end) {
            // Priority queue for processing the stops
            const pq = new MinPriorityQueue();
            const distances = {};
            const parents = {};

            // Initialize distances and priority queue
            for (const route of routes) {
                for (const stop of route.stops) {
                    distances[stop.stop] = Infinity;
                    parents[stop.stop] = null;
                }
            }

            // Starting point
            distances[start] = 0;
            pq.enqueue(start, 0);

            while (!pq.isEmpty()) {
                const currentStop = pq.dequeue().element;

                // If we reach the target stop, return the distance
                if (currentStop === end) {
                    return distances[currentStop];
                }

                for (const route of routes) {
                    for (let i = 0; i < route.stops.length - 1; i++) {
                        const stop1 = route.stops[i].stop;
                        const stop2 = route.stops[i + 1].stop;
                        const time = route.stops[i + 1].time - route.stops[i].time;

                        if (stop1 === currentStop) {
                            const newTime = distances[stop1] + time;
                            if (newTime < distances[stop2]) {
                                distances[stop2] = newTime;
                                parents[stop2] = stop1;
                                pq.enqueue(stop2, newTime);
                            }
                        }
                    }
                }
            }
            return -1; // If there's no path to the end
        }

        // Example usage
        const routes = [
            {busRoute: "1", stops: [{stop: "A", time: 0}, {stop: "B", time: 5}, {stop: "C", time: 10}]},
            {busRoute: "2", stops: [{stop: "A", time: 0}, {stop: "D", time: 3}, {stop: "B", time: 8}]},
            {busRoute: "3", stops: [{stop: "B", time: 0}, {stop: "C", time: 4}, {stop: "E", time: 6}]},
            {busRoute: "4", stops: [{stop: "D", time: 0}, {stop: "E", time: 2}, {stop: "B", time: 7}]},
        ];
        const start = "A";
        const end = "B";
        console.log(getFastestBusRoute(routes, start, end)); // Output: 5
    

결론

이번 강좌에서는 주어진 버스 노선 정보를 바탕으로 가장 빠른 경로를 찾는 알고리즘 문제를 해결하는 방법을 배웠습니다. Dijkstra 알고리즘은 가중치가 있는 그래프에서 최단 경로를 찾아주는 매우 유용한 방법입니다. 각 단계에서 실제로 어떻게 탐색을 진행하는지 이해하고, 이를 코딩으로 구현하는 과정에서 많은 도움이 되었기를 바랍니다.

추가 연습 문제

이번 문제를 통해 Dijkstra 알고리즘을 익혔다면, 다음과 같은 변형 문제들도 시도해 보세요:

  • 특정 노선만을 사용하여 경로를 찾아야 하는 문제
  • 정류소 간의 이동 시간이 아닌 이동 거리로 경로를 찾는 문제
  • 최소 경로가 아닌 최다 경로를 찾는 문제

참고 자료