자바스크립트 코딩테스트 강좌, 타임머신으로 빨리 가기

코딩 시험은 점점 더 많은 기업들에서 필수적으로 진행되고 있으며, 자바스크립트는 웹 개발에서 가장 인기 있는 언어 중 하나입니다.
이 강좌에서는 자바스크립트를 사용하여 코딩 시험에서 흔히 나오는 알고리즘 문제를 풀어보겠습니다.
오늘의 주제는 ‘타임머신으로 빨리 가기’라는 문제입니다.

문제 설명

당신은 타임머신을 조작할 수 있는 과학자입니다. 타임머신은 특정 시간으로 이동할 수 있으며,
두 개의 정수 a, b가 주어졌을 때, a에서 b로 이동하는 데 걸리는 최소 시간 (이동 횟수를 의미)
을 계산해야 합니다. 타임머신은 다음과 같은 규칙을 따릅니다:

  • 현재 위치에서 1을 더하거나 1을 뺄 수 있습니다.
  • 현재 위치를 2배로 만들 수 있습니다.

주어진 a와 b에 대해 최소한 몇 번의 이동으로 a에서 b로 이동할 수 있는지를 계산하는 함수를 작성하세요.

입력 형식

– 두 개의 정수 a (0 ≤ a ≤ 105), b (0 ≤ b ≤ 105)가 주어집니다.

출력 형식

– a에서 b로 이동하기 위한 최소 이동 수를 정수로 출력합니다.

예제

        입력: a = 2, b = 9
        출력: 4
    
        입력: a = 5, b = 22
        출력: 7
    

문제 풀이 접근 방법

이 문제를 해결하기 위해 우리는 BFS(너비 우선 탐색)를 사용할 것입니다. BFS는 최단 경로를 찾는 데 적합한 알고리즘으로,
주어진 상태에서 가능한 모든 상태를 탐색하여 목표 상태에 도달하는 가장 최소한의 이동 경로를 찾는 방식입니다.
이 경우, 각각의 상태는 타임머신이 위치할 수 있는 시간을 나타냅니다.

1단계: BFS 알고리즘 사용 준비

BFS를 구현하기 위해, 우리는 큐를 사용할 것입니다. 먼저, 시작 위치인 a를 큐에 추가합니다.
그리고 현재 위치에서 가능한 모든 이동을 큐에 추가하면서 목표 위치인 b에 도달할 때까지 반복합니다.
각 위치에서 가능한 이동은 다음과 같습니다:

  • 현재 위치에서 1을 더하기
  • 현재 위치에서 1을 빼기
  • 현재 위치를 2배로 만들기

목표 위치에 도달할 때까지 각 이동의 횟수를 기록할 것이며, 목표에 도달했을 때의 이동 횟수를 출력합니다.

2단계: 코드 구현


function minimumMoves(a, b) {
    if (a >= b) return a - b; // a가 b보다 크거나 같으면 정해진 시간 만큼 차감하는 것으로 이동 횟수 결정
    const queue = [[a, 0]]; // [현재 위치, 이동 수]
    const visited = new Set(); // 방문한 위치 기록
    visited.add(a); // 시작 위치를 방문 처리

    while (queue.length > 0) {
        const [current, moves] = queue.shift(); 

        // 가능한 모든 이동
        const nextMoves = [current - 1, current + 1, current * 2]; 

        for (let next of nextMoves) {
            if (next === b) return moves + 1; // 목표 위치에 도달하면 이동 수 반환
            if (next < 0 || next > 100000 || visited.has(next)) continue; // 유효 범위 내에서 방문하지 않은 경우만
            visited.add(next); // 다음 위치 방문 처리
            queue.push([next, moves + 1]); // 다음 위치와 이동 수 큐에 추가
        }
    }
}
    

3단계: 알고리즘 복잡도 분석

알고리즘의 시간 복잡도는 O(n) 입니다.
최악의 경우 모든 가능한 위치를 탐색해야 하므로 O(n)에 해당하고,
공간 복잡도도 O(n)입니다. 큐와 방문 기록을 위한 공간을 고려하면 이러한 복잡도가 발생합니다.

4단계: 최적화 가능성

이 알고리즘은 이미 BFS를 기반으로 하여 최단 경로를 탐색하고 있으므로
추가적인 최적화는 필요하지 않습니다. 그러나 상황에 따라
DFS(깊이 우선 탐색)를 적용할 수도 있지만, 이 문제에서는 BFS가 더 효과적입니다.

5단계: 결론

‘타임머신으로 빨리 가기’ 문제를 통해 BFS의 원리를 간단히 이해하고,
자바스크립트를 활용하여 문제를 해결하는 방법을 배웠습니다.
이런 방식으로 다양한 문제를 해결할 수 있으며,
코딩테스트에서 좋은 성적을 얻기 위해 기본적인 알고리즘을 숙지하는 것이 중요합니다.

추가 자료

– BFS 알고리즘에 대한 심화 연구 및 다양한 문제 풀이를 연습하기 위해 다음의 자료를 추천드립니다.

자바스크립트 코딩테스트 강좌, 오일러 피 함수 구현하기

안녕하세요, 여러분! 오늘은 자바스크립트로 오일러 피 함수(𝜙(n))를 구현하는 방법에 대해 자세히 설명드리겠습니다. 오일러 피 함수는 주어진 정수 n보다 작거나 같은 정수 중 n과 서로 소인 정수의 개수를 나타냅니다. 이 문제는 수론 관련 알고리즘 문제에서 매우 자주 등장하며, 다양한 코딩 테스트에서 유용하게 활용될 수 있습니다.

오일러 피 함수란?

오일러 피 함수 𝜙(n)은 n과 서로 소인 1부터 n까지의 양의 정수의 개수를 반환합니다. 다시 말하면, 두 수 a와 b가 서로 소라는 것은 두 수의 최대공약수(GCD)가 1일 때를 의미합니다.

예를 들어:

  • 𝜙(1) = 1 (1과 서로 소인 수는 1 하나뿐)
  • 𝜙(2) = 1 (2보다 작고 2와 서로 소인 수는 1)
  • 𝜙(3) = 2 (3보다 작고 3과 서로 소인 수는 1, 2)
  • 𝜙(4) = 2 (4보다 작고 4와 서로 소인 수는 1, 3)
  • 𝜙(5) = 4 (5보다 작고 5와 서로 소인 수는 1, 2, 3, 4)

문제 정의

이제 코딩 테스트 문제를 정의해보겠습니다.

문제: 주어진 정수 n에 대해 오일러 피 함수를 계산하는 함수를 작성하라.
입력: 정수 n (1 ≤ n ≤ 106)
출력: 오일러 피 함수 𝜙(n)의 값

문제 해결 접근법

오일러 피 함수를 계산하는 방법에는 여러 가지가 있습니다. 가장 효율적인 방법은 에라토스테네스의 체를 변형하여 𝜙(n) 값을 한 번에 구하는 것입니다. 이 방법의 시간 복잡도는 O(n log log n)입니다.

오일러 피 함수의 성질

𝜙(n)을 계산하기 위해 필요한 중요한 성질은 다음과 같습니다:

  • 𝜙(p) = p – 1, 여기서 p는 소수
  • 𝜙(p1 * p2 * … * pk) = p1 * p2 * … * pk * (1 – 1/p1) * (1 – 1/p2) * … * (1 – 1/pk)
  • 𝜙(n) = n * (1 – 1/p1) * (1 – 1/p2) * … * (1 – 1/pk), 여기서 pi는 n의 소인수들입니다.

자바스크립트 코드 구현

위의 성질을 바탕으로 오일러 피 함수를 구현하는 코드를 작성해보겠습니다.


function eulerPhi(n) {
    // 배열 선언 및 초기화
    const phi = Array.from({ length: n + 1 }, (_, i) => i);
    
    // 에라토스테네스의 체를 사용한 소수 찾기
    for (let p = 2; p <= n; p++) {
        if (phi[p] === p) { // p가 소수인 경우
            for (let k = p; k <= n; k += p) {
                // 𝜙(k) 값 업데이트
                phi[k] = Math.floor(phi[k] * (1 - 1 / p));
            }
        }
    }
    
    // n에 대한 phi(n) 반환
    return phi[n];
}

// 테스트 케이스
console.log(eulerPhi(1));  // 1
console.log(eulerPhi(2));  // 1
console.log(eulerPhi(3));  // 2
console.log(eulerPhi(4));  // 2
console.log(eulerPhi(5));  // 4

코드 설명

코드는 다음과 같이 작동합니다:

  1. 우선 n + 1 크기의 배열 phi를 생성하고, 각 요소를 그 자체로 초기화합니다. phi[i]는 i를 초기값으로 가집니다.
  2. 2부터 n까지 반복하면서, 각 수 p가 소수인지 검사합니다. 이를 위해, phi[p]가 p와 같은 경우 소수로 간주합니다.
  3. p가 소수일 경우, p의 배수를 찾아 phi[k] 값을 업데이트합니다. 업데이트는 𝜙(k) = 𝜙(k) * (1 – 1/p)로 수행합니다.
  4. 최종적으로, phi[n] 값을 반환하여 n에 대한 오일러 피 함수의 값을 계산합니다.

복잡도 분석

위 코드의 시간 복잡도는 O(n log log n)입니다. 이는 에라토스테네스의 체를 사용하는 방법 때문입니다. 공간 복잡도는 O(n)입니다, 배열 phi를 저장하기 위해 n의 크기만큼의 공간이 필요합니다.

결론

지금까지 자바스크립트로 오일러 피 함수를 구현하는 방법에 대해 알아보았습니다. 이 방법은 알고리즘 테스트 및 수론에 매우 유용하며, 효율적으로 오일러 피 값을 계산할 수 있습니다. 이 코드를 활용하여 다양한 문제를 해결해 보시기 바랍니다.

더 나아가기

비슷한 문제를 풀어보고 싶다면, 최대공약수나 최소공배수를 사용하는 문제를 해결해보는 것 또한 좋은 연습이 될 것입니다. 또한 수론의 다른 개념인 소수 판별, 소수 생성기 등을 연구해보는 것도 추천드립니다. 수학적 사고를 통해 알고리즘에 대한 이해도를 높여보세요!

참고 자료

이 포스팅이 도움이 되셨기를 바랍니다. 궁금한 점이나 추가적인 질문이 있으시다면 댓글로 남겨주세요! 감사합니다!

자바스크립트 코딩테스트 강좌, 최소 신장 트리 구하기

오늘은 알고리즘 테스트에서 자주 등장하는 문제 중 하나인 ‘최소 신장 트리(MST, Minimum Spanning Tree)’를 구하는 방법에 대해 알아보겠습니다. 특히, 자바스크립트를 사용하여 이 문제를 해결하는 방법을 단계별로 설명하도록 하겠습니다. 이 강좌를 통해 여러분은 모든 개념을 이해하고, 실제 코딩테스트에서도 자신있게 이 문제를 해결할 수 있는 능력을 기르게 될 것입니다.

1. 최소 신장 트리란?

최소 신장 트리는 연결 그래프에서 정점들을 모두 포함하는 부분 그래프이며, 그 부분 그래프의 간선 비용의 합이 최소가 되는 그래프입니다. 즉, 모든 정점이 연결되어 있으면서 최소한의 비용으로 연결된 트리를 의미합니다. MST는 네트워크 설계, 교통 시스템, 클러스터링 등 다양한 분야에서 활용됩니다.

2. 문제 설명

주어진 그래프의 정점과 간선 정보가 있을 때, 최소 신장 트리를 구하고 그 총 가중치를 반환하는 함수를 작성하세요.

입력 형식

  • 정점의 개수 n (1 ≤ n ≤ 1000)
  • 간선의 개수 m (1 ≤ m ≤ 10000)
  • 각 간선은 (a, b, c)의 형태로 주어지며, a와 b는 정점, c는 간선의 가중치입니다.

출력 형식

최소 신장 트리의 총 가중치를 출력합니다.

예시

    입력:
    4 5
    1 2 1
    1 3 4
    2 3 2
    1 4 3
    3 4 5

    출력:
    6
    

3. 알고리즘 선택

최소 신장 트리를 구하는 방법에는 여러 가지가 있습니다. 그 중에서도 크루스칼 알고리즘(Kruskal’s Algorithm)프림 알고리즘(Prim’s Algorithm)이 널리 사용됩니다. 여기서는 크루스칼 알고리즘을 사용할 것입니다.

크루스칼 알고리즘

크루스칼 알고리즘은 간선을 기준으로 정렬한 후, 가장 낮은 가중치의 간선부터 선택하여 사이클을形成하지 않는 한에서 최소 신장 트리를 만들 수 있도록하는 방식입니다. 이 방법은 주어진 간선 목록을 먼저 정렬한 뒤, 가장 가벼운 간선부터 추가해 나가는 방식입니다.

4. 알고리즘 구현

이제 크루스칼 알고리즘을 이용하여 문제를 해결하는 자바스크립트 코드를 작성해 보겠습니다. 전체 단계는 다음과 같습니다:

  1. 간선 정보를 입력받은 후, 가중치 기준으로 정렬합니다.
  2. 유니온-파인드(Union-Find) 자료구조를 활용하여 사이클이 형성되지 않도록 간선을 포함합니다.
  3. 모든 간선을 처리한 후, 최소 신장 트리의 총 가중치를 계산하여 반환합니다.

코드 구현

    
    function find(parent, i) {
        if (parent[i] === -1) {
            return i;
        }
        return find(parent, parent[i]);
    }

    function union(parent, x, y) {
        const xset = find(parent, x);
        const yset = find(parent, y);
        parent[xset] = yset;
    }

    function kruskal(n, edges) {
        edges.sort((a, b) => a[2] - b[2]); // 간선 가중치 기준으로 정렬
        let parent = Array(n + 1).fill(-1);
        let minWeight = 0;
        const mst = [];

        for (let i = 0; i < edges.length; i++) {
            const [u, v, weight] = edges[i];

            if (find(parent, u) !== find(parent, v)) {
                union(parent, u, v);
                minWeight += weight;
                mst.push([u, v, weight]);
            }
        }

        return { minWeight, mst };
    }

    // 예시 입력 데이터
    const n = 4;
    const edges = [
        [1, 2, 1],
        [1, 3, 4],
        [2, 3, 2],
        [1, 4, 3],
        [3, 4, 5]
    ];

    const result = kruskal(n, edges);
    console.log("최소 신장 트리의 총 가중치:", result.minWeight);
    
    

5. 코드 해설

위 코드는 크루스칼 알고리즘을 사용하여 주어진 그래프의 최소 신장 트리를 구하는 함수입니다. 다음과 같은 주요 부분으로 나뉩니다:

5.1. 유니온-파인드 함수

유니온-파인드(Union-Find) 자료구조는 그래프의 연결 성분을 추적하는 데 사용됩니다. 각 노드는 자신의 부모를 가지고 있습니다. find 함수는 노드가 속한 집합의 대표자를 찾고, union 함수는 두 집합을 합칩니다.

5.2. 간선 정렬

간선 목록을 가중치 기준으로 정렬하여 최소 가중치의 간선부터 선택할 수 있도록 합니다. 자바스크립트의 sort 메서드를 사용하여 간단히 정렬할 수 있습니다.

5.3. 최소 신장 트리 구성

각 간선에 대해 두 노드의 부모를 확인하여 사이클이 생기지 않는 경우에만 그 간선을 선택합니다. 선택된 간선은 mst 배열에 저장되며, 가중치의 합은 minWeight 변수에 증가합니다.

6. 성능 분석

크루스칼 알고리즘의 시간 복잡도는 O(E log E)입니다. 여기서 E는 간선의 수입니다. 주어진 문제의 제약 사항 하에서 이 알고리즘은 효율적입니다. 유니온-파인드의 경로 압축 기법을 사용할 경우 추가적인 성능 향상을 기대할 수 있습니다.

7. 마무리

이번 강좌에서는 자바스크립트를 사용하여 최소 신장 트리를 구하는 크루스칼 알고리즘에 대해 알아보고, 문제를 해결하는 방법에 대해 상세히 설명하였습니다. 그래프 문제들은 알고리즘 경진대회 및 여러 코딩 테스트에서 빈번히 출제되므로, 여러분이 익혀두면 많은 도움이 될 것입니다. 다음에는 다른 알고리즘이나 데이터 구조를 활용하여 다양한 문제를 함께 풀어보도록 하겠습니다.

8. 연습 문제

아래의 문제를 풀어보세요. 문제를 해결한 후에 자신의 코드를 리뷰하여 최적화할 수 있는 부분이 있는지 점검해 보세요.

주어진 그래프에서 최소 신장 트리의 간선을 추출한 후, 이 간선의 가중치 목록과 함께 출력하는 알고리즘을 작성하세요.

9. 참고 자료

자바스크립트 코딩테스트 강좌, 기수 정렬

본 강좌에서는 자바스크립트로 구현된 기수 정렬(Radix Sort) 알고리즘을 소개하고, 이를 어떻게 활용하여 코딩테스트 문제를 해결할 수 있는지에 대해 상세히 설명하겠습니다. 기수 정렬 알고리즘의 개념, 구현 방법, 시간 복잡도, 예제 문제를 통해 체계적으로 학습해보겠습니다.

기수 정렬(Radix Sort)란?

기수 정렬은 정렬 알고리즘 중 하나로, 비슷한 수의 자릿수(digit)를 가지는 수들을 정렬할 때 효율적인 방법입니다. 이 방법의 핵심은 숫자를 개별 자리(1의 자리, 10의 자리 등)로 나누어 정렬한 후, 자릿수를 순차적으로 고려하여 전체 숫자를 정렬하는 방식입니다.

기수 정렬의 원리

기수 정렬은 다음과 같은 순서로 진행됩니다:

  1. 입력된 배열의 최대 자릿수를 찾습니다. 이는 정렬을 수행할 때 몇 번의 패스(pass)가 필요한지를 결정합니다.
  2. 각 자릿수에 대해 안정 정렬을 수행합니다. 가장 낮은 자리(1의 자리)부터 시작하여 가장 높은 자리(최대 자릿수)까지 반복합니다.
  3. 최종적으로 모든 자릿수에 대한 정렬이 완료된 후, 원본 배열은 정렬된 상태가 됩니다.

시간 복잡도

기수 정렬의 시간 복잡도는 주로 사용하는 안정 정렬 알고리즘에 따라 다르지만, 일반적으로 O(nk)입니다. 여기서 n은 정렬할 숫자의 개수, k는 가장 큰 숫자의 자릿수입니다. 기수 정렬은 특성상 정수에 대해서만 사용될 수 있지만, 문자나 문자열에 대해서도 변형된 버전으로 적용할 수 있습니다.

자바스크립트로 기수 정렬 구현하기

기본 알고리즘 구현

아래는 자바스크립트로 구현된 기수 정렬의 예시 코드입니다:

function getMax(array) {
    let max = array[0];
    for (let i = 1; i < array.length; i++) {
        if (array[i] > max) {
            max = array[i];
        }
    }
    return max;
}

function countingSort(array, place) {
    const n = array.length;
    const output = new Array(n);
    const count = new Array(10).fill(0);

    for (let i = 0; i < n; i++) {
        const digit = Math.floor(array[i] / place) % 10;
        count[digit]++;
    }

    for (let i = 1; i < 10; i++) {
        count[i] += count[i - 1];
    }

    for (let i = n - 1; i >= 0; i--) {
        const digit = Math.floor(array[i] / place) % 10;
        output[count[digit] - 1] = array[i];
        count[digit]--;
    }

    for (let i = 0; i < n; i++) {
        array[i] = output[i];
    }
}

function radixSort(array) {
    const max = getMax(array);
    for (let place = 1; Math.floor(max / place) > 0; place *= 10) {
        countingSort(array, place);
    }
    return array;
}

// 사용 예시
const numbers = [170, 45, 75, 90, 802, 24, 2, 66];
console.log(radixSort(numbers)); // 출력: [2, 24, 45, 66, 75, 90, 170, 802]

문제 예시: 정수 배열 정렬

자, 이제 기수 정렬을 실제 문제에 적용해 보겠습니다. 문제는 다음과 같습니다:

문제: 정수 배열이 주어질 때, 기수 정렬 알고리즘을 이용하여 이 배열을 오름차순으로 정렬하는 함수를 작성하시오.

문제 접근 방식

  1. 입력 배열을 함수의 인자로 받아옵니다.
  2. 기수 정렬 알고리즘을 활용하여 배열을 정렬합니다.
  3. 정렬된 배열을 반환합니다.

구현 및 테스트

위에서 설명한 기수 정렬 알고리즘을 바탕으로 위 문제를 해결하기 위한 함수를 아래와 같이 구현할 수 있습니다:

function sortIntegers(array) {
    return radixSort(array);
}

// 테스트
const testArray = [5, 3, 8, 1, 2, 7, 4, 6];
console.log(sortIntegers(testArray)); // 출력: [1, 2, 3, 4, 5, 6, 7, 8]

결론

이번 강좌에서는 기수 정렬 알고리즘에 대해 알아보고, 자바스크립트로 어떻게 구현하는지 살펴보았습니다. 기수 정렬은 대량의 정수를 정렬할 때 매우 효율적이며, 특히 자릿수가 적은 수에 대해서 뛰어난 성능을 보여줍니다. 다양한 코딩테스트 문제를 접근하기 위해 기수 정렬을 활용해보는 것은 매우 유익한 경험이 될 것입니다. 앞으로의 코딩테스트에서 기수 정렬의 개념과 구현 방법을 잘 활용하시기 바랍니다.

자바스크립트 코딩테스트 강좌, 그래프의 표현

그래프는 다양한 문제를 해결하는 데 강력한 데이터 구조입니다. 이 포스팅에서는 그래프의 표현 방법에 대해 알아보고, 문제를 해결하는 과정을 자세히 설명하겠습니다.

그래프의 정의

그래프는 정점(Vertex)과 간선(Edge)으로 구성된 데이터 구조로, 정점은 객체나 노드를 나타내고 간선은 정점 간의 관계를 나타냅니다. 그래프는 방향이 있는 경우(Directed Graph)와 없는 경우(Undirected Graph)로 나눌 수 있습니다.

또한, 그래프는 가중치가 있을 수도 있고(Weighted Graph), 없을 수도 있습니다(Unweighted Graph). 가중치 그래프에서는 간선에 비용이나 거리가 할당됩니다.

그래프 표현 방법

그래프를 표현하는 방법은 크게 두 가지가 있습니다:

  • 인접 행렬(Adjacency Matrix): 정점 간의 관계를 2차원 배열로 표현합니다. 배열의 크기는 정점의 수에 따라 결정되며, 행렬의 값은 두 정점 간의 간선의 존재를 나타내거나 가중치를 포함합니다.
  • 인접 리스트(Adjacency List): 각 정점에 인접한 정점들을 리스트로 표현합니다. 이 방법은 메모리 효율성이 좋고, 희소 그래프에서 유리합니다.

문제: 그래프의 경로 찾기

다음 문제를 해결해 보겠습니다.

문제 설명: 주어진 그래프에서 두 개의 정점 A와 B가 주어질 때, A에서 B까지 가는 모든 경로를 찾아 출력하는 함수를 작성하세요.

그래프는 인접 리스트로 주어집니다.

문제 예시

입력:
graph = {
    'A': ['B', 'C'],
    'B': ['D'],
    'C': ['D'],
    'D': ['E'],
    'E': []
}
start = 'A'
end = 'E'

출력:
['A', 'B', 'D', 'E']
['A', 'C', 'D', 'E']
            

문제 해결 과정

이 문제를 해결하기 위해 Depth-First Search(DFS) 알고리즘을 사용할 것입니다. DFS는 그래프의 깊이를 우선적으로 탐색하여 모든 가능한 경로를 찾아내는 알고리즘입니다.

1단계: DFS 함수 정의

먼저, 현재 정점에서 시작하여 모든 경로를 탐색하는 DFS 함수를 정의합니다. 이 함수는 현재 경로를 리스트로 가지고 있으며, 목표 정점에 도달하면 경로를 저장합니다.


function findPaths(graph, start, end, path = [], paths = []) {
    path.push(start); // 현재 정점을 경로에 추가

    // 목표 정점에 도달하면 경로를 저장
    if (start === end) {
        paths.push([...path]);
    } else {
        // 인접한 정점들에 대해 DFS를 호출
        for (const neighbor of graph[start] || []) {
            findPaths(graph, neighbor, end, path, paths);
        }
    }

    path.pop(); // 경로에서 현재 정점을 제거 (백트래킹)
    return paths; // 모든 경로를 반환
}
            

2단계: 그래프와 입력값 정의

이제 그래프와 시작 및 종료 정점을 정의합니다.


const graph = {
    'A': ['B', 'C'],
    'B': ['D'],
    'C': ['D'],
    'D': ['E'],
    'E': []
};

const start = 'A';
const end = 'E';
            

3단계: 함수 실행

모든 경로를 찾기 위해 함수를 실행하고 결과를 출력합니다.


const allPaths = findPaths(graph, start, end);
console.log(allPaths);
            

최종 코드


function findPaths(graph, start, end, path = [], paths = []) {
    path.push(start); // 현재 정점을 경로에 추가
    if (start === end) {
        paths.push([...path]); // 경로가 완성되면 추가
    } else {
        for (const neighbor of graph[start] || []) {
            findPaths(graph, neighbor, end, path, paths); // DFS 호출
        }
    }
    path.pop(); // 백트래킹
    return paths; // 모든 경로 반환
}

const graph = {
    'A': ['B', 'C'],
    'B': ['D'],
    'C': ['D'],
    'D': ['E'],
    'E': []
};

const start = 'A';
const end = 'E';
const allPaths = findPaths(graph, start, end);
console.log(allPaths);
            

결론

이번 포스팅에서는 자바스크립트를 활용한 그래프 표현 방식과 DFS를 이용한 경로 찾기 문제를 해결하는 과정을 설명했습니다. 그래프는 실생활에서도 다양한 문제를 해결하는 데 유용하게 사용되므로, 그 본질과 활용에 대한 이해는 매우 중요합니다. 앞으로 더 많은 알고리즘 문제를 다루어 보며, 다양한 문제 해결 능력을 기르시길 바랍니다.