라이브스마트

문제 소개

당신은 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 알고리즘을 익혔다면, 다음과 같은 변형 문제들도 시도해 보세요:

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

참고 자료

• Dijkstra’s Algorithm – Wikipedia
• JavaScript Guide – MDN Web Docs
• Dijkstra’s Shortest Path Algorithm – GeeksforGeeks

안녕하세요! 이번 블로그 글에서는 자바스크립트로 코딩테스트에서 출제될 수 있는 수들을 묶어서 최댓값 만들기 문제에 대해 다뤄보겠습니다. 이 문제는 다양한 알고리즘적 사고를 요구하며, 최적화 문제에 대한 이해를 깊이 있게 할 수 있는 기회를 제공합니다. 목표는 주어진 숫자들을 조합하여 가능한 최대 수를 만들어내는 것입니다.

문제 정의

주어진 수를 두 개 묶어서 곱하는 작업을 반복해 최댓값을 만들어내야 합니다. 자세한 문제 정의는 다음과 같습니다.

문제: N개의 자연수로 이루어진 배열이 주어질 때, 이 배열의 모든 수를 두 개씩 묶어서 곱하고 그 결과의 합을 최대화하는 프로그램을 작성하시오.

입력:
- 첫 줄에 자연수 N (1 ≤ N ≤ 1000).
- 둘째 줄에 N개의 자연수 a1, a2, ..., aN (1 ≤ ai ≤ 1000)가 주어짐.

출력:
- 최댓값을 출력하시오.

문제 예시

입력:
5
1 2 3 4 5

출력:
43

문제 접근법

이 문제를 해결하기 위해서는 몇 가지 주요 단계가 필요합니다.

• 정렬: 주어진 수를 내림차순으로 정렬합니다. 가장 큰 수를 남겨두어 최대한 큰 곱 결과를 생성하기 위한 준비 단계입니다.
• 짝짓기: 배열에서 수를 두 개씩 묶어 곱하고, 그 결과를 모두 누적합니다. 짝짓기를 할 때는 가장 큰 두 수를 묶고, 그 다음 두 큰 수를 묶는 방식으로 진행합니다.
• 예외 처리: 홀수개의 수가 입력된 경우, 마지막 남은 수는 따로 처리하여 결과에 포함시켜야 합니다.

구현

자바스크립트로 이 문제를 해결하기 위한 코드를 작성해보겠습니다. 아래는 구현된 코드입니다.

function maxSumFromPairs(numbers) {
    // 배열을 내림차순으로 정렬
    numbers.sort((a, b) => b - a);
    
    let maxSum = 0;

    // 두 개씩 묶어서 곱하고 합산하기
    for (let i = 0; i < numbers.length; i += 2) {
        // 마지막 요소가 홀수일 경우, 남은 요소는 혼자 더함
        if (i === numbers.length - 1) {
            maxSum += numbers[i];
        } else {
            maxSum += numbers[i] * numbers[i + 1];
        }
    }
    return maxSum;
}

// 예제 사용
const numbers = [1, 2, 3, 4, 5];
console.log(maxSumFromPairs(numbers)); // 43

코드 분석

코드의 각 부분을 분석해보겠습니다.

1. 정렬

먼저, 배열을 내림차순으로 정렬합니다. 이를 통해 더 큰 수가 먼저 오게 되고, 이를 기반으로 곱을 계산하게 됩니다. 자바스크립트에서 배열의 정렬은 sort 메소드를 사용하여 간단하게 수행할 수 있습니다.

2. 짝짓기 및 합산

반복문을 통해 배열의 요소를 두 개씩 읽어들이고, 그 곱을 maxSum에 누적합니다. 만약 배열의 길이가 홀수라면, 마지막 남은 요소는 보름의 수로 그냥 더해집니다.

3. 결과 반환

최종적으로 maxSum을 반환합니다. 코드는 간단하지만, 이로 인해 효율적으로 최댓값을 구할 수 있게 됩니다.

복잡도 분석

이 알고리즘의 시간 복잡도는 O(N log N)입니다. 이는 배열을 정렬하는 데 들어가는 시간 때문입니다. 이후의 반복문은 O(N)으로, 전체적으로 정렬을 제외한 연산은 선형입니다. 공간 복잡도는 O(1)로, 추가적인 공간을 사용하지 않으므로 메모리 효율도 좋습니다.

테스트 케이스

테스트 케이스를 몇 가지 추가하여 코드의 정확성을 검증해보겠습니다.

console.log(maxSumFromPairs([3, 5, 1, 2, 4])); // 47
console.log(maxSumFromPairs([1])); // 1
console.log(maxSumFromPairs([9, 7, 5, 3])); // 64
console.log(maxSumFromPairs([1, 1, 1, 1, 1])); // 5

결론

이번 글에서는 수를 묶어서 최댓값 만들기에 대한 문제를 다뤄보았습니다. 배열을 정렬하고, 최댓값을 구하는 방식으로 알고리즘을 구현했습니다. 이를 통해 배열의 즉각적인 처리를 어떻게 효율적으로 할 수 있는지에 대해 고민하게 되는 좋은 경험이 되셨기를 바랍니다.

자바스크립트를 사용한 코딩테스트에서는 이와 같은 최적화 문제들이 많이 출제되니, 꾸준한 연습이 필요합니다. 추가적으로 다양한 문제에 도전해보면서 알고리즘적 사고를 발전시켜 나가길 바랍니다!