자바 코딩테스트 강좌, 다각형의 면적 구하기

안녕하세요! 이번 강좌에서는 다각형의 면적을 구하는 문제를 다루어 보겠습니다. 이 문제는 자바를 사용하여 구현할 것이며, 기초적인 수학 개념과 알고리즘을 적용하여 문제를 해결하는 과정을 자세히 설명하겠습니다.

문제 설명

주어진 점들의 좌표를 기반으로 다각형의 면적을 계산하는 프로그램을 작성하세요. 점들은 (x1, y1), (x2, y2), ..., (xn, yn) 형태로 주어지며, 이 점들을 연결하여 다각형을 구성한다고 가정합니다. 구하는 면적은 다음과 같은 조건을 충족해야 합니다:

  • 점들은 시계 방향 또는 반시계 방향으로 주어집니다.
  • 정확하고 효율적인 알고리즘을 작성해야 합니다.

입력

첫 번째 줄에는 점의 개수 n이 주어집니다. 다음 n개의 줄에는 각 점의 좌표 x, y가 정수로 주어집니다.

출력

다각형의 면적을 실수 형태로 출력하되, 소수점 이하 둘째 자리까지 반올림해야 합니다.

예제 입력

4
0 0
4 0
4 3
0 4

예제 출력

12.00

해결 방법

다각형의 면적을 구하는 방법으로는 다양한 알고리즘이 있지만, 이번 강좌에서는 슈뢰더의 공식(또는 다각형의 면적 공식)을 이용하겠습니다. 이 공식에 따르면, 다각형의 면적 A는 다음과 같이 계산됩니다:

A = 0.5 * |Σ (xiyi+1 - yixi+1)|

여기서 (xi, yi)는 다각형의 각 점의 좌표이며, (xn+1, yn+1) = (x1, y1)와 같은 방식으로 처음 점으로 돌아갑니다.

1단계: 알고리즘 구조 설계

우선 프로그램의 기본 구조를 설계해 보겠습니다. 프로그램은 다음과 같은 4단계로 구성됩니다:

  1. 입력 받기
  2. 면적 계산하기
  3. 결과 출력하기
  4. 정리하기

2단계: 입력 받기

자바에서는 Scanner 클래스를 통해 사용자 입력을 받을 수 있습니다. 각 점의 좌표를 ArrayList를 사용하여 저장하겠습니다. 코드 예시는 다음과 같습니다:

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class PolygonArea {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();  // 점의 개수
        List points = new ArrayList<>();
        
        for (int i = 0; i < n; i++) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            points.add(new Point(x, y));
        }
        scanner.close();
    }
    
    static class Point {
        int x, y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}

3단계: 면적 계산하기

이제 면적을 계산하는 메서드를 추가할 차례입니다. 면적 계산은 for문을 이용하여 각 점에 대해 위의 공식을 적용하면 됩니다:

public static double calculateArea(List points) {
    double area = 0.0;
    int n = points.size();

    for (int i = 0; i < n; i++) {
        Point p1 = points.get(i);
        Point p2 = points.get((i + 1) % n); // 다음 점, 마지막 점은 첫 번째 점을 연결
        area += p1.x * p2.y - p2.x * p1.y;
    }
    return Math.abs(area) / 2.0;
}

4단계: 결과 출력하기

이제 마지막으로 계산된 면적을 원하는 형식으로 출력하는 코드를 추가하겠습니다. 메인 메서드에 다음 코드를 추가해 줍니다:

double area = calculateArea(points);
System.out.printf("%.2f\n", area);

전체 코드

이제 모든 코드를 하나로 정리하면 다음과 같습니다:

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class PolygonArea {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();  // 점의 개수
        List points = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            points.add(new Point(x, y));
        }
        scanner.close();
        
        double area = calculateArea(points);
        System.out.printf("%.2f\n", area);
    }

    static class Point {
        int x, y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    public static double calculateArea(List points) {
        double area = 0.0;
        int n = points.size();

        for (int i = 0; i < n; i++) {
            Point p1 = points.get(i);
            Point p2 = points.get((i + 1) % n); // 다음 점, 마지막 점은 첫 번째 점을 연결
            area += p1.x * p2.y - p2.x * p1.y;
        }
        return Math.abs(area) / 2.0;
    }
}

정리

이번 강좌에서는 다각형의 면적을 구하는 문제를 풀어보았습니다. 우리 다룬 알고리즘은 슈뢰더의 공식을 바탕으로 하였으며, 이는 실제 프로그래밍 대회에서도 자주 사용됩니다. 각 단계마다 코드를 작성하며 알고리즘을 직접 구현해보는 경험이 매우 유익했을 것입니다.

이제 여러분도 이 알고리즘을 바탕으로 다양한 형태의 다각형에 대해 면적을 구하는 문제를 풀어볼 수 있습니다. 더 나아가 다른 아이디어와 알고리즘을 접목시켜 더욱 발전된 문제를 해결하는 데 도전해 보시기 바랍니다. 다음 강좌에서 더 많은 알고리즘 문제를 다르게 해보세요!

자바 코딩테스트 강좌, 너비 우선 탐색

코딩 테스트에서는 다양한 알고리즘과 자료구조에 대한 이해가 중요합니다. 그 중 하나가 바로 너비 우선 탐색(BFS, Breadth-First Search)입니다. 이 글에서는 너비 우선 탐색의 기본 개념, 문제 예시, 그리고 그 문제를 해결하기 위한 단계별 접근 방법을 설명하겠습니다.

1. 너비 우선 탐색(BFS) 개요

너비 우선 탐색은 그래프나 트리 구조를 탐색하는 데 사용되는 알고리즘으로, Root 노드에서 시작하여 인접한 노드를 우선적으로 방문하는 방식입니다. 이는 주로 큐(Queue) 자료구조를 이용하여 구현됩니다. BFS는 특정 노드까지의 최단 경로를 찾는 데 유용하며, 최단 거리 문제가 있는 경우 적합합니다.

1.1 BFS의 특징

  • 모든 노드를 동일한 Depth로 검색
  • 최단 경로를 보장
  • 메모리 사용량이 많을 수 있음

1.2 BFS의 시간 복잡도

BFS의 시간 복잡도는 O(V + E)입니다. 여기서 V는 노드의 수, E는 간선의 수를 나타냅니다. 이는 모든 노드와 간선을 각각 한 번씩 방문하기 때문입니다.

2. 문제 예시

문제 설명

주어진 그래프에서 시작 노드로부터 최단 거리를 계산하는 문제입니다. 그래프는 인접 리스트 형태로 주어지며, 시작 노드에서 도달할 수 있는 모든 노드까지의 최단 거리를 반환하는 함수를 작성하세요.

입력

  • n (1 ≤ n ≤ 1000): 그래프의 노드 수
  • edges: 간선 리스트의 배열, 각 간선은 [a, b] 형태
  • start: 시작 노드 (1부터 n까지의 정수)

출력

start 노드에서 각 노드까지의 최단 거리를 담은 배열을 반환합니다. 도달할 수 없는 경우 -1을 사용하여 표시합니다.

2.1 예시

    입력: 
    n = 5
    edges = [[1, 2], [1, 3], [2, 4], [3, 5]]
    start = 1

    출력: 
    [0, 1, 1, 2, -1]
    

3. 문제 해결 과정

이 문제를 해결하기 위해서는 다음 단계로 진행합니다.

3.1 입력 데이터를 그래프 형태로 변환

우선 간선 리스트를 이용해 그래프를 인접 리스트 형태로 변환합니다. 이렇게 하면 각 노드가 인접한 노드들을 쉽게 찾을 수 있습니다.

3.2 BFS 알고리즘 구현

큐를 사용하여 시작 노드에서부터 BFS를 수행합니다. 큐에 현재 노드를 추가하고, 이를 통해 인접한 노드를 탐색합니다. 방문한 노드는 배열에 최단 거리를 기록하여 나중에 활용합니다.

3.2.1 BFS 탐색의 진행

  1. 시작 노드를 큐에 추가하고, 거리 배열에 초기값(0)을 설정합니다.
  2. 큐에서 노드를 꺼내 그 노드에 인접한 모든 노드를 확인합니다.
  3. 인접한 노드가 방문하지 않았다면 거리 값을 갱신하고 큐에 추가합니다.
  4. 모든 노드를 방문할 때까지 이 과정을 반복합니다.

3.3 최종 결과 생성

모든 노드를 탐색한 뒤, 거리 배열을 반환하여 최단 거리를 출력합니다. 도달할 수 없는 노드는 -1로 표시합니다.

4. Java 코드 예제


import java.util.*;

public class BFSDistance {
    public static int[] bfsDistance(int n, int[][] edges, int start) {
        List> graph = new ArrayList<>();
        for (int i = 0; i <= n; i++) {
            graph.add(new ArrayList<>());
        }
        
        // 그래프 인접 리스트 생성
        for (int[] edge : edges) {
            graph.get(edge[0]).add(edge[1]);
            graph.get(edge[1]).add(edge[0]); // 비방향 그래프
        }

        int[] distances = new int[n + 1];
        Arrays.fill(distances, -1); // 초기 거리 -1로 설정
        distances[start] = 0; // 시작 점의 거리는 0
        
        Queue queue = new LinkedList<>();
        queue.add(start);
        
        while (!queue.isEmpty()) {
            int currentNode = queue.poll();
            for (int neighbor : graph.get(currentNode)) {
                if (distances[neighbor] == -1) { // 방문하지 않았다면
                    distances[neighbor] = distances[currentNode] + 1;
                    queue.add(neighbor);
                }
            }
        }
        
        return Arrays.copyOfRange(distances, 1, distances.length); // 1부터 n까지 반환
    }

    public static void main(String[] args) {
        int n = 5;
        int[][] edges = {{1, 2}, {1, 3}, {2, 4}, {3, 5}};
        int start = 1;

        int[] result = bfsDistance(n, edges, start);
        System.out.println(Arrays.toString(result)); // [0, 1, 1, 2, -1]
    }
}

5. 마무리

이번 강좌에서는 너비 우선 탐색(BFS)의 개념과 활용을 보여주었습니다. BFS는 최단 경로를 찾는 데 매우 효과적인 알고리즘이며, 그래프와 트리를 탐색할 수 있는 강력한 도구입니다. 여러분이 이 기법을 이해하고 코딩 테스트에서 적용할 수 있도록 연습하시기 바랍니다. 다음 강의에서는 깊이 우선 탐색(DFS)에 대해 다루겠습니다!

6. 추가 연습 문제

너비 우선 탐색을 연습하기 위한 추가 문제를 제공합니다. 아래의 문제를 풀어보세요.

문제: 최단 경로 찾기

가중치가 없는 그래프가 주어졌을 때, 시작 노드에서 모든 노드까지의 최단 경로를 구하세요. 또한 다익스트라 알고리즘을 사용하여 가중치가 있는 그래프의 최단 경로를 구하는 방법도 학습해보세요.

참고 자료

자바 코딩테스트 강좌, 내림차순으로 자릿수 정렬하기

문제 설명

일반적인 정렬 문제와는 달리, 이번 문제는 주어진 숫자를 구성하는 각 자릿수들을 내림차순으로 정렬하여 새롭게 만들어진 수를 출력하는 것입니다.
사용자로부터 입력받는 숫자는 음이 아닌 정수로 가정하며, 각 자릿수는 0부터 9까지의 숫자로 구성됩니다. 예를 들어, 321을 입력받으면
내림차순으로 정렬하여 321을 그대로 출력하고, 2143을 입력받으면 4321을 출력하는 식입니다.

입력 형식 및 조건

  • 입력은 각 자릿수를 포함한 정수 하나입니다.
  • 입력값은 0보다 크거나 같은 32비트 정수의 범위 내에 있어야 합니다.
  • 입력값이 0일 경우 0을 출력합니다.

예제 테스트 케이스

입력 출력
2143 4321
321 321
1110 1110
0 0

문제 접근 방법

문제를 해결하기 위한 접근 방식은 다음과 같습니다.
1. **입력 값 문자열 처리**: 먼저, 입력된 정수를 문자열로 변환하여 각 자릿수를 분리합니다.
2. **자릿수 배열화**: 문자열로 변환된 숫자를 한 자릿수씩 배열에 담습니다.
3. **정렬**: 배열에 담긴 각 자릿수를 내림차순으로 정렬합니다.
4. **출력 형식**: 정렬된 자릿수를 하나의 문자열로 다시 붙여 출력합니다.

상세 알고리즘 과정

각 단계별로 알고리즘을 좀 더 구체적으로 살펴보겠습니다.

1단계: 입력 처리

사용자로부터 입력받은 숫자를 문자열로 변환합니다.
사용자가 입력한 값이 자바의 Scanner 클래스를 통해 받아올 수 있습니다.
예를 들어:

Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();

2단계: 자릿수 배열화

입력된 문자열의 각 문자를 배열로 구성하기 위해, String 클래스의 toCharArray() 메서드를 사용할 수 있습니다.
이 메서드는 문자열을 구성하는 각 문자를 문자 배열로 변환합니다.

char[] digits = input.toCharArray();

3단계: 정렬

정렬을 위해 Arrays.sort 메서드를 사용할 수 있지만, 내림차순으로 정렬하기 위해
Comparator를 이용한 방법이 필요합니다. 코드는 다음과 같습니다:

Arrays.sort(digits, Collections.reverseOrder());

4단계: 출력 형식

정렬된 문자 배열을 다시 문자열로 변환하여 최종 결과를 출력합니다.
다음 코드와 같이 처리할 수 있습니다:

String result = new String(digits);
System.out.println(result);

최종 코드 구현

모든 단계를 통합한 최종 코드는 다음과 같습니다:

import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class DescendingOrder {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("숫자를 입력하세요: ");
        String input = scanner.nextLine();

        if (input.equals("0")) {
            System.out.println("0");
            return;
        }

        char[] digits = input.toCharArray();
        Arrays.sort(digits, Collections.reverseOrder());
        
        String result = new String(digits);
        System.out.println(result);
    }
}

코드 설명 및 추가 최적화

위 코드는 기본적인 요구 사항을 충족합니다. 그러나, 코드의 몇 가지 부분은 더 최적화할 수 있습니다.
예를 들어, **음수 처리**와 명확한 **입력 유효성 검사**를 추가할 수 있습니다. 사용자로부터 입력받는 문자열이 실제로 숫자인지를 체크하는
로직이 필요할 수 있습니다. 여기에 대한 예시 코드를 제공드립니다.

if (!input.matches("\\d+")) {
            System.out.println("유효하지 않은 입력입니다.");
            return;
        }

테스트 및 검증

최종 코드가 완료되었다면, 다양한 입력을 통해 코드가 잘 작동하는지 테스트해야 합니다.
입력값으로 0, 음수, 다양한 길이의 숫자들을 시도해봐야 합니다.
다음과 같은 테스트 케이스로 프로그램을 검증할 수 있습니다:

  • 입력: 98765 → 출력: 98765
  • 입력: 10203 → 출력: 32100
  • 입력: 9001 → 출력: 9100

결론

본 강좌에서는 자바를 사용하여 주어진 숫자의 자릿수를 내림차순으로 정렬하는 방법을 상세히 설명하였습니다.
알고리즘의 단계별 접근 방법과 최종 코드를 통해 문제를 해결하는 과정을 이해하셨기를 바랍니다.
이후 실전에서는 더욱 복잡한 문제를 접할 수 있으므로, 꾸준한 연습을 통해 문제 해결 능력을
키우는 것이 중요합니다. 감사합니다.

자바 코딩테스트 강좌, 나머지 합 구하기

안녕하세요! 오늘의 강좌에서는 자바를 사용하여 “나머지 합 구하기”라는 알고리즘 문제를 해결해보겠습니다. 이 문제는 정수 배열이 주어질 때, 주어진 수로 나누었을 때의 나머지를 모두 구한 후, 그 나머지의 합을 구하는 것입니다. 이 문제는 코딩 테스트를 준비하는 데 중요한 기본 개념을 다룹니다.

문제 설명

정수 배열 arr와 정수 m이 주어질 때, 배열의 각 요소를 m으로 나눈 나머지를 구하고, 그 나머지들의 총합을 반환하는 함수를 작성하시오.

입력

  • 첫 번째 줄에 배열의 크기 n (1 ≤ n ≤ 100,000)이 주어진다.
  • 두 번째 줄에 n개의 정수 arr[i] (1 ≤ arr[i] ≤ 1,000,000)가 공백으로 구분되어 주어진다.
  • 세 번째 줄에 정수 m (1 ≤ m ≤ 1,000,000)이 주어진다.

출력

배열의 나머지를 m으로 나눈 후 나머지의 합을 출력한다.

예제

입력:
5
1 2 3 4 5
3

출력:
15

문제 해결 전략

이 문제를 해결하기 위해서는 다음의 단계를 따릅니다:

  1. 정수 배열과 정수 m을 입력 받은 후, 나머지를 배열의 모든 요소에 대해 m으로 계산합니다.
  2. 그 나머지 값을 모두 더합니다.
  3. 최종 결과를 출력합니다.

구현

이제 위의 전략을 바탕으로 자바 코드로 구현해 보겠습니다. 먼저, 배열을 입력받고 각 요소를 m으로 나눈 나머지를 계산하는 메소드를 작성합니다. 다음은 이 문제를 해결하는 자바 코드입니다:


import java.util.Scanner;

public class RemainderSum {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 1. 입력 받기
        int n = scanner.nextInt(); // 배열의 크기
        int[] arr = new int[n];
        
        // 배열 요소 입력
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        
        int m = scanner.nextInt(); // 나눌 정수

        // 2. 나머지 합 구하기
        long remainderSum = 0; // 결과를 저장할 변수
        for (int i = 0; i < n; i++) {
            remainderSum += arr[i] % m; // 나머지를 더함
        }

        // 3. 결과 출력
        System.out.println(remainderSum);
        
        scanner.close();
    }
}

코드 설명

  1. 입력 처리: Scanner 클래스를 사용하여 입력을 처리합니다. 먼저 배열의 크기 n을 입력받고, 이후 arr에 각 요소를 저장합니다. 마지막으로 나누려는 정수 m을 입력받습니다.
  2. 나머지 합계 계산: remainderSum 변수를 초기화한 후, 반복문을 통해 각 배열의 요소가 m으로 나누어 떨어질 때의 나머지를 더합니다. long 타입을 사용하여 큰 수 의 합계를 안전하게 저장합니다.
  3. 결과 출력: 최종적으로 나머지의 합계를 출력합니다.

복잡도 분석

이 프로그래밍 문제의 시간 복잡도는 O(n)입니다. 배열의 길이에 따라 반복이 필요하기 때문에 최악의 경우, 모든 요소를 한 번에 검사해야 합니다. 공간 복잡도는 O(1)입니다. 추가적으로 필요한 공간이 거의 없기 때문입니다.

추가 예제 테스트

구현 후 몇 가지 추가 테스트 케이스를 고려해보는 것도 좋습니다:

예제 1

입력:
3
5 10 15
4

출력:
6

예제 2

입력:
4
1 100 10000 1000000
1

출력:
0

예제 3

입력:
5
0 10 20 30 40
7

출력:
10

결론

오늘 우리는 자바를 사용하여 “나머지 합 구하기” 문제를 해결했습니다. 이 예제를 통해 배열 처리 및 반복문, 나머지 계산을 효과적으로 활용하는 방법을 배웠습니다. 이러한 문제는 다양한 방식으로 변형될 수 있으므로, 응용력을 키우는 데 도움이 됩니다. 앞으로도 다양한 알고리즘 문제를 풀어보며 실력을 향상시키기를 바랍니다!

감사합니다!

자바 코딩테스트 강좌, 깊이 우선 탐색

코딩테스트의 많은 문제들은 그래프 또는 트리 구조를 기반으로 하고 있습니다. 이러한 문제를 해결하는 데 유용한 알고리즘 중 하나가 깊이 우선 탐색(Depth-First Search, DFS)입니다. 이번 강좌에서는 DFS의 개념과 자바로 구현하는 방법을 알아보겠습니다.

1. 깊이 우선 탐색(DFS)란?

깊이 우선 탐색은 그래프 탐색 알고리즘의 일종으로, 가능한 한 깊이 들어가면서 노드를 탐색하는 방법입니다. 즉, 한 갈래로 계속 나아가다가 더 이상 진행할 수 없게 되면 한 단계 앞의 노드로 되돌아가서 다른 갈래를 탐색하는 방식입니다.

2. DFS의 특징

  • 스택을 사용하여 방문한 노드를 저장합니다.
  • 재귀(recursion)를 통해 구현될 수 있습니다.
  • 너비 우선 탐색(BFS)과는 달리 노드의 깊이나 경로를 우선 고려합니다.

3. 문제 정의

다음과 같은 그래프가 있다고 가정해 봅시다:

        A
       / \
      B   C
     / \   \
    D   E   F
    

이 그래프에서 DFS를 사용하여 A에서 시작해 D까지의 경로를 찾아보려 합니다. 경로를 찾고 A에서 D까지 방문한 노드를 출력하는 것이 목표입니다.

4. 문제 해결 과정

DFS를 사용하여 문제를 해결하기 위해, 먼저 그래프를 표현한 후 DFS 알고리즘을 구현해야 합니다.

4.1 그래프 표현

그래프는 보통 인접 리스트나 인접 행렬로 표현할 수 있습니다. 여기서는 인접 리스트를 사용하여 그래프를 표현하겠습니다.

자바로 그래프 구현하기

    import java.util.*;

    class Graph {
        private Map> adjacencyList;

        public Graph() {
            adjacencyList = new HashMap<>();
        }

        public void addEdge(String source, String destination) {
            adjacencyList.putIfAbsent(source, new ArrayList<>());
            adjacencyList.get(source).add(destination);
        }
        
        public Map> getAdjacencyList() {
            return adjacencyList;
        }
    }
    

4.2 DFS 알고리즘 구현

DFS 알고리즘은 다음과 같은 방식으로 구현될 수 있습니다. 방문한 노드를 저장하기 위해 Set을 사용하고 재귀 호출을 통해 깊이 탐색을 수행합니다.

자바 DFS 메서드

    class DFS {
        private Set visited;
        private List path;

        public DFS() {
            visited = new HashSet<>();
            path = new ArrayList<>();
        }

        public void depthFirstSearch(Graph graph, String node) {
            if (!visited.contains(node)) {
                visited.add(node);
                path.add(node);
                
                for (String neighbor : graph.getAdjacencyList().get(node)) {
                    depthFirstSearch(graph, neighbor);
                }
            }
        }

        public List getPath() {
            return path;
        }
    }
    

5. 전체 코드

이제 전체 코드를 하나로 합쳐서 사용해 보겠습니다. 다음은 그래프를 만들고 DFS를 실행하는 전체 코드입니다.

    public class Main {
        public static void main(String[] args) {
            Graph graph = new Graph();
            graph.addEdge("A", "B");
            graph.addEdge("A", "C");
            graph.addEdge("B", "D");
            graph.addEdge("B", "E");
            graph.addEdge("C", "F");

            DFS dfs = new DFS();
            dfs.depthFirstSearch(graph, "A");

            System.out.println("DFS 경로: " + dfs.getPath());
        }
    }
    

6. 코드 실행 결과

위 코드를 실행하면 다음과 같은 결과를 얻을 수 있습니다:

    DFS 경로: [A, B, D, E, C, F]
    

결과에서 보듯이 DFS는 A에서 시작하여 B를 방문하고 그 후 D로 깊이 들어갔습니다. DFS의 탐색 순서가 유지되는 것을 확인할 수 있습니다.

7. 심화 학습

이 강좌에서는 DFS의 개념과 기본적인 구현 방법을 소개했습니다. 더 나아가 DFS를 활용한 다양한 문제들을 풀어보며 실력을 쌓아가는 것이 좋습니다. 대표적인 문제로는:

  • 미로 탐색
  • 연결 요소 찾기
  • 사이클 검출

8. 결론

이번 강좌를 통해 깊이 우선 탐색의 기본 개념과 자바에서의 구현 방법을 배웠습니다. 그래프 문제는 코딩테스트에서 자주 출제되므로 반드시 숙지하고 연습해보시기 바랍니다. 다음 강좌에서는 다른 탐색 알고리즘인 너비 우선 탐색(BFS)에 대해 다뤄보겠습니다.