백준 문제풀이

[Baekjoon 24444] 알고리즘 수업 - 너비 우선 탐색 1 - JAVA

planting grass 2023. 7. 8. 22:02
728x90

[Silver II] 알고리즘 수업 - 너비 우선 탐색 1 - 24444

문제 링크

성능 요약

메모리: 88724 KB, 시간: 1016 ms

분류

너비 우선 탐색, 그래프 이론, 그래프 탐색, 정렬

문제 설명

오늘도 서준이는 너비 우선 탐색(BFS) 수업 조교를 하고 있다. 아빠가 수업한 내용을 학생들이 잘 이해했는지 문제를 통해서 확인해보자.

N개의 정점과 M개의 간선으로 구성된 무방향 그래프(undirected graph)가 주어진다. 정점 번호는 1번부터 N번이고 모든 간선의 가중치는 1이다. 정점 R에서 시작하여 너비 우선 탐색으로 노드를 방문할 경우 노드의 방문 순서를 출력하자.

너비 우선 탐색 의사 코드는 다음과 같다. 인접 정점은 오름차순으로 방문한다.

bfs(V, E, R) {  # V : 정점 집합, E : 간선 집합, R : 시작 정점
    for each v ∈ V - {R}
        visited[v] <- NO;
    visited[R] <- YES;  # 시작 정점 R을 방문 했다고 표시한다.
    enqueue(Q, R);  # 큐 맨 뒤에 시작 정점 R을 추가한다.
    while (Q ≠ ∅) {
        u <- dequeue(Q);  # 큐 맨 앞쪽의 요소를 삭제한다.
        for each v ∈ E(u)  # E(u) : 정점 u의 인접 정점 집합.(정점 번호를 오름차순으로 방문한다)
            if (visited[v] = NO) then {
                visited[v] <- YES;  # 정점 v를 방문 했다고 표시한다.
                enqueue(Q, v);  # 큐 맨 뒤에 정점 v를 추가한다.
            }
    }
}

입력

첫째 줄에 정점의 수 N (5 ≤ N ≤ 100,000), 간선의 수 M (1 ≤ M ≤ 200,000), 시작 정점 R (1 ≤ R ≤ N)이 주어진다.

다음 M개 줄에 간선 정보 _u_ _v_가 주어지며 정점 u와 정점 v의 가중치 1인 양방향 간선을 나타낸다. (1 ≤ u < v ≤ N, u ≠ v) 모든 간선의 (u, v) 쌍의 값은 서로 다르다.

출력

첫째 줄부터 N개의 줄에 정수를 한 개씩 출력한다. i번째 줄에는 정점 i의 방문 순서를 출력한다. 시작 정점의 방문 순서는 1이다. 시작 정점에서 방문할 수 없는 경우 0을 출력한다.

문제 풀이

큐를 이용해서 풀었다.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        StringBuilder sb = new StringBuilder();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        int N = 0, M = 0, R = 0, start = 0, end = 0, order = 1, front = 0, num = 0;
        int[] res;
        boolean visited[];
        List<List<Integer>> list = new ArrayList<>();
        Queue<Integer> que = new LinkedList<Integer>();

        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        R = Integer.parseInt(st.nextToken());

        for (int i = 0; i <= N; i++)
            list.add(new ArrayList<>());
        visited = new boolean[N + 1];
        res = new int[N + 1];

        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            start = Integer.parseInt(st.nextToken());
            end = Integer.parseInt(st.nextToken());

            list.get(start).add(end);
            list.get(end).add(start);
        }

        for (int i = 0; i < list.size(); i++)
            Collections.sort(list.get(i));

        que.add(R);
        visited[R] = true;
        res[R] = order++;

        while (!que.isEmpty()) {
            front = que.poll();

            for (int i = 0; i < list.get(front).size(); i++) {
                num = list.get(front).get(i);
                if (visited[num] == false) {
                    visited[num] = true;
                    que.add(num);
                    res[num] = order++;
                }
            }
        }

        for (int i = 1; i < res.length; i++)
            sb.append(res[i]).append("\n");

        System.out.println(sb);
    }
}

코드 풀이

        int N = 0, M = 0, R = 0, start = 0, end = 0, order = 1, front = 0, num = 0;
-  N: 노드의 수를 나타내는 변수
-  M: 간선의 수를 나타내는 변수
-  R: 시작 노드를 나타내는 변수
-  start: 현재 간선의 시작 노드를 나타내는 변수
-  end: 현재 간선의 끝 노드를 나타내는 변수
-  order: 노드 방문 순서를 나타내는 변수로, 방문할 때마다 1씩 증가한다.
-  front: 큐에서 꺼낸 현재 노드를 나타내는 변수
-  num: 현재 노드의 이웃 노드를 나타내는 변수
        int[] res;
        boolean visited[];
        List<List<Integer>> list = new ArrayList<>();
        Queue<Integer> que = new LinkedList<Integer>();

        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        R = Integer.parseInt(st.nextToken());
  • res는 프로그램의 결과를 저장하는 데 사용한다.
  • visited라는 불리언 배열 변수를 선언, 방문한 노드를 추적하는 데 사용한다.
  • list 리스트를 선언, 그래프 노드들의 인접 리스트를 표현하는 데 사용한다.
  • que를 생성, 이는 BFS (너비 우선 탐색) 순회를 위한 큐로 사용한다.
  • 변수 N, M, R에 할당한다.
        for (int i = 0; i <= N; i++)
            list.add(new ArrayList<>());
        visited = new boolean[N + 1];
        res = new int[N + 1];
  • 각 노드의 인접 리스트를 초기화하기 위해 빈 ArrayList를 list에 추가하는 반복문이다.
  • visited 배열을 N+1개의 요소로 초기화한다. 이 배열은 노드의 방문 여부를 나타낸다.
  • 이 부분은 res 배열을 N+1개의 요소로 초기화합니다. 이 배열은 각 노드의 방문 순서를 저장할 것입니다.
        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            start = Integer.parseInt(st.nextToken());
            end = Integer.parseInt(st.nextToken());

            list.get(start).add(end);
            list.get(end).add(start);
        }
  • M번 반복하며, 각 간선을 읽고 처리한다.
  • start와 end 변수에 할당한다. 이는 현재 간선의 시작 노드와 끝 노드를 나타냅니다.
  • get을 사용해서 시작 노드의 인접 리스트에 끝 노드를 추가하고, 끝 노드의 인접 리스트에 시작 노드를 추가한다. 이는 두 노드 간의 무방향 간선을 나타낸다.
        for (int i = 0; i < list.size(); i++)
            Collections.sort(list.get(i));

        que.add(R);
        visited[R] = true;
        res[R] = order++;
                for (int i = 0; i < list.size(); i++)
            Collections.sort(list.get(i));

        que.add(R);
        visited[R] = true;
        res[R] = order++;
  • 현재 노드 front의 이웃들에 대해 반복한다.
  • 현재 노드 front의 인접 리스트에서 i번째 이웃 노드를 가져와 변수 num에 할당한다.
  • 이웃 노드 num이 방문되지 않았는지 확인한다.
  • 이웃 노드 num을 방문되었다고 표시한다.
  • 이웃 노드 num을 순회하기 위해 큐에 추가합니다.
  • 주문 받은대로 51번째 줄을 설명하는 도중에 절사된 것 같습니다. 아래에 해당 설명을 계속해드리겠습니다.
  • 부분은 이웃 노드 num을 큐에 추가합니다. 이웃 노드 num은 아직 방문되지 않은 노드 중 BFS 순회 순서를 결정하는 데 사용됩니다.
  • 이 부분은 이웃 노드 num의 방문 순서를 order로 설정하고, order를 1 증가시킵니다. res 배열은 각 노드의 방문 순서를 저장하는 용도로 사용됩니다.
        for (int i = 1; i < res.length; i++)
            sb.append(res[i]).append("\n");

        System.out.println(sb);
  • res 배열의 각 요소를 반복하면서 StringBuilder 객체 sb에 추가하고, 각 요소 뒤에 개행 문자를 추가한다.
  • StringBuilder 객체 sb의 내용을 표준 출력에 출력한다.

이렇게 주어진 코드의 한 줄씩 설명을 마쳤습니다. 이 코드는 주어진 그래프에서 너비 우선 탐색(BFS) 알고리즘을 사용하여 시작 노드부터 각 노드를 방문한 순서를 저장하는 배열에 저장합니다.

728x90
저작자표시