쉽게 쉽게

[알고리즘] DFS(깊이 우선 탐색)란? (백준 11724, 2667)

곱마2 — Sat, 18 Jul 2026 18:58:35 +0900

핵심 요약

DFS(깊이 우선 탐색)는 한 방향으로 갈 수 있는 만큼 끝까지 파고든 뒤, 막히면 되돌아와 다른 길을 탐색하는 알고리즘입니다.
“되돌아오기”를 구현하기 위해 스택(Stack) 또는 재귀 호출을 사용하며, 실전에서는 재귀 방식이 훨씬 간결합니다.
최단 거리는 보장하지 않지만, 연결 요소 찾기 · 모든 경로 탐색 · 백트래킹의 기반이 되는 필수 알고리즘입니다.
백준 11724(연결 요소의 개수), 2667(단지번호붙이기) 두 문제로 그래프 DFS와 2차원 격자 DFS를 직접 풀어봅니다.

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

DFS(Depth-First Search, 깊이 우선 탐색)는 그래프나 트리에서 한 방향으로 갈 수 있는 만큼 깊이 파고들며 탐색하는 알고리즘입니다. 미로에서 길을 찾는 사람을 떠올리면 됩니다. 갈림길이 나오면 일단 한쪽 길을 선택해 막다른 곳이 나올 때까지 걸어가고, 막히면 마지막 갈림길로 되돌아와서 아직 가보지 않은 다른 길을 시도합니다. 이 과정을 반복하면 결국 미로의 모든 길을 한 번씩 밟게 됩니다.

BFS가 “가까운 곳부터 한 겹씩” 넓게 퍼져나갔다면, DFS는 “일단 한 길로 끝까지” 깊게 들어간다는 점이 정반대입니다.

스택(Stack)이란?

스택(Stack)은 나중에 넣은 데이터가 먼저 나오는(LIFO, Last-In First-Out) 자료구조입니다. 접시를 쌓아둔 더미처럼, 꺼낼 때는 항상 맨 위(가장 최근에 올린 접시)부터 꺼냅니다.

DFS에 스택이 필요한 이유는 “가장 최근에 지나온 갈림길”로 되돌아가야 하기 때문입니다. 지나온 갈림길을 스택에 차곡차곡 쌓아두면, 막다른 길을 만났을 때 스택의 맨 위를 꺼내는 것만으로 가장 최근 갈림길로 돌아갈 수 있습니다.

BFS가 “먼저 발견한 것 먼저”를 위해 큐를 썼다면, DFS는 “가장 최근 것부터 되짚기”를 위해 스택을 씁니다.

왜 재귀 호출로 구현할까?

재귀 호출(Recursion)은 메서드가 자기 자신을 다시 호출하는 방식입니다.

그런데 사실 자바는 메서드를 호출할 때마다 호출 정보를 콜 스택(Call Stack)이라는 내부 스택에 자동으로 쌓고, 메서드가 끝나면 꺼내서 이전 위치로 돌아갑니다.

즉 재귀 호출을 쓰면 “되돌아오기”에 필요한 스택 관리를 자바가 대신 해주는 셈입니다. 그래서 실전에서는 스택을 직접 다루는 코드보다 재귀 방식이 훨씬 짧고 직관적이라 대부분 재귀로 DFS를 구현합니다.

ℹ️

큐를 쓰면 BFS, 스택(재귀)을 쓰면 DFS

두 알고리즘의 코드 구조는 거의 같습니다. “다음에 방문할 노드”를 큐로 관리하면 BFS, 스택(또는 재귀)으로 관리하면 DFS가 됩니다. 자료구조 하나의 차이가 탐색 순서 전체를 바꾼다는 점이 두 알고리즘의 핵심입니다.

2 DFS의 동작 원리

재귀 기준으로 DFS의 전체 흐름은 아래 4단계입니다. “방문 → 더 깊이 → 막히면 복귀”의 반복이라고 기억하면 됩니다.

DFS 동작 4단계 (재귀 기준)

시작 노드에서 dfs 메서드를 호출하고, 진입하자마자 방문 처리(visited = true)합니다.
현재 노드와 연결된 인접 노드를 확인해, 아직 방문하지 않은 노드가 있으면 그 노드로 dfs를 재귀 호출합니다. (더 깊이 파고들기)
인접 노드를 전부 방문했다면(막다른 길) 메서드가 종료되고, 자동으로 이전 노드로 되돌아갑니다. (백트래킹)
되돌아온 노드에서 남은 다른 인접 노드에 대해 2~3번을 반복합니다. 최초 호출까지 종료되면 시작점에서 도달 가능한 모든 노드를 방문한 것입니다.

⚠️

방문 처리를 빠뜨리면 무한 재귀에 빠집니다

그래프에 사이클(순환 경로)이 있을 때 방문 처리를 하지 않으면, 두 노드가 서로를 계속 재귀 호출하다가 StackOverflowError(콜 스택이 가득 차서 발생하는 에러)로 프로그램이 죽습니다. dfs 메서드에 진입하자마자 방문 처리하는 것을 습관으로 만드세요.

3 DFS vs BFS 비교

두 알고리즘 모두 모든 노드를 한 번씩 방문하므로 시간 복잡도는 O(V + E)로 같습니다. (V = 노드 수, E = 간선 수) 어떤 문제에서 어느 쪽을 골라야 하는지가 실전의 핵심입니다.

구분	DFS (깊이 우선 탐색)	BFS (너비 우선 탐색)
탐색 방식	한 방향으로 끝까지 파고든 후 되돌아옴	가까운 노드부터 한 겹씩 확장
사용 자료구조	스택 (Stack) 또는 재귀	큐 (Queue)
최단 거리 보장	보장 안 됨	보장 (가중치 없을 때)
구현 난이도	재귀로 매우 간결	큐 관리 코드 필요
주의할 점	깊은 재귀 시 스택 오버플로우	큐 중복 삽입 시 메모리 초과
유리한 문제	연결 요소, 모든 경로 탐색, 백트래킹, 사이클 판별	최단 거리, 최소 횟수, 가까운 대상 찾기

“몇 개인가 / 모든 경우”는 DFS, “최단 · 최소”는 BFS

연결된 덩어리가 몇 개인지 세거나, 가능한 모든 경우를 탐색하는 문제는 구현이 간결한 DFS가 편합니다. 반면 “최단 거리”, “최소 횟수”가 등장하면 BFS를 선택하세요. 단순히 모든 노드를 방문하기만 하면 되는 문제(연결 요소 등)는 둘 중 아무거나 써도 정답이 같습니다.

4 Java로 DFS 구현하기

그래프는 BFS 때와 마찬가지로 인접 리스트(각 노드마다 “연결된 노드 목록”을 저장하는 방식)로 표현합니다. 먼저 가장 많이 쓰는 재귀 버전입니다. 큐 관리 코드가 없어서 BFS보다 훨씬 짧다는 점을 확인해 보세요.

Java — DFS 기본 템플릿 (재귀)

import java.util.*;

public class DfsTemplate {

    // graph[i] = i번 노드와 연결된 노드 목록 (인접 리스트)
    static List<Integer>[] graph;
    static boolean[] visited;

    static void dfs(int cur) {
        // 1. 진입하자마자 방문 처리 (무한 재귀 방지!)
        visited[cur] = true;
        System.out.println("방문: " + cur);

        // 2. 미방문 인접 노드로 더 깊이 파고든다
        for (int next : graph[cur]) {
            if (!visited[next]) {
                dfs(next);
            }
        }
        // 3. for문이 끝나면(막다른 길) 자동으로 이전 노드로 복귀
    }
}

같은 동작을 스택으로 직접 구현하면 아래와 같습니다. 재귀가 내부적으로 어떤 일을 하는지 이해하는 데 도움이 되고, 재귀 깊이 제한에 걸릴 만큼 그래프가 깊을 때의 대안이 되기도 합니다.

Java — DFS 스택 버전 (참고용)

static void dfsWithStack(int start) {
    Deque<Integer> stack = new ArrayDeque<>();
    stack.push(start);

    while (!stack.isEmpty()) {
        int cur = stack.pop(); // 맨 위(가장 최근)부터 꺼낸다
        if (visited[cur]) continue;
        visited[cur] = true;
        System.out.println("방문: " + cur);

        for (int next : graph[cur]) {
            if (!visited[next]) stack.push(next);
        }
    }
}

ℹ️

자바에서 스택은 ArrayDeque를 권장합니다

자바에는 Stack 클래스가 있지만 오래된 설계(모든 메서드에 동기화 처리)로 성능이 떨어져, 공식 문서에서도 Deque 인터페이스와 ArrayDeque 구현체 사용을 권장합니다. push()로 맨 위에 넣고 pop()으로 맨 위에서 꺼냅니다.

5 문제풀이 1 : 백준 11724 연결 요소의 개수

첫 번째 문제는 DFS 입문의 정석인 연결 요소의 개수입니다. 연결 요소(Connected Component)란 그래프 안에서 서로 오갈 수 있는 노드들의 덩어리를 말합니다. 이 문제의 핵심은 “모든 노드에 대해 DFS 시도 → 새로 탐색이 시작된 횟수 = 덩어리 수”라는 패턴입니다.

BOJ #11724

연결 요소의 개수

N ≤ 1,000 · M ≤ N×(N-1)/2 · 시간제한 3초

난이도: Silver V

방향 없는 그래프가 주어졌을 때, 연결 요소(서로 연결된 노드 덩어리)의 개수를 출력하는 문제입니다.

풀이 과정

간선이 양방향이므로 인접 리스트에 양쪽 모두 간선을 추가해 그래프를 만든다.
1번부터 N번까지 모든 노드를 순회하면서, 아직 방문하지 않은 노드를 만나면 그 노드에서 DFS를 시작한다.
DFS 한 번이 끝나면 연결된 덩어리 하나를 전부 방문한 것이므로, DFS를 새로 시작한 횟수가 곧 연결 요소의 개수다.

Java — 백준 11724 연결 요소의 개수

import java.io.*;
import java.util.*;

public class Main {
    static List<Integer>[] graph;
    static boolean[] visited;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken()); // 노드 수
        int m = Integer.parseInt(st.nextToken()); // 간선 수

        graph = new ArrayList[n + 1];
        visited = new boolean[n + 1];
        for (int i = 1; i <= n; i++) graph[i] = new ArrayList<>();

        // 양방향 간선 등록
        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            graph[a].add(b);
            graph[b].add(a);
        }

        // 모든 노드를 순회하며, 미방문 노드에서 DFS 시작
        int count = 0;
        for (int i = 1; i <= n; i++) {
            if (!visited[i]) {
                dfs(i);
                count++; // 새 덩어리 발견!
            }
        }

        System.out.println(count);
    }

    static void dfs(int cur) {
        visited[cur] = true;
        for (int next : graph[cur]) {
            if (!visited[next]) dfs(next);
        }
    }
}

“모든 노드 순회 + 미방문 시 DFS” 패턴을 기억하세요

BFS의 바이러스(2606)는 시작점 하나에서 탐색했지만, 이 문제처럼 그래프가 여러 덩어리로 나뉘어 있을 수 있는 경우에는 모든 노드를 for문으로 순회하며 미방문 노드마다 새로 탐색을 시작해야 합니다. 다음 문제인 단지번호붙이기도 똑같은 패턴입니다.

6 문제풀이 2 : 백준 2667 단지번호붙이기

두 번째 문제는 2차원 격자 DFS의 대표 문제인 단지번호붙이기입니다.

방금 배운 “모든 노드 순회 + 미방문 시 DFS” 패턴을 격자에 적용하고, 추가로 DFS의 반환값으로 덩어리의 크기를 누적하는 기법을 배웁니다. 격자에서 상하좌우 이동은 BFS 때와 동일하게 방향 배열(dx, dy)을 사용합니다.

BOJ #2667

단지번호붙이기

지도 크기 N ≤ 25 · 시간제한 1초

난이도: Silver I

N×N 지도에서 1은 집, 0은 빈 땅입니다. 상하좌우로 붙어 있는 집들을 하나의 단지로 묶을 때, 총 단지 수와 각 단지의 집 수를 오름차순으로 출력하는 문제입니다.

풀이 과정

지도의 모든 칸을 이중 for문으로 순회하다가, 집(1)이면서 미방문인 칸을 만나면 그 칸에서 DFS를 시작한다. (= 새 단지 발견)
DFS는 현재 칸을 방문 처리한 뒤, 상하좌우의 범위 안 · 집 · 미방문 칸으로 재귀를 이어간다.
DFS가 “자기 자신 1채 + 재귀로 이어진 집들의 수”를 반환하도록 만들면, 최초 호출의 반환값이 곧 그 단지의 집 수가 된다.
단지별 집 수를 리스트에 모아 오름차순 정렬 후, 단지 수와 함께 출력한다.

Java — 백준 2667 단지번호붙이기

import java.io.*;
import java.util.*;

public class Main {
    // 상, 하, 좌, 우 네 방향
    static int[] dx = {-1, 1, 0, 0};
    static int[] dy = {0, 0, -1, 1};
    static int n;
    static int[][] map;
    static boolean[][] visited;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(br.readLine().trim());
        map = new int[n][n];
        visited = new boolean[n][n];

        for (int i = 0; i < n; i++) {
            String line = br.readLine();
            for (int j = 0; j < n; j++) {
                map[i][j] = line.charAt(j) - '0';
            }
        }

        // 모든 칸 순회 : 집(1)이면서 미방문이면 새 단지
        List<Integer> sizes = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (map[i][j] == 1 && !visited[i][j]) {
                    sizes.add(dfs(i, j)); // 단지 하나 통째로 탐색
                }
            }
        }

        // 오름차순 정렬 후 출력
        Collections.sort(sizes);
        StringBuilder sb = new StringBuilder();
        sb.append(sizes.size()).append('\n');
        for (int s : sizes) sb.append(s).append('\n');
        System.out.print(sb);
    }

    // 반환값 = 이 칸에서 이어진 단지의 집 수
    static int dfs(int x, int y) {
        visited[x][y] = true;
        int size = 1; // 자기 자신 1채

        for (int d = 0; d < 4; d++) {
            int nx = x + dx[d];
            int ny = y + dy[d];

            // 지도 범위 밖이면 건너뛰기
            if (nx < 0 || ny < 0 || nx >= n || ny >= n) continue;
            // 빈 땅(0)이거나 이미 방문한 칸이면 건너뛰기
            if (map[nx][ny] == 0 || visited[nx][ny]) continue;

            size += dfs(nx, ny); // 이어진 집 수를 누적
        }
        return size;
    }
}

⚠️

재귀 DFS는 격자가 크면 StackOverflowError가 날 수 있습니다

이 문제는 지도가 최대 25×25 = 625칸이라 재귀 깊이가 얕아 안전합니다. 하지만 격자가 수백×수백처럼 커지면 재귀 깊이가 수만~수십만까지 깊어져 콜 스택이 넘칠 수 있습니다. 그럴 때는 스택 버전 DFS로 바꾸거나 BFS로 대체하는 것이 안전합니다. 이 판단 기준을 알아두면 실전에서 큰 도움이 됩니다.

7 마무리

DFS의 핵심을 다시 정리하면 세 가지입니다.

한 길로 끝까지 파고들고, 막히면 되돌아온다, 재귀 호출이 콜 스택을 통해 “되돌아오기”를 자동으로 처리해 준다, dfs 진입 즉시 방문 처리한다.

잘못된 내용이 있다면 지적부탁드립니다. 방문해주셔서 감사합니다.

[알고리즘] BFS(너비 우선 탐색)란 무엇인가? (백준 2606, 2178)

곱마2 — Sat, 18 Jul 2026 18:35:45 +0900

핵심 요약

BFS(너비 우선 탐색)는 시작점에서 가까운 곳부터 차례대로 퍼져나가며 탐색하는 알고리즘입니다.
탐색 순서를 관리하기 위해 큐(Queue) 자료구조를 사용하며, 먼저 발견한 노드를 먼저 방문합니다.
모든 간선의 비용이 같을 때(가중치가 없을 때) 최단 거리를 보장하는 것이 BFS의 가장 큰 강점입니다.
백준 2606(바이러스), 2178(미로 탐색) 두 문제로 연결 요소 탐색과 최단 거리 계산을 직접 풀어봅니다.

1 BFS(너비 우선 탐색)란?

BFS(Breadth-First Search, 너비 우선 탐색)는 그래프나 트리에서 시작점과 가까운 노드부터 차례대로 방문하는 탐색 알고리즘입니다.

호수에 돌을 던졌을 때 물결이 동심원을 그리며 퍼져나가는 모습을 떠올리면 됩니다.

시작점에서 거리 1인 노드를 모두 방문한 뒤, 거리 2인 노드, 거리 3인 노드… 순서로 한 겹씩(너비 단위로) 탐색 범위를 넓혀갑니다.

그래프란?

BFS를 이해하려면 먼저 그래프가 무엇인지 알아야 합니다.

그래프(Graph)는 노드(정점)와 노드 사이를 연결하는 간선(선)으로 이루어진 자료구조입니다.

지하철 노선도를 생각하면 쉽습니다. 각 역이 노드, 역과 역을 잇는 선로가 간선입니다. 컴퓨터 네트워크, SNS 친구 관계, 미로의 길 등 “무언가와 무언가가 연결된 구조”는 대부분 그래프로 표현할 수 있습니다.

왜 큐(Queue)를 사용할까?

큐(Queue)는 먼저 넣은 데이터가 먼저 나오는(FIFO, First-In First-Out) 자료구조입니다. 은행 창구의 대기줄처럼, 먼저 줄을 선 사람이 먼저 처리됩니다.

BFS가 큐를 사용하는 이유는 “먼저 발견한 노드를 먼저 방문해야” 가까운 순서대로 탐색이 진행되기 때문입니다.

시작점에서 거리 1인 노드들을 큐에 넣으면, 그 노드들을 꺼내 처리하는 동안 거리 2인 노드들이 큐의 뒤에 쌓입니다.

큐는 항상 앞에서부터 꺼내므로 거리 1이 모두 끝난 뒤에야 거리 2가 처리됩니다.

이 성질 덕분에 BFS는 자연스럽게 가까운 순서대로 탐색하게 되고, 가중치가 없는 그래프에서 최단 거리를 보장하게 됩니다.

ℹ️

스택을 쓰면 DFS가 됩니다

같은 코드에서 큐 대신 스택(나중에 넣은 것이 먼저 나오는 구조)을 쓰면, 한 방향으로 끝까지 파고드는 DFS(깊이 우선 탐색)가 됩니다. 즉 어떤 자료구조로 “다음에 방문할 노드”를 관리하느냐가 BFS와 DFS를 가르는 핵심입니다.

2 BFS의 동작 원리

BFS는 큐와 방문 체크 배열(visited) 두 가지만 있으면 동작합니다. 전체 흐름은 아래 4단계의 반복입니다.

BFS 동작 4단계

시작 노드를 큐에 넣고, 방문 처리(visited = true)합니다.
큐에서 노드를 하나 꺼냅니다(poll).
꺼낸 노드와 연결된 인접 노드 중 아직 방문하지 않은 노드를 모두 큐에 넣고, 넣는 순간 방문 처리합니다.
큐가 빌 때까지 2~3번을 반복합니다. 큐가 비면 시작점에서 도달 가능한 모든 노드를 방문한 것입니다.

⚠️

방문 처리는 “큐에 넣을 때” 해야 합니다

큐에서 꺼낼 때 방문 처리를 하면, 같은 노드가 여러 경로를 통해 큐에 중복으로 들어가는 문제가 생깁니다. 노드 수가 많은 문제에서는 이 중복 때문에 메모리 초과나 시간 초과가 발생할 수 있으니, 반드시 큐에 넣는 순간 방문 처리하는 습관을 들이세요.

3 BFS vs DFS 비교

BFS와 DFS는 모두 그래프의 모든 노드를 한 번씩 방문하는 완전 탐색 알고리즘이라 시간 복잡도는 같습니다.

하지만 탐색 순서가 다르기 때문에 문제 유형에 따라 유리한 쪽이 달라집니다.

구분	BFS (너비 우선 탐색)	DFS (깊이 우선 탐색)
탐색 방식	가까운 노드부터 한 겹씩 확장	한 방향으로 끝까지 파고든 후 되돌아옴
사용 자료구조	큐 (Queue)	스택 (Stack) 또는 재귀
최단 거리 보장	보장 (가중치 없을 때)	보장 안 됨
시간 복잡도	O(V + E)	O(V + E)
유리한 문제	최단 거리, 최소 횟수, 가까운 대상 찾기	모든 경로 탐색, 백트래킹, 사이클 판별

문제에서 “최단”, “최소”가 보이면 BFS

“최단 거리”, “최소 이동 횟수”, “최소 몇 번 만에” 같은 표현이 등장하고 간선의 비용이 모두 같다면 BFS를 먼저 떠올리세요. 반대로 간선마다 비용(가중치)이 다르다면 다익스트라 알고리즘이 필요합니다.

4 Java로 BFS 구현하기

그래프를 인접 리스트(각 노드마다 “연결된 노드 목록”을 저장하는 방식)로 표현하고, 자바의 Queue 인터페이스와 LinkedList 구현체로 BFS 기본 뼈대를 작성해 보겠습니다. 이 뼈대는 거의 모든 BFS 문제에서 그대로 재사용됩니다.

Java — BFS 기본 템플릿

import java.util.*;

public class BfsTemplate {

    // graph[i] = i번 노드와 연결된 노드 목록 (인접 리스트)
    static List<Integer>[] graph;
    static boolean[] visited;

    static void bfs(int start) {
        Queue<Integer> queue = new LinkedList<>();

        // 1. 시작 노드를 큐에 넣고, 넣는 순간 방문 처리
        queue.offer(start);
        visited[start] = true;

        // 4. 큐가 빌 때까지 반복
        while (!queue.isEmpty()) {
            // 2. 큐에서 노드를 하나 꺼낸다
            int cur = queue.poll();
            System.out.println("방문: " + cur);

            // 3. 인접 노드 중 미방문 노드를 큐에 넣는다
            for (int next : graph[cur]) {
                if (!visited[next]) {
                    visited[next] = true; // 넣는 순간 방문 처리!
                    queue.offer(next);
                }
            }
        }
    }
}

ℹ️

offer / poll 메서드

offer()는 큐의 뒤에 데이터를 넣는 메서드, poll()은 큐의 앞에서 데이터를 꺼내는 메서드입니다. 비슷한 역할의 add() / remove()도 있지만, 이 둘은 실패 시 예외를 던지는 반면 offer() / poll()은 null 등을 반환하므로 알고리즘 문제에서는 보통 offer() / poll()을 사용합니다.

5 문제풀이 1 : 백준 2606 바이러스

첫 번째 문제는 BFS 입문 문제의 대표 격인 바이러스입니다. “시작점에서 도달할 수 있는 노드가 몇 개인가”를 세는 연결 요소 탐색 유형으로, 앞에서 만든 기본 템플릿을 거의 그대로 사용할 수 있습니다.

BOJ #2606

바이러스

컴퓨터 수 ≤ 100 · 시간제한 1초

난이도: Silver III

컴퓨터들이 네트워크로 연결되어 있습니다. 1번 컴퓨터가 바이러스에 걸렸을 때, 1번 컴퓨터를 통해 바이러스에 감염되는 컴퓨터의 수를 출력하는 문제입니다. (1번 자신은 제외)

풀이 과정

컴퓨터를 노드, 네트워크 연결을 간선으로 보고 인접 리스트로 그래프를 만든다. 연결은 양방향이므로 간선을 양쪽 모두에 추가한다.
1번 노드에서 BFS를 시작해 도달 가능한 모든 노드를 방문한다.
방문한 노드 수를 세고, 시작점인 1번을 제외하기 위해 결과에서 1을 뺀다.

Java — 백준 2606 바이러스

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 컴퓨터(노드) 수
        int m = sc.nextInt(); // 연결(간선) 수

        // 인접 리스트 초기화 (1번 노드부터 쓰기 위해 n+1 크기)
        List<Integer>[] graph = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) graph[i] = new ArrayList<>();

        // 양방향 간선 등록
        for (int i = 0; i < m; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            graph[a].add(b);
            graph[b].add(a);
        }

        // 1번 노드에서 BFS
        boolean[] visited = new boolean[n + 1];
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(1);
        visited[1] = true;

        int count = 0; // 감염된 컴퓨터 수 (1번 제외)

        while (!queue.isEmpty()) {
            int cur = queue.poll();
            for (int next : graph[cur]) {
                if (!visited[next]) {
                    visited[next] = true;
                    queue.offer(next);
                    count++; // 새로 감염될 때마다 카운트
                }
            }
        }

        System.out.println(count);
    }
}

1번을 방문 처리한 뒤 count는 0에서 시작

시작점 1번을 큐에 넣을 때 count를 올리지 않고, 새로운 노드가 감염될 때만 count를 올리면 “1번을 제외한 감염 컴퓨터 수”가 자연스럽게 계산됩니다. 마지막에 1을 빼는 방식보다 실수할 여지가 적습니다.

6 문제풀이 2 : 백준 2178 미로 탐색

두 번째 문제는 BFS의 진짜 강점인 최단 거리를 활용하는 미로 탐색입니다. 이번에는 노드가 번호가 아니라 2차원 격자의 칸(행, 열)이라는 점이 다릅니다. 격자 문제에서는 상하좌우 이동을 표현하는 방향 배열(dx, dy) 기법을 사용합니다.

BOJ #2178

미로 탐색

N, M ≤ 100 · 시간제한 1초

난이도: Silver I

N×M 크기의 미로에서 (1, 1)에서 출발해 (N, M)까지 이동할 때 지나야 하는 최소 칸 수를 구하는 문제입니다. 1은 이동 가능한 칸, 0은 벽이며, 시작 칸과 도착 칸도 개수에 포함됩니다.

풀이 과정

“최소 칸 수”를 묻고 모든 이동 비용이 1로 같으므로 BFS로 최단 거리를 구하면 된다.
상하좌우 이동을 dx, dy 방향 배열로 표현하고, 미로 범위를 벗어나거나 벽(0)이거나 이미 방문한 칸은 건너뛴다.
거리 저장은 별도 배열 대신 미로 배열 값 자체를 누적 거리로 갱신한다. 다음 칸의 값 = 현재 칸의 값 + 1.
탐색이 끝나면 도착 칸 (N, M)에 저장된 값이 최단 거리(지나온 칸 수)가 된다.

Java — 백준 2178 미로 탐색

import java.io.*;
import java.util.*;

public class Main {
    // 상, 하, 좌, 우 네 방향 (dx = 행 이동, dy = 열 이동)
    static int[] dx = {-1, 1, 0, 0};
    static int[] dy = {0, 0, -1, 1};

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());

        int[][] maze = new int[n][m];
        for (int i = 0; i < n; i++) {
            String line = br.readLine();
            for (int j = 0; j < m; j++) {
                maze[i][j] = line.charAt(j) - '0';
            }
        }

        // BFS : 큐에는 {행, 열} 좌표를 int 배열로 담는다
        boolean[][] visited = new boolean[n][m];
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{0, 0});
        visited[0][0] = true;

        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int x = cur[0];
            int y = cur[1];

            // 네 방향을 모두 확인
            for (int d = 0; d < 4; d++) {
                int nx = x + dx[d];
                int ny = y + dy[d];

                // 미로 범위 밖이면 건너뛰기
                if (nx < 0 || ny < 0 || nx >= n || ny >= m) continue;
                // 벽이거나 이미 방문한 칸이면 건너뛰기
                if (maze[nx][ny] == 0 || visited[nx][ny]) continue;

                visited[nx][ny] = true;
                // 다음 칸의 거리 = 현재 칸의 거리 + 1
                maze[nx][ny] = maze[x][y] + 1;
                queue.offer(new int[]{nx, ny});
            }
        }

        // 도착 칸에 누적된 값 = 지나온 최소 칸 수
        System.out.println(maze[n - 1][m - 1]);
    }
}

⚠️

BFS의 최단 거리는 “처음 도착한 순간” 확정됩니다

BFS는 가까운 칸부터 순서대로 방문하기 때문에, 어떤 칸에 처음 도착했을 때의 거리가 곧 최단 거리입니다. 그래서 이미 방문한 칸은 다시 볼 필요가 없고, DFS처럼 모든 경로를 비교할 필요도 없습니다. 이것이 최단 거리 문제에서 BFS를 쓰는 이유입니다.

7 마무리

BFS의 핵심을 다시 정리하면 세 가지입니다. 큐를 사용해 가까운 노드부터 방문한다, 큐에 넣는 순간 방문 처리한다, 가중치가 없다면 최단 거리가 보장된다. 이 세 가지만 기억하면 기본 템플릿에서 “큐에 무엇을 담을지(노드 번호 or 좌표)”와 “무엇을 셀지(개수 or 거리)”만 바꿔가며 대부분의 BFS 문제를 풀 수 있습니다.

다음 단계 추천 문제

백준 1926(그림), 7576(토마토), 1697(숨바꼭질)을 추천합니다. 특히 토마토는 시작점이 여러 개인 멀티 소스 BFS, 숨바꼭질은 격자가 아닌 수직선 위의 BFS로, 오늘 배운 템플릿을 응용하는 좋은 연습이 됩니다.

잘못된 내용이 있다면 지적부탁드립니다. 방문해주셔서 감사합니다.

[프로그래머스] 거리두기 확인하기(Java) — BFS

곱마2 — Sat, 18 Jul 2026 18:10:50 +0900

핵심 요약

각 P에서 BFS를 시작 — 맨해튼 거리 2 이내에 다른 P가 있는지 확인한다
X는 벽으로 처리 — 파티션으로 막힌 경로는 큐에 넣지 않으므로 자연스럽게 걸러진다
거리 2에서 확장 중단 — dis == 2인 노드는 검사만 하고 이웃을 큐에 넣지 않는다

Programmers #81302

거리두기 확인하기

5×5 대기실 5개 · P(응시자) / O(빈 자리) / X(파티션)

난이도: Lv.2

5×5 크기의 대기실 5개가 주어진다. 응시자들이 앉은 자리(P) 사이의 맨해튼 거리가 2 이하이면 거리두기 위반인데, 예외적으로 두 자리 사이가 파티션(X)으로 막혀 있으면 위반이 아니다. 각 대기실이 거리두기를 지키고 있으면 1, 아니면 0을 배열에 담아 반환한다.

풀이 과정

대기실 5개를 각각 독립적으로 검사한다. 하나라도 위반 쌍이 발견되면 그 대기실은 0이다.
대기실 안의 모든 P를 찾아, 각 P를 시작점으로 BFS를 돌린다.
BFS 도중 거리 1~2 위치에서 다른 P를 만나면 즉시 위반으로 판정한다. X는 큐에 넣지 않으므로 파티션으로 막힌 경로는 탐색되지 않는다.

1 접근 방법 — 왜 BFS인가

이 문제의 핵심은 “맨해튼 거리 2 이하”와 “파티션으로 막혀 있으면 예외”라는 두 조건을 동시에 처리하는 것이다.

단순히 좌표 차이로 맨해튼 거리만 계산하면 파티션 조건을 반영할 수 없다.

예를 들어 P X P처럼 두 응시자가 한 칸 건너 앉아 있어도, 사이에 파티션이 있으면 거리두기 위반이 아니다.

그래서 좌표 계산 대신 실제로 이동 가능한 경로 기준의 거리를 재기로 했다. X를 벽으로 취급하고 O와 P만 지나갈 수 있는 격자에서 BFS를 돌리면, 각 칸까지의 거리는 “파티션을 우회해서 도달하는 최단 거리”가 된다. 이 거리가 2 이하인 위치에 다른 P가 있을 때만 위반으로 판정하면 두 조건이 한 번에 해결된다.

BFS의 최단 거리 보장이 핵심

BFS는 각 칸에 항상 최단 거리로 먼저 도달한다. P X P 케이스에서 오른쪽 P까지의 BFS 거리는 파티션을 우회한 3 이상이 되므로, 거리 2 이내 검사에 걸리지 않고 자연스럽게 통과 처리된다. 별도의 예외 분기 없이 파티션 조건이 해결되는 이유다.

2 BFS 설계

큐에 담는 상태

큐에는 {row, col, dis} 세 값을 담았다.

거리(dis)는 노드마다 달라지는 값이므로 큐 안에 함께 넣어 관리한다. 시작점의 거리는 0이고, 이웃으로 확장할 때마다 dis + 1로 넣는다.

위반 판정과 탐색 범위 제한

큐에서 노드를 꺼냈을 때 두 가지를 검사한다.

위반 검사 — dis > 0이면서 현재 칸이 P라면 거리 2 이내에 다른 응시자가 있다는 뜻이므로 false를 반환한다. dis > 0 조건은 시작점 자신(P)을 제외하기 위한 것이다.
확장 중단 — dis == 2라면 검사만 하고 이웃을 큐에 넣지 않는다. 거리 3 이상은 어차피 위반 대상이 아니므로 탐색할 필요가 없다.

확장 조건은 네 가지를 모두 만족해야 한다. 격자 범위 안이고, 방문하지 않았고, X(파티션)가 아닌 칸만 큐에 넣는다.

⚠️

경계 검사는 배열 접근보다 먼저

next_row >= 0 && next_row < 5 같은 범위 검사를 visited[next_row][next_col] 배열 접근보다 앞에 두어야 한다. 순서가 뒤집히면 격자 밖 좌표로 배열에 접근해 ArrayIndexOutOfBoundsException이 발생한다. && 연산자의 단축 평가(short-circuit) 덕분에 앞 조건이 false면 뒤 조건은 평가되지 않는다.

3 전체 코드

Java — Solution.java

import java.util.*;

class Solution {
    static int[] dr = {-1, 1, 0, 0};
    static int[] dc = {0, 0, 1, -1};

    public int[] solution(String[][] places) {
        int[] answer = new int[5];

        for (int i = 0; i < places.length; i++) {
            answer[i] = check(places[i]) ? 1 : 0;
        }

        return answer;
    }

    public boolean check(String[] place) {
        char[][] arr = new char[5][5];

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                arr[i][j] = place[i].charAt(j);
            }
        }

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                if (arr[i][j] == 'P') {
                    if (!bfs(arr, i, j)) {
                        return false;
                    }
                }
            }
        }
        return true;
    }

    public boolean bfs(char[][] arr, int startRow, int startCol) {
        ArrayDeque<int[]> deque = new ArrayDeque<>();
        boolean[][] visited = new boolean[5][5];
        deque.add(new int[]{startRow, startCol, 0});
        visited[startRow][startCol] = true;

        while (!deque.isEmpty()) {
            int[] cur = deque.poll();
            int row = cur[0];
            int col = cur[1];
            int dis = cur[2];

            if (dis > 0 && arr[row][col] == 'P') {
                return false;
            }

            if (dis == 2) continue;  // 거리 2에서는 더 확장하지 않음

            for (int i = 0; i < 4; i++) {
                int nextRow = row + dr[i];
                int nextCol = col + dc[i];

                if (nextRow >= 0 && nextCol >= 0 && nextRow < 5 && nextCol < 5
                        && !visited[nextRow][nextCol] && arr[nextRow][nextCol] != 'X') {
                    visited[nextRow][nextCol] = true;
                    deque.add(new int[]{nextRow, nextCol, dis + 1});
                }
            }
        }

        return true;
    }
}

4 정리하면서 손본 부분

처음 제출한 코드도 정답이었지만, 정리하면서 몇 군데를 다듬었다.

불필요한 탐색 제거

처음 코드는 dis == 2인 노드에서도 이웃을 큐에 넣고, 꺼낸 뒤에야 if (dis > 2) continue로 버리는 구조였다.

정답에는 영향이 없지만 거리 3짜리 노드를 만들었다가 버리는 낭비가 있었다. dis == 2 시점에 확장을 멈추도록 바꾸면 거리 3 이상인 노드가 아예 생성되지 않는다.

이렇게 바꾸고 나니 위반 검사 조건도 단순해졌다. 원래는 dis > 0 && dis <= 2 && arr[row][col] == 'P'였는데, 큐에 거리 0~2인 노드만 들어오게 되면서 dis <= 2가 항상 참이 되어 조건에서 뺄 수 있었다.

구분	처음 코드	수정 후
확장 중단	`dis > 2`인 노드를 꺼낸 뒤 `continue`	`dis == 2`에서 확장하지 않음 개선
위반 검사	`dis > 0 && dis <= 2 && P`	`dis > 0 && P` 단순화
거리 3 노드	생성 후 폐기	생성되지 않음

스타일 정리

answer[i] 대입을 if/else 대신 삼항 연산자 check(places[i]) ? 1 : 0으로 줄였다.
배열 선언을 int dx[]에서 Java 관례에 맞는 int[] dr 형태로 바꿨다. 이름도 행/열 의미가 드러나도록 dr/dc로 정했다.
변수명을 start_row → startRow처럼 카멜케이스로 통일했다.

ℹ️

조건문으로 직접 확인하는 대안도 있다

거리 제한이 2로 고정이라, BFS 없이 각 P 기준으로 “거리 1 상하좌우 / 거리 2 직선 / 대각선” 케이스를 조건문으로 직접 검사하는 풀이도 널리 쓰인다. 다만 케이스 분기가 많아 실수 여지가 있고, BFS 방식은 거리 제한이 바뀌어도 그대로 통용되는 일반적인 형태라 이 방식을 택했다.

잘못된 내용이 있다면 지적부탁드립니다. 방문해주셔서 감사합니다.

[Java] StringTokenizer 사용법 - split()과의 차이점

곱마2 — Fri, 17 Jul 2026 18:14:41 +0900

핵심 요약

StringTokenizer는 문자열을 구분자 기준으로 잘라주는 클래스 — 정규식을 쓰지 않아 split()보다 단순하고 빠르다
세 번째 인자를 true로 주면 구분자도 토큰으로 반환 — 수식 파싱처럼 구분자 자체가 필요한 경우에 유용하다
빈 토큰은 무시된다 — 구분자가 연속으로 나올 때 split()과 결과가 달라지므로 주의

1 StringTokenizer란?

java.util.StringTokenizer는 문자열을 구분자(delimiter) 기준으로 잘라 토큰 단위로 꺼내 쓸 수 있게 해주는 클래스다. 문자열을 한 번에 배열로 바꾸는 split()과 달리, hasMoreTokens()로 남은 토큰이 있는지 확인하면서 nextToken()으로 하나씩 꺼내는 방식으로 동작한다.

왜 사용하는가? (split과의 차이)

split()은 인자를 정규식으로 해석한다.

그래서 +, *, | 같은 정규식 특수문자를 구분자로 쓰려면 이스케이프가 필요하고, 내부적으로 정규식 엔진을 거치기 때문에 단순 분리 작업치고는 비용이 크다.

반면 StringTokenizer는 구분자를 문자 집합으로 그대로 해석한다.

"+-*"를 넘기면 정규식이 아니라 "+ 또는 - 또는 * 중 하나"라는 뜻이라 이스케이프를 고민할 필요가 없다.

코딩테스트에서 공백으로 구분된 입력을 대량으로 읽을 때 BufferedReader와 함께 표준 조합으로 쓰이는 이유이기도 하다.

ℹ️

구분자는 "문자열"이 아니라 "문자들의 집합"

new StringTokenizer(str, "+-")는 "+-"라는 두 글자짜리 문자열을 찾는 게 아니라, +와 - 각각을 구분자로 취급한다. 여러 종류의 구분자를 한 번에 처리할 수 있다는 뜻이지만, 두 글자 이상의 문자열 자체를 구분자로 쓰고 싶다면 StringTokenizer로는 안 되고 split()을 써야 한다.

2 StringTokenizer 사용법

생성자 3가지

생성자는 인자 개수에 따라 세 가지 형태가 있다. 세 번째 인자가 이 클래스의 핵심 기능이다.

Java — 생성자 3가지

// 1. 구분자 생략 — 기본값은 공백류(" \t\n\r\f")
StringTokenizer st1 = new StringTokenizer("1 2 3");
// 토큰: "1", "2", "3"

// 2. 구분자 지정 — 각 문자를 구분자로 취급
StringTokenizer st2 = new StringTokenizer("100-200+300", "+-");
// 토큰: "100", "200", "300" — 구분자는 버려진다

// 3. 세 번째 인자 true — 구분자도 토큰으로 반환
StringTokenizer st3 = new StringTokenizer("100-200+300", "+-", true);
// 토큰: "100", "-", "200", "+", "300" — 구분자가 살아있다

주요 메서드

Java — hasMoreTokens / nextToken / countTokens

StringTokenizer st = new StringTokenizer("10 20 30");

// 1. countTokens() — 남은 토큰 개수 반환
int count = st.countTokens();  // 3

// 2. hasMoreTokens() + nextToken() — 표준 순회 패턴
while (st.hasMoreTokens()) {
    String token = st.nextToken();  // "10" → "20" → "30"
}

// 3. 개수를 알고 있다면 for문으로도 가능
StringTokenizer st2 = new StringTokenizer("1 2 3 4 5");
int[] arr = new int[st2.countTokens()];
for (int i = 0; i < arr.length; i++) {
    arr[i] = Integer.parseInt(st2.nextToken());
}

⚠️

토큰이 없는데 nextToken()을 호출하면 예외 발생

남은 토큰이 없는 상태에서 nextToken()을 호출하면 NoSuchElementException이 발생한다. 항상 hasMoreTokens()로 확인하거나, countTokens()만큼만 반복해야 한다.

전체 메서드 한눈에 보기

메서드	설명	비고
`hasMoreTokens()`	남은 토큰이 있으면 true	while 조건으로 사용
`nextToken()`	다음 토큰 반환	없으면 `NoSuchElementException`
`nextToken(delim)`	구분자를 새로 바꿔서 다음 토큰 반환	이후 호출에도 새 구분자 유지
`countTokens()`	남은 토큰 개수 반환	`nextToken()` 호출 시마다 감소

3 split()과의 비교

가장 헷갈리기 쉬운 차이는 빈 토큰 처리다. 구분자가 연속으로 나오거나 문자열이 구분자로 시작하면 두 방식의 결과가 달라진다.

Java — 빈 토큰 처리 차이

String str = "a,,b";

// split() — 빈 문자열도 결과에 포함
String[] arr = str.split(",");
// ["a", "", "b"] — 길이 3

// StringTokenizer — 빈 토큰은 건너뜀
StringTokenizer st = new StringTokenizer(str, ",");
// "a", "b" — 토큰 2개

구분	StringTokenizer	split()
구분자 해석	문자 집합 (각 문자가 구분자)	정규식 (특수문자 이스케이프 필요)
빈 토큰	무시	포함
구분자 유지	가능 (세 번째 인자 true)	기본 불가 (lookahead 정규식 필요)
속도	빠름 (정규식 미사용)	상대적으로 느림
결과 형태	하나씩 순회 (Iterator 스타일)	배열로 한 번에 반환

선택 기준

공백/특정 문자로 잘라서 순서대로 읽기만 하면 되는 입력 파싱은 StringTokenizer, 빈 문자열을 보존해야 하거나 인덱스로 접근할 배열이 필요하거나 정규식 패턴으로 잘라야 한다면 split()이 맞다.

4 실전 활용

BufferedReader와 조합 (입력 파싱)

코딩테스트에서 가장 자주 쓰는 형태다. Scanner보다 훨씬 빠르기 때문에 입력량이 많은 문제에서는 이 조합이 표준이다.

Java — BufferedReader + StringTokenizer

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

// "5 3" 형태의 한 줄 입력 파싱
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
int m = Integer.parseInt(st.nextToken());

구분자를 살려서 수식 파싱하기

세 번째 인자 true가 진가를 발휘하는 경우다. 수식을 파싱할 때는 숫자뿐 아니라 연산자 자체도 토큰으로 필요한데, 세 번째 인자를 true로 주면 별도 처리 없이 숫자와 연산자가 번갈아 담긴 리스트를 바로 만들 수 있다.

Java — 수식을 토큰 리스트로 분리

String expression = "100-200*300-500+20";

List<String> tokens = new ArrayList<>();
StringTokenizer st = new StringTokenizer(expression, "+-*", true);
while (st.hasMoreTokens()) {
    tokens.add(st.nextToken());
}

// 결과: [100, -, 200, *, 300, -, 500, +, 20]
// 정규식 없이 숫자와 연산자가 번갈아 담긴 리스트 완성

같은 작업을 split()으로 하려면 split("(?=[+\\-*])|(?<=[+\\-*])") 같은 정규식이 필요하다.

정확히 쓰기도 어렵고 나중에 읽기는 더 어렵다.

구분자를 살려야 하는 파싱이라면 StringTokenizer의 세 번째 인자가 훨씬 단순한 답이 된다.

이 패턴을 실제로 활용한 문제 풀이는

2026.07.17 - [알고리즘/완전 탐색 및 백트래킹] - [프로그래머스] 수식 최대화(Java) - 완전탐색

글에서 확인할 수 있다.

잘못된 내용이 있다면 지적부탁드립니다. 방문해주셔서 감사합니다.

[프로그래머스] 수식 최대화(Java) - 완전탐색

곱마2 — Fri, 17 Jul 2026 18:03:32 +0900

핵심 요약

완전탐색 — 연산자 3개의 우선순위 순열은 6가지뿐이라 전부 시도해도 충분하다
토큰 리스트 축약 — 우선순위가 높은 연산자부터 찾아 [숫자, 연산자, 숫자] 세 토큰을 결과 하나로 접는다
인덱스 보정 — 리스트를 순회하면서 동시에 수정할 때는 줄어든 크기만큼 인덱스를 되돌려야 한다

1 문제 이해

Programmers #67257

수식 최대화

expression 길이 ≤ 100 · 피연산자는 3자리 이하

난이도: Lv.2

+, -, * 세 연산자로 이루어진 수식이 주어진다. 연산자 우선순위를 마음대로 재정의할 수 있을 때(단, 우선순위가 같은 연산자는 없음), 수식 결과의 절댓값이 최대가 되는 값을 구하는 문제다.

풀이 과정

수식을 숫자와 연산자 토큰으로 분리한다
우선순위 순열 6가지를 하나씩 시도한다
각 순열에서 우선순위가 높은 연산자부터 리스트를 훑으며 계산하고, 세 토큰을 결과 하나로 접는다
최종 결과의 절댓값 중 최댓값을 갱신한다

2 접근 방식

연산자가 +, -, * 세 개뿐이라 우선순위 순열은 3! = 6가지밖에 없다.

expression 길이도 최대 100이라서 6가지를 전부 시도하는 완전탐색으로 충분하다고 판단했다.

토큰 분리는 StringTokenizer의 세 번째 인자를 true로 주면 구분자인 연산자까지 토큰으로 같이 뽑아준다.

이러면 정규식 없이 [100, -, 200, *, 300, ...] 형태의 리스트를 바로 만들 수 있다.

계산은 우선순위가 높은 연산자부터 리스트를 앞에서부터 훑으면서, 해당 연산자를 만나면 양옆 숫자와 함께 세 토큰을 지우고 계산 결과 하나를 그 자리에 넣는 방식이다.

ℹ️

중간 결과는 long으로

곱셈이 먼저 처리되는 순열에서는 중간 결과가 int 범위를 넘을 수 있다. 리스트에 문자열로 다시 넣은 중간 결과를 꺼낼 때 Integer.parseInt가 아니라 Long.parseLong으로 읽어야 한다.

3 헤맨 부분: 순회 중 리스트 수정

처음 제출한 코드는 일부 케이스에서 틀렸다.

원인은 리스트에서 토큰 3개를 지우고 1개를 넣으면 리스트가 2칸 줄어드는데, 반복문 인덱스 i는 그대로 i++로 진행된다는 점이었다.

1 - 2 - 3처럼 같은 연산자가 연속으로 나오는 경우를 직접 따라가 보면 문제가 보인다.

trace — 보정 없이 실행했을 때

// copy = [1, -, 2, -, 3],  op = "-"
i=1: "-" 매치 → 1-2 계산 → copy = [-1, -, 3]
i=2: copy.get(2) = "3" → 연산자가 아님
i=3: 루프 종료
// 두 번째 "-"는 인덱스 1로 당겨졌는데 i는 이미 2를 지나 건너뛰었다

축약 후 리스트가 2칸 줄었으니 인덱스도 그만큼 되돌려야 한다.

축약 처리 끝에 i--를 넣으면 루프의 i++와 합쳐져 결과적으로 i - 1, 즉 방금 넣은 결과 바로 다음 위치부터 다시 검사하게 된다.

⚠️

순회 중 수정 시 인덱스 보정

리스트를 순회하면서 동시에 요소를 지우거나 넣을 때는, 크기가 변한 만큼 인덱스를 보정해야 한다. 보정을 빼먹으면 같은 요소가 연속으로 나오는 케이스에서만 조용히 틀리기 때문에 원인을 찾기 어렵다.

4 전체 코드

Java — Solution.java

import java.util.*;

class Solution {
    private static final String[][] PRIORITIES = {
        {"+", "-", "*"}, {"+", "*", "-"},
        {"-", "+", "*"}, {"-", "*", "+"},
        {"*", "+", "-"}, {"*", "-", "+"}
    };

    public long solution(String expression) {
        // 숫자와 연산자를 토큰으로 분리
        List<String> tokens = new ArrayList<>();
        StringTokenizer st = new StringTokenizer(expression, "+-*", true);
        while (st.hasMoreTokens()) {
            tokens.add(st.nextToken());
        }

        long answer = 0;
        for (String[] priority : PRIORITIES) {
            List<String> copy = new ArrayList<>(tokens);

            for (String op : priority) {
                for (int i = 0; i < copy.size(); i++) {
                    if (op.equals(copy.get(i))) {
                        long left = Long.parseLong(copy.get(i - 1));
                        long right = Long.parseLong(copy.get(i + 1));
                        long result = calculate(left, right, op);

                        // [left, op, right] 세 토큰을 result 하나로 접기
                        copy.remove(i - 1);
                        copy.remove(i - 1);
                        copy.remove(i - 1);
                        copy.add(i - 1, String.valueOf(result));
                        i--; // 리스트가 2칸 줄었으니 인덱스 보정
                    }
                }
            }
            answer = Math.max(answer, Math.abs(Long.parseLong(copy.get(0))));
        }
        return answer;
    }

    private long calculate(long a, long b, String op) {
        switch (op) {
            case "+": return a + b;
            case "-": return a - b;
            case "*": return a * b;
            default: throw new IllegalArgumentException("알 수 없는 연산자: " + op);
        }
    }
}

우선순위 순열마다 원본 토큰의 복사본을 만들어 계산하고, 최종적으로 남은 값의 절댓값 중 최댓값을 반환한다.

calculate의 default에서 예외를 던지도록 한 건, 여기 도달하면 로직에 버그가 있다는 뜻이라 조용히 0을 반환하는 것보다 바로 드러나는 편이 낫기 때문이다.

잘못된 내용이 있다면 지적부탁드립니다. 방문해주셔서 감사합니다.

[프로그래머스] 무인도 여행 — BFS

곱마2 — Thu, 16 Jul 2026 19:45:20 +0900

핵심 요약

연결 요소별 합계 — 격자에서 상하좌우로 이어진 육지(섬)를 BFS로 묶고, 섬마다 식량의 합을 구하는 문제입니다.
거리 BFS vs 집계 BFS — 미로 탈출처럼 거리를 구할 땐 큐에 {r, c, day}를 싣지만, 이 문제는 탐색 밖의 변수 하나에 누적하면 충분합니다.

1 문제 소개

Programmers #154540

무인도 여행

지도 최대 100×100 · 각 칸은 X 또는 1~9

난이도: Lv.2

문자열 배열로 주어지는 지도에서 X는 바다, 숫자는 그 칸에서 얻을 수 있는 식량입니다. 상하좌우로 연결된 숫자 칸들이 하나의 무인도를 이룰 때, 각 섬에서 얻을 수 있는 식량의 총합을 오름차순으로 반환해야 합니다. 섬이 하나도 없으면 {-1}을 반환합니다.

풀이 과정

문자열 배열을 char[][] 맵으로 먼저 전부 변환합니다.
이중 루프를 돌며 아직 방문하지 않은 육지 칸을 만나면 BFS를 시작합니다.
BFS가 퍼지는 동안 방문하는 칸의 식량을 지역 변수 total에 누적하고, 탐색이 끝나면 그 값이 곧 섬 하나의 식량 합입니다.
섬별 합계를 오름차순 정렬해 int[]로 변환합니다. 리스트가 비어 있으면 {-1}을 반환합니다.

한 문장으로 요약하면 "연결 요소(Connected Component)를 찾고, 각 요소의 값을 합산하라"는 문제입니다. 얼마 전에 풀었던 미로 탈출과 똑같이 격자 BFS인데, 막상 풀어보니 큐에 실어야 하는 정보가 완전히 달랐습니다. 이번 포스트의 핵심은 바로 그 차이입니다.

2 접근: 미방문 육지마다 BFS 한 번씩

전체 구조는 격자 연결 요소 문제의 전형적인 패턴입니다. 바깥에서 이중 루프로 모든 칸을 훑다가, 바다가 아니고 아직 방문하지 않은 칸을 만나면 거기서 BFS를 한 번 돌립니다. BFS 한 번이 섬 하나를 통째로 방문 처리하므로, 같은 섬의 다른 칸에서는 두 번 다시 BFS가 시작되지 않습니다.

Java — 탐색 시작 구조

for (int i = 0; i < row; i++) {
    for (int j = 0; j < col; j++) {
        if (map[i][j] != 'X' && !visited[i][j]) {
            answerList.add(bfs(i, j));  // BFS 1회 = 섬 1개의 식량 합
        }
    }
}

여기서 visited를 클래스 필드로 두는 게 포인트입니다. BFS 호출이 끝나도 방문 기록이 유지돼야 "이미 처리한 섬"을 건너뛸 수 있기 때문입니다. 각 칸은 정확히 한 번씩만 방문되므로 전체 시간 복잡도는 O(N×M)입니다.

3 핵심: 그 값은 누구의 것인가?

처음에는 미로 탈출을 풀던 습관대로 큐에 {행, 열, 값} 형태로 값을 실어 나르려고 했습니다.

그런데 이 문제에서는 그럴 필요가 전혀 없었습니다.

두 방식의 차이를 정리해보니, 기준은 "그 값이 칸마다 다른 답을 가지는가?"라는 질문 하나였습니다.

밖의 변수 = 탐색 전체의 집계

무인도의 식량 합계는 특정 칸의 속성이 아닙니다.

"이 칸의 합계"라는 개념 자체가 없고, 탐색이 끝났을 때 하나만 나오면 되는 값입니다.

이런 값은 노드마다 들고 다닐 이유가 없으니 BFS 바깥의 지역 변수에 누적하면 끝입니다.

Java — 두 방식 비교

// [거리 BFS] 값이 칸마다 다름 → 큐에 실어 부모→자식으로 전파
deque.add(new int[]{nr, nc, current[2] + 1});

// [집계 BFS] 값이 탐색 전체에 하나 → 밖의 변수에 누적
total += map[nr][nc] - '0';
deque.add(new int[]{nr, nc});

구분	거리 BFS (큐에 싣기)	집계 BFS (밖에서 누적)
값의 주인	노드 각각	탐색(컴포넌트) 전체
값이 정해지는 방식	부모 값에서 파생 (`부모 + 1`)	방문한 칸들의 합·개수
답을 읽는 시점	목표 칸을 발견할 때	while 루프 종료 후
대표 문제	미로 탈출 최단거리	무인도 여행 섬 크기·합

상태 설계 판별법

"이 값이 칸마다 다른 답을 가지는가?"를 먼저 물어보세요. 다르면 큐에 싣고, 탐색 끝에 하나만 나오면 되는 값이면 밖에 둡니다. 같은 격자 BFS라도 문제가 묻는 것에 따라 큐에 실어야 할 상태가 달라집니다.

5 전체 코드

Java — Solution.java

import java.util.*;

class Solution {
    static final int[] dx = {-1, 1, 0, 0};
    static final int[] dy = {0, 0, 1, -1};

    int row, col;
    char[][] map;
    boolean[][] visited;

    public int[] solution(String[] maps) {
        row = maps.length;
        col = maps[0].length();
        map = new char[row][col];
        visited = new boolean[row][col];

        // 1단계: 맵 완성
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                map[i][j] = maps[i].charAt(j);
            }
        }

        // 2단계: 미방문 육지마다 BFS
        List<Integer> answerList = new ArrayList<>();
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (map[i][j] != 'X' && !visited[i][j]) {
                    answerList.add(bfs(i, j));
                }
            }
        }

        if (answerList.isEmpty()) {
            return new int[]{-1};
        }
        return answerList.stream()
                .sorted()
                .mapToInt(Integer::intValue)
                .toArray();
    }

    public int bfs(int startRow, int startCol) {
        ArrayDeque<int[]> deque = new ArrayDeque<>();
        deque.add(new int[]{startRow, startCol});
        visited[startRow][startCol] = true;

        int total = map[startRow][startCol] - '0'; // 시작 칸 식량 포함!

        while (!deque.isEmpty()) {
            int[] current = deque.poll();
            int curRow = current[0];
            int curCol = current[1];

            for (int i = 0; i < 4; i++) {
                int nextRow = curRow + dx[i];
                int nextCol = curCol + dy[i];

                if (nextRow >= 0 && nextCol >= 0 && nextRow < row && nextCol < col
                        && map[nextRow][nextCol] != 'X' && !visited[nextRow][nextCol]) {
                    visited[nextRow][nextCol] = true;
                    total += map[nextRow][nextCol] - '0'; // 방문 처리와 같은 시점에 합산
                    deque.add(new int[]{nextRow, nextCol});
                }
            }
        }
        return total;
    }
}

각 칸을 정확히 한 번씩만 방문하므로 시간 복잡도는 O(N×M)으로 최적입니다. 이 문제는 방문 순서가 결과에 영향을 주지 않아서 DFS로 풀어도 무방하지만, 격자 탐색은 BFS 패턴으로 통일해두는 편이 스택 오버플로 걱정도 없고 익숙해서 BFS를 선택했습니다.

6 마무리

"BFS는 이미 할 줄 안다"고 생각했는데, 미로 탈출의 틀을 그대로 가져왔다가 큐에 실을 필요 없는 값을 실어 나르며 헤맸습니다. 같은 격자 BFS라도 문제가 "몇 번 만에 도달하는가"를 묻는지 "연결된 덩어리의 합이 얼마인가"를 묻는지에 따라 상태 설계가 완전히 달라진다는 걸 몸으로 배운 문제였습니다.

정리하면 이번 문제에서 챙겨갈 것은 세 가지입니다.

상태 설계 질문 — 큐에 싣기 전에 "이 값이 칸마다 다른가?"를 먼저 묻는다.
초기화 → 탐색 순서 — 자료구조를 다 만들고 나서 그 위에서 탐색을 시작한다.
방문·합산 시점 통일 — 큐에 넣는 순간 방문 처리와 합산을 함께 하고, 시작 칸은 루프 밖에서 미리 더한다.

잘못된 내용이 있다면 지적부탁드립니다. 방문해주셔서 감사합니다.

[프로그래머스] 디펜스 게임 (Java) — 우선순위 큐

곱마2 — Fri, 10 Jul 2026 17:45:13 +0900

핵심 요약

무적권은 소급 적용이 가능하다 — "언제 쓸지" 미리 결정하지 말고, 병사가 부족해진 순간 지금까지 가장 병사를 많이 쓴 라운드에 쓴 셈 치면 된다.
최대 힙(PriorityQueue)으로 최댓값 관리 — 매 라운드 적의 수를 힙에 넣어두면, 소급 적용할 최적의 라운드를 poll() 한 번(O(log N))으로 찾을 수 있다.
검증 후 카운트 — answer++는 그 라운드를 실제로 막아냈다는 검증이 끝난 뒤에 실행해야 실패한 라운드가 세어지지 않는다.

1 문제 설명

https://school.programmers.co.kr/learn/courses/30/lessons/142085

Programmers #142085

디펜스 게임

n ≤ 10⁹ · k ≤ 500,000 · enemy ≤ 1,000,000

난이도: Lv.2

병사 n명으로 매 라운드 enemy[i]마리의 적을 막는 게임이다. 적을 막으면 그 수만큼 병사가 소모되고, 남은 병사보다 적이 많으면 게임이 끝난다. 단, 무적권을 쓰면 병사 소모 없이 한 라운드를 막을 수 있고 최대 k번 사용할 수 있다. 무적권을 최적으로 사용했을 때 최대 몇 라운드까지 버틸 수 있는지 구하는 문제다.

입출력 예

n=7, k=3, enemy=[4,2,4,5,3,3,1] → 적이 많은 4, 5, 4 라운드에 무적권을 쓰고 나머지를 병사로 막으면 5라운드까지 버틴다.
n=2, k=4, enemy=[3,3,3,3] → 병사로는 한 라운드도 못 막지만 무적권 4번으로 4라운드(전부) 막는다.

2 문제 해결 전략

처음 든 생각: 언제 무적권을 써야 하지?

"적이 많은 라운드에 무적권을 아껴 써야 한다"는 건 직관적으로 알겠는데, 문제는 미래의 적 규모를 모른 채로 현재 라운드에서 결정해야 한다는 점이다. 지금 라운드에 무적권을 썼는데 뒤에 더 큰 적이 나오면 손해다. 그렇다고 모든 경우를 탐색하자니 enemy 길이가 최대 100만이라 완전탐색은 불가능하다.

발상의 전환: 무적권을 소급 적용하자

여기서 관점을 바꾸면 문제가 풀린다. 무적권을 미리 결정할 필요가 없다. 일단 모든 라운드를 병사로 막았다고 치고 진행하다가, 병사가 부족해지는 순간(n < 0)에 "지금까지 지나온 라운드 중 병사를 가장 많이 소모한 라운드에 사실은 무적권을 썼던 걸로" 정정하면 된다. 그 라운드에 썼던 병사(enemy 최댓값)를 돌려받는 것이다.

이 소급 적용이 항상 최적인 이유는 간단하다. 무적권 한 장이 아껴주는 병사 수는 그 라운드의 적 수와 같으므로, 같은 한 장이라면 무조건 적이 가장 많았던 라운드에 쓰는 것이 이득이기 때문이다. 이것이 이 문제의 그리디 논리다.

ℹ️

왜 최대 힙인가?

"지금까지 지나온 라운드 중 최댓값"을 매번 꺼내야 하는데, 배열에서 매번 최댓값을 찾으면 O(N)이라 전체 O(N²)이 된다. 최대 힙은 삽입과 최댓값 추출이 모두 O(log N)이므로, "동적으로 원소가 추가되는 집합에서 반복적으로 최댓값을 뽑는" 이 문제에 정확히 들어맞는 자료구조다.

3 구체적인 구현 단계

① 최대 힙 생성

Java의 PriorityQueue는 기본이 최소 힙이므로, Collections.reverseOrder()를 생성자에 넘겨 최대 힙으로 만든다.

② 일단 병사로 막으며 진행

매 라운드 적의 수를 힙에 넣고(pq.add(e)), 병사에서 차감한다(n -= e). 이 시점의 n은 "무적권 없이 여기까지 왔다면 남았을 병사 수"를 의미한다. 음수가 아니라면 그 라운드는 무사히 방어한 것이다.

③ 병사가 부족하면 무적권 소급 적용

n < 0이 되는 순간이 결정의 순간이다. 무적권이 남아 있다면(k > 0) 힙에서 최댓값을 꺼내 병사를 돌려받고(n += pq.poll()) k를 차감한다. 방금 넣은 현재 라운드의 적도 힙에 들어 있으므로, 현재 라운드가 역대 최대라면 자연스럽게 현재 라운드에 무적권을 쓰는 셈이 된다. 무적권이 없다면 이 라운드는 막을 수 없으니 break로 종료한다.

복구 후 n은 항상 0 이상이 되는 이유

힙에서 꺼낸 최댓값은 방금 차감한 현재 라운드의 적 수(e) 이상이다. 직전까지 n ≥ 0이었으므로, n - e + (최댓값 ≥ e)는 반드시 0 이상으로 회복된다. 즉 무적권이 남아 있는 한 단 한 번의 poll로 그 라운드 방어가 보장되고, while로 반복해서 꺼낼 필요가 없다.

④ 검증이 끝난 뒤 answer++

라운드 방어 성공 여부가 확정된 뒤에야 answer++를 실행한다. 무적권으로 복구했든 병사로 막았든 여기 도달했다면 방어 성공이고, 실패 시에는 break로 빠져나가므로 카운트되지 않는다.

⚠️

answer 갱신 타이밍 주의

answer++를 루프 시작 부분(검증 전)에 두면, 무적권도 없고 병사도 부족해서 막지 못한 마지막 라운드까지 세어버리는 오프바이원 오류가 난다. "조건 검증이 모두 끝난 뒤에 확정한다"는 원칙은 이런 시뮬레이션형 문제에서 특히 자주 시험대에 오른다.

4 전체 코드

Java — Solution.java

import java.util.*;

class Solution {
    public int solution(int n, int k, int[] enemy) {
        int answer = 0;

        // 최대 힙: 지나온 라운드 중 가장 큰 적 규모를 O(log N)에 조회
        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());

        for (int e : enemy) {
            pq.add(e);  // 현재 라운드도 무적권 후보에 포함
            n -= e;    // 일단 병사로 막았다고 가정

            if (n < 0) { // 병사 부족 → 결정의 순간
                if (k > 0 && !pq.isEmpty()) {
                    // 가장 컸던 라운드에 무적권을 소급 적용 → 병사 회수
                    n += pq.poll();
                    k--;
                } else {
                    break; // 무적권 소진 → 이 라운드는 못 막음
                }
            }

            answer++; // 검증이 끝난 뒤에만 라운드 카운트
        }

        return answer;
    }
}

시간복잡도는 라운드마다 힙 연산이 O(log N)이므로 전체 O(N log N). enemy 길이가 최대 100만이어도 여유 있게 통과한다.

5 정리

단계	핵심 처리	놓치면 생기는 문제	중요도
힙 구성	`Collections.reverseOrder()`로 최대 힙 생성	기본 최소 힙이면 가장 작은 라운드에 무적권 낭비	필수
진행 순서	힙 삽입 → 차감 → 부족 시 복구	현재 라운드를 힙에 안 넣으면 현재가 최대인 경우 누락	필수
소급 적용	`n < 0`일 때 최댓값 poll로 병사 회수	미리 무적권 시점을 정하려 하면 그리디 성립 불가	핵심 발상
카운트 시점	검증 완료 후 `answer++`	못 막은 라운드까지 세는 오프바이원 오류	함정

이 문제에서 배운 것

그리디에서 "언제 쓸까"를 미리 결정하기 어렵다면, 일단 진행하고 한계에 부딪힌 순간 과거의 선택을 정정하는 소급 적용이 강력한 패턴이 된다. 그리고 "동적으로 추가되는 값들 중 최댓값/최솟값을 반복해서 꺼내는" 작업이 보이면 우선순위 큐가 정답 자료구조다. 힙과 그리디는 이렇게 자주 한 세트로 움직인다.

잘못된 내용이 있다면 지적부탁드립니다. 방문해주셔서 감사합니다.

[프로그래머스] 미로 탈출 (Java) - BFS

곱마2 — Wed, 8 Jul 2026 14:41:04 +0900

핵심 요약

경유지 최단거리 분해 — "S에서 E로 가되 반드시 L을 거쳐야 한다"는 조건은 S→L 최단거리 + L→E 최단거리로 쪼갤 수 있다. 경유지가 고정이면 두 BFS 결과를 독립적으로 합쳐도 최단이 보장된다.
BFS는 target 문자만 알면 된다 — 목표 좌표를 미리 저장할 필요 없이, 탐색 중 처음 만난 target까지의 거리가 곧 최단거리다.

1 문제 분석

Programmers #159993

미로 탈출

5 ≤ 세로 · 가로 ≤ 100 · Lv.2

난이도: Level 2

S(시작점)에서 출발해 E(출구)로 탈출해야 한다. 단, 출구는 잠겨 있어서 반드시 L(레버)을 먼저 당겨야 열린다. X는 벽이라 지나갈 수 없고, 한 칸 이동에 1초가 걸린다. 탈출까지 걸리는 최소 시간을 구하고, 탈출할 수 없으면 -1을 반환한다.

풀이 과정

미로를 순회하며 S와 L의 좌표를 기록한다. (E는 BFS가 문자로 직접 찾으므로 저장 불필요)
1차 BFS: S에서 출발해 L까지의 최단거리를 구한다. 도달 불가면 -1 반환.
2차 BFS: L에서 출발해 E까지의 최단거리를 구한다. 도달 불가면 -1 반환.
두 최단거리의 합을 반환한다.

2 접근: BFS를 두 번으로 나누기

이 문제의 핵심은 "레버를 거쳐야 한다"는 제약을 어떻게 처리하느냐다.

상태에 레버를 당겼는지 여부를 추가해서 한 번의 BFS로 풀 수도 있지만, 훨씬 단순한 관점이 있다.

경유지 L이 고정되어 있다는 점에 주목하면, 전체 경로는 반드시 "S에서 L까지의 구간"과 "L에서 E까지의 구간"으로 나뉜다. 각 구간의 최단거리는 서로 독립적이므로, 두 구간을 각각 BFS로 구해 더하면 그것이 전체 최단 시간이 된다.

ℹ️

왜 두 최단거리를 더해도 최단이 보장될까?

전체 경로가 L을 지나는 순간, 경로는 (S→L 부분)과 (L→E 부분)으로 쪼개진다. 만약 전체 최단 경로의 S→L 부분이 S→L 최단거리보다 길다면, 그 부분만 최단 경로로 교체해서 더 짧은 전체 경로를 만들 수 있으므로 모순이다. 따라서 각 구간의 최단거리 합 = 전체 최단거리가 성립한다. 경유지가 하나로 고정일 때만 통하는 논리라는 점에 주의.

또 하나의 설계 포인트는 BFS에 목표 좌표가 아닌 목표 문자를 넘긴다는 것이다.

BFS는 거리 순으로 칸을 방문하므로, 탐색 중 target 문자를 처음 만난 시점의 거리가 곧 최단거리다.

덕분에 E의 좌표를 미리 저장할 필요가 없고, 같은 bfs 메서드를 두 구간에 그대로 재사용할 수 있다.

3 전체 코드

Java — Solution.java

import java.util.*;

class Solution {
    // 상하좌우 4방향 이동량 (행 변화, 열 변화)
    static final int[] dx = {-1, 1, 0, 0};
    static final int[] dy = {0, 0, -1, 1};

    public int solution(String[] maps) {
        int rows = maps.length;
        int cols = maps[0].length();

        char[][] map = new char[rows][cols];
        int[] start = null;   // 시작 지점 S 좌표
        int[] lever = null;   // 레버 L 좌표

        // 문자열 배열 → char 2차원 배열 변환하며 S, L 좌표 기록
        // (E는 BFS가 target 문자로 직접 찾으므로 좌표 저장 불필요)
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                char c = maps[i].charAt(j);
                map[i][j] = c;

                if (c == 'S')      start = new int[]{i, j};
                else if (c == 'L') lever = new int[]{i, j};
            }
        }

        // 1차 BFS: 시작점 → 레버 최단거리
        int toLever = bfs(start, 'L', map);
        if (toLever == -1) return -1;   // 레버 도달 불가 → 탈출 불가

        // 2차 BFS: 레버 → 출구 최단거리
        int toExit = bfs(lever, 'E', map);
        if (toExit == -1) return -1;    // 출구 도달 불가 → 탈출 불가

        // 경유지(L)가 고정이므로 두 최단거리의 합이 전체 최단 시간
        return toLever + toExit;
    }

    /** start 좌표에서 target 문자까지의 최단거리 반환 (도달 불가 시 -1) */
    private int bfs(int[] start, char target, char[][] map) {
        int rows = map.length;
        int cols = map[0].length;

        Queue<int[]> queue = new ArrayDeque<>();
        boolean[][] visited = new boolean[rows][cols];

        // 큐 원소는 {행, 열, 시작점부터의 거리}
        queue.add(new int[]{start[0], start[1], 0});
        visited[start[0]][start[1]] = true;   // 방문 표시는 enqueue 시점에!

        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int row = cur[0], col = cur[1], dist = cur[2];

            // 목표 도달 → BFS 특성상 처음 만난 거리가 곧 최단거리
            if (map[row][col] == target) return dist;

            for (int d = 0; d < 4; d++) {
                int nextRow = row + dx[d];
                int nextCol = col + dy[d];

                // 격자 범위를 벗어나면 스킵
                if (nextRow < 0 || nextRow >= rows || nextCol < 0 || nextCol >= cols) continue;
                // 벽(X)이면 스킵
                if (map[nextRow][nextCol] == 'X') continue;
                // 이미 방문한 칸이면 스킵
                if (visited[nextRow][nextCol]) continue;

                visited[nextRow][nextCol] = true;
                queue.add(new int[]{nextRow, nextCol, dist + 1});
            }
        }

        return -1;   // 큐가 비었는데 target 미도달
    }
}

방문 표시는 queue 삽입 직전에

방문 표시를 poll 시점에 하면 같은 칸이 큐에 여러 번 들어가 시간과 메모리를 낭비한다. "확인 → 방문 표시 → 큐 삽입" 순서를 지켜, 큐에 넣는 순간 방문 처리하는 것이 BFS의 기본 패턴이다.

잘못된 내용이 있다면 지적부탁드립니다. 방문해주셔서 감사합니다.

[프로그래머스] 연속된 부분 수열의 합 (Java) - 투 포인터

곱마2 — Mon, 6 Jul 2026 16:04:54 +0900

핵심 요약

투 포인터로 O(N) 풀이 — 수열 길이가 최대 100만이라 O(N²) 완전 탐색은 시간 초과. left/right 두 포인터로 윈도우를 늘렸다 줄였다 하며 한 번만 훑습니다.
성립 근거는 단조성 — 모든 원소가 1 이상(양수)이라 right를 밀면 합이 반드시 커지고 left를 밀면 반드시 작아집니다. 이 성질 덕분에 각 상황에서 취할 행동이 하나로 정해집니다.
동점 처리는 부등호 하나로 — "길이가 같으면 시작 인덱스가 작은 것" 조건은 탐색 방향(왼쪽→오른쪽)과 엄격한 부등호(<)의 조합으로 자연스럽게 해결됩니다.

1 문제 소개

Programmers #178870

연속된 부분 수열의 합

수열 길이 ≤ 1,000,000 · 원소 1~1,000 · k ≤ 10억

난이도: Programmers Lv.2

비내림차순으로 정렬된 수열 sequence와 정수 k가 주어질 때, 원소의 합이 k인 연속된 부분 수열을 찾아 [시작 인덱스, 끝 인덱스]를 반환하는 문제입니다. 조건을 만족하는 수열이 여러 개라면 길이가 가장 짧은 것, 길이도 같다면 시작 인덱스가 가장 작은 것을 골라야 합니다. (합이 k인 부분 수열은 항상 존재한다고 보장됩니다.)

예를 들어 sequence = [1, 2, 3, 4, 5], k = 7이면 합이 7인 구간은 [3, 4](인덱스 2~3) 하나뿐이므로 답은 [2, 3]입니다. sequence = [2, 2, 2, 2, 2], k = 6이면 합이 6인 구간이 세 개인데 길이가 모두 3으로 같으므로, 시작 인덱스가 가장 작은 [0, 2]가 답입니다.

2 접근 방법

제한 조건에서 출발하기

가장 먼저 확인한 것은 수열의 길이입니다.

최대 100만이므로, 모든 시작/끝 인덱스 쌍을 시도하는 O(N²) 완전 탐색은 최악의 경우 약 5,000억 번 연산이 되어 시간 초과를 피할 수 없습니다. O(N) 또는 O(N log N) 수준의 풀이가 필요합니다.

다음으로 눈에 들어온 것은 원소가 전부 1 이상의 양수라는 조건입니다.

이 조건이 왜 중요하냐면, 구간의 오른쪽 끝을 늘리면 합이 반드시 증가하고 왼쪽 끝을 줄이면 반드시 감소하는 단조성이 보장되기 때문입니다.

이 단조성이 성립하면 투 포인터(가변 크기 윈도우)를 쓸 수 있습니다.

투 포인터의 동작

left와 right 두 포인터로 구간 [left, right]를 관리하면서, 매 순간 합과 k를 비교해 행동을 결정합니다.

합이 k보다 작으면 → right를 오른쪽으로 밀어 구간을 늘린다 (합 증가)
합이 k보다 크면 → left를 오른쪽으로 밀어 구간을 줄인다 (합 감소)
합이 k와 같으면 → 정답 후보로 기록한다

단조성 덕분에 각 상황에서 취할 행동이 하나로 정해지고, 두 포인터 모두 뒤로 돌아가는 일 없이 각자 최대 N번만 전진하므로 전체 시간 복잡도는 O(N)입니다.

⚠️

0이나 음수가 섞여 있었다면?

구간을 늘렸는데 합이 그대로거나 오히려 줄어드는 상황이 생겨 단조성이 깨지고, 투 포인터로는 놓치는 구간이 발생합니다. 이 문제는 원소가 전부 양수라서 가능한 풀이라는 점을 유의해야합니다.

3 Java 코드

Java — Solution.java (투 포인터, O(N))

class Solution {
    public int[] solution(int[] sequence, int k) {
        int[] answer = new int[2];
        long total = 0;                       // 현재 구간의 합
        int left = 0;                        // 구간의 왼쪽 끝
        int minLength = Integer.MAX_VALUE;   // 지금까지 찾은 최소 길이

        for (int right = 0; right < sequence.length; right++) {
            // 1. 오른쪽 끝을 한 칸 확장
            total += sequence[right];

            // 2. 합이 k를 초과하면 왼쪽 끝을 밀어서 구간을 줄인다
            while (total > k) {
                total -= sequence[left];
                left++;
            }

            // 3. 합이 정확히 k인 구간 발견 → 더 짧을 때만 갱신
            if (total == k) {
                int currentLength = right - left + 1;
                if (currentLength < minLength) {
                    minLength = currentLength;
                    answer[0] = left;
                    answer[1] = right;
                }
            }
        }

        return answer;
    }
}

4 놓치기 쉬운 포인트

동점 처리는 부등호 하나로 끝난다

right가 왼쪽에서 오른쪽으로 진행하므로, 같은 길이의 구간이라면 시작 인덱스가 작은 쪽이 항상 먼저 발견됩니다. 갱신 조건을 currentLength < minLength처럼 등호 없는 엄격한 부등호로 두면, 나중에 나온 같은 길이 구간이 앞의 답을 덮어쓰지 못합니다. 만약 <=로 썼다면 뒤쪽 구간으로 덮어써서 오답이 됩니다.

⚠️

"total == k일 때 left를 더 안 밀어도 되나?"

저도 처음에 잠깐 헷갈렸던 부분인데, 원소가 전부 양수라서 total == k인 상태에서 left를 밀면 합이 무조건 k 미만으로 떨어집니다. 즉 현재 right에서 합이 k가 되는 구간은 지금 그 하나뿐이므로 추가 탐색이 필요 없습니다.

ℹ️

누적 합 변수는 범위 계산부터

while문 덕분에 매 반복이 끝나면 total ≤ k가 보장되고, 다음 원소를 더해도 최대 k + 1,000 ≈ 10억 + 1,000이라 사실 int 범위(약 21.4억) 안입니다. 다만 k가 조금만 더 컸다면 오버플로가 나는 아슬아슬한 코드였습니다. 누적 합 변수는 일단 최대값부터 계산해 보고, 애매하면 long을 쓰는 습관을 들이는 것이 안전합니다.

잘못된 내용이 있다면 지적부탁드립니다. 방문해주셔서 감사합니다.

[프로그래머스] 전력망을 둘로 나누기 (Java) — BFS

곱마2 — Fri, 3 Jul 2026 16:19:46 +0900

핵심 요약

트리의 성질 — 노드 n개, 간선 n-1개면 트리. 간선 하나를 끊으면 정확히 두 개의 컴포넌트로 갈라진다.
완전탐색으로 충분 — n ≤ 100이라 간선 99개를 전부 끊어봐도 여유롭게 통과한다. 그리디하게 고민할 필요가 없다.
한쪽만 세면 끝 — 한쪽 크기가 count면 반대쪽은 n - count. 차이는 Math.abs(count - (n - count)).
트리라서 가능한 단순화 — 간선을 끊는 대신 반대편 노드 하나를 차단하는 것으로 같은 효과를 낼 수 있다.

1 문제 소개

Programmers #86971

전력망을 둘로 나누기

2 ≤ n ≤ 100 · 간선 n-1개

난이도: Lv.2

n개의 송전탑이 전선을 통해 하나의 트리 형태로 연결되어 있다. 전선 중 하나를 끊어 전력망을 2개로 분할하려고 한다. 이때 두 전력망이 갖게 되는 송전탑의 개수를 최대한 비슷하게 맞추고, 그 개수 차이(절댓값)를 반환하는 문제다.

풀이 과정

wires 배열로 양방향 인접 리스트를 만든다.
간선을 하나씩 "끊었다고 가정"하며 전부 시도한다 (완전탐색).
끊은 간선의 한쪽 끝에서 BFS를 돌려 그쪽 컴포넌트의 크기 count를 센다. 이때 반대편 노드를 차단해 간선을 끊은 효과를 낸다.
Math.abs(count - (n - count))로 두 그룹의 차이를 구하고 최솟값을 갱신한다.

2 접근 아이디어

노드 n개 + 간선 n-1개 = 트리

문제를 읽고 처음 눈에 들어온 건 "송전탑 n개, 전선 n-1개"라는 조건이었다. 이건 그래프 이론에서 아주 특별한 형태, 바로 트리라는 뜻이다. 사이클이 없는 연결 그래프이기 때문에, 트리에서 간선 하나를 끊으면 정확히 두 개의 덩어리로 갈라진다는 게 보장된다.

완전탐색으로 충분한 이유

n이 최대 100이므로 간선은 최대 99개다.

"간선을 하나씩 끊어보고 → 매번 결과를 확인"하는 완전탐색을 해도 간선 99개 × 탐색 O(n) 수준이라 시간은 전혀 문제가 되지 않는다.

어떤 간선을 끊어야 유리할지 그리디하게 고민할 필요 없이, 전부 끊어보면 된다.

한쪽 크기만 세면 반대쪽은 공짜

전체가 n개인데 한쪽이 count개라면, 나머지는 자동으로 n - count개다.

그래서 BFS는 한 번만 돌리면 되고, 두 그룹의 차이는 아래 한 줄로 정리된다.

ℹ️

차이 계산과 Math.abs가 필요한 이유

count - (n - count)는 count가 작은 쪽 덩어리인지 큰 쪽 덩어리인지에 따라 음수가 될 수 있다. 문제가 원하는 건 부호 없는 "차이"이므로 Math.abs로 절댓값을 씌운다. 이게 없으면 음수 diff가 Math.min에서 부당하게 이겨버려 답이 망가진다.

3 BFS 설계 — 간선 대신 노드를 차단하기

트리라서 가능한 단순화

"간선 (a, b)를 끊는다"를 구현하는 가장 정직한 방법은 BFS 중에 a→b, b→a 양방향 이동을 모두 검사해서 막는 것이다.

그런데 트리에서는 더 단순한 방법이 있다. a에서 출발하는 BFS가 b 쪽 덩어리로 건너가는 통로는 그 간선 하나뿐이므로, "b 노드 자체를 밟지 않는다"는 조건 하나로 간선을 끊은 것과 완전히 같은 효과가 난다.

⚠️

이 단순화는 트리에서만 성립한다

사이클이 있는 일반 그래프라면 b로 우회해서 도달하는 다른 경로가 존재할 수 있다. 그 경우 노드 차단은 간선 차단보다 더 많은 것을 막아버려 결과가 달라진다. 일반 그래프 문제에서는 간선 쌍(a, b)을 양방향으로 검사하는 방식을 써야 안전하다.

BFS의 핵심: 확인 → 도장 → 예약

BFS에서 큐에 넣는다는 건 "나중에 방문할 것을 예약한다"는 뜻이다. 그래서 visited의 실제 의미는 "방문 완료"가 아니라 "큐에 들어간 적 있음(예약됨)"이고, 도장은 큐에 넣는 시점에 찍어야 한다. 순서는 항상 이 세 동작이 한 세트다.

확인 — !visited[next] 아직 예약 안 된 노드인지 검사한다.
도장 — visited[next] = true 즉시 예약됨 표시를 남긴다.
예약 — queue.add(next) 그 다음에 큐에 넣는다.

직접 겪은 실수: 방문 확인을 빼먹으면 무한 루프

처음 작성한 코드에서 visited[next] = true로 표시는 했지만 넣기 전에 이미 방문한 노드인지 확인을 안 했다. 양방향 그래프에서는 노드 1과 2가 서로를 계속 다시 큐에 넣는 핑퐁이 벌어져서, count가 틀리는 정도가 아니라 while문이 영원히 끝나지 않는다. 표시만 하고 확인을 안 하면 표시가 아무 역할을 못 한다는 걸 몸으로 배웠다.

4 전체 코드 (Java)

Java — Solution.java

import java.util.*;

class Solution {

    // 여러 메서드에서 함께 쓰기 위해 필드로 선언
    private List<List<Integer>> graph;

    public int solution(int n, int[][] wires) {
        int answer = n; // 어떤 diff도 n 이상이 될 수 없으므로 n으로 초기화

        // 1. 인접 리스트 구성 (인덱스 = 노드 번호, 0번은 버림 칸)
        graph = new ArrayList<>();
        for (int i = 0; i <= n; i++) {
            graph.add(new ArrayList<>());
        }
        for (int[] wire : wires) {
            graph.get(wire[0]).add(wire[1]);
            graph.get(wire[1]).add(wire[0]); // 무방향이므로 양방향 등록
        }

        // 2. 간선을 하나씩 끊어보며 완전탐색
        for (int[] wire : wires) {
            // wire[0]에서 시작, wire[1] 노드를 차단
            int count = bfs(wire[0], wire[1], n);

            // 3. 두 그룹의 크기 차이로 최솟값 갱신
            int diff = Math.abs(count - (n - count));
            answer = Math.min(answer, diff);
        }

        return answer;
    }

    // start에서 출발하되 blocked 노드로는 이동하지 않는 BFS
    private int bfs(int start, int blocked, int n) {
        boolean[] visited = new boolean[n + 1];
        Queue<Integer> queue = new LinkedList<>();

        // 4. 시작 노드를 예약(큐 삽입)하고 도장 찍기
        queue.add(start);
        visited[start] = true;
        int count = 0;

        while (!queue.isEmpty()) {
            int cur = queue.poll();
            count++;

            for (int next : graph.get(cur)) {
                // 5. 차단 노드이거나 이미 예약된 노드면 패스
                if (next == blocked || visited[next]) continue;

                visited[next] = true;
                queue.add(next);
            }
        }

        // 6. start 쪽 컴포넌트의 크기 반환
        return count;
    }
}

5 시간복잡도

BFS 한 번은 노드와 간선을 모두 훑으므로 O(V+E) = O(n)이고, 전체는 O(n²)이다.

n ≤ 100이므로 최악에도 1만 번 수준의 연산이라 아주 여유롭다.

단계	연산	복잡도	비고
그래프 구성	간선 n-1개를 양방향 등록	O(n)	1회
BFS 1회	컴포넌트 크기 세기	O(n)	여유
전체	간선 수 × BFS	O(n²)	n ≤ 100이라 충분

잘못된 내용이 있다면 지적부탁드립니다. 방문해주셔서 감사합니다.