29-kokeunho #118

kokeunho · 2025-07-20T21:06:13Z

🔗 문제 링크

[BOJ] 불! https://www.acmicpc.net/problem/4179

✔️ 소요된 시간

1h 25min

✨ 수도 코드

우선 불이 날 수 있는 각 지점에서 bfs를 사용해서
불이 퍼질 수 있는 경로의 지점마다 몇 분만에 불이 옮겨붙을 수 있는지 표시해두었습니다.
(불이 여러 지점에서 발생할 수 있다는 것을 적용하지 않았다가 시간을 좀 버렸습니다.)

그리고 지훈이도 bfs로 탈출을 시도합니다.
지훈이가 다음 지점에 이동할 때, 걸린 시간과 해당 지점에 불이 옮겨 붙은 시간을 비교하여
불이 옮겨 붙는 시간보다 더 빠르다면 해당 지점으로 움직입니다.
미로를 벗어날 때마다 시간을 체크해서 탈출 최단 시간을 구합니다.

📚 새롭게 알게된 내용

kangrae-jo

불이 먼저 퍼지게 하는게 핵심이었네요.
생각이 좀 안나서 근호님 설명 살짝 봤습니다.

방법을 아니까 구현자체의 난이도는 그리높지않았던것 같아요.

근데 처음에 제출했을 때 메모리 초과가 뜨더라구요.
그래서 처음에 불의 위치를 저장하는 큐는 전역에서 사이즈가 늘어나지않도록하고,
메서드 내부에 따로 큐를 두어서 복사하여 사용했네요.
(메모리 초과에 대한 원인파악과 대처가 적절했는지는 모르겠네요)

뭔가 제 30번쨰 피알인 치즈문제와 비슷하군요.

#include <iostream>
#include <queue>
#include <string>
#include <vector>

using namespace std;

const char WALL = '#';
const char PATH = '.';
const char START = 'J';
const char FIRE = 'F';
const int OFFSET[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

int R, C;
pair<int, int> start;
vector<vector<int>> fireTime;
vector<pair<int, int>> fireInit;

bool isIn(int y, int x) { return 0 <= y && y < R && 0 <= x && x < C; }

void diffuse(vector<string>& board) {
    fireTime.assign(R, vector<int>(C, 1e9));
    
    queue<pair<int, int>> q;
    for (auto [y, x] : fireInit) {
        fireTime[y][x] = 0;
        q.push({y, x});
    }

    while (!q.empty()) {
        auto [y, x] = q.front();
        q.pop();

        for (int dir = 0; dir < 4; dir++) {
            int y_ = y + OFFSET[dir][0];
            int x_ = x + OFFSET[dir][1];
            if (isIn(y_, x_) && board[y_][x_] != WALL && fireTime[y_][x_] > fireTime[y][x] + 1) {
                fireTime[y_][x_] = fireTime[y][x] + 1;
                q.push({y_, x_});
            }
        }
    }
}

int solution(vector<string>& board) {
    vector<vector<bool>> visited(R, vector<bool>(C, false));
    queue<pair<int, int>> q;
    q.push({start.first, start.second});
    visited[start.first][start.second] = true;

    int time = 0;
    while (!q.empty()) {
        int size = q.size();
        time++;
        while (size--) {
            auto [y, x] = q.front();
            q.pop();

            if (y == 0 || y == R - 1 || x == 0 || x == C - 1) return time;

            for (int dir = 0; dir < 4; dir++) {
                int y_ = y + OFFSET[dir][0];
                int x_ = x + OFFSET[dir][1];
                if (isIn(y_, x_) && board[y_][x_] == PATH && fireTime[y_][x_] > time && !visited[y_][x_]) {
                    q.push({y_, x_});
                    visited[y_][x_] = true;
                }
            }
        }
    }
    return -1;
}

int main() {
    cin >> R >> C;

    vector<string> board(R);
    for (int y = 0; y < R; y++) {
        cin >> board[y];
        for (int x = 0; x < C; x++) {
            if (board[y][x] == START) start = {y, x};
            else if (board[y][x] == FIRE) fireInit.push_back({y, x});
        }
    }

    diffuse(board);

    int answer = solution(board);
    if (answer == -1) cout << "IMPOSSIBLE\n";
    else cout << answer << "\n";

    return 0;
}

kangrae-jo · 2025-07-21T02:02:15Z

kokeunho/그래프 탐색/29-kokeunho.java

평행세계?중 가장 빨리 나온 지훈이임이 보장됨으로 바로 current[2] + 1 값을 escapeCount로 두고 return해도 됩니다.
우선순위큐가 아니어도 큐는 순서대로 쌓이니까요

wnsmir

간만에 시뮬레이션문제라 재밌게 풀고있었다만,,,

하

불부터 움직이면.. 지훈이가 그자리에있으면 타야하는거아닙니까?!

그래서 당연히 지훈이부터 움직이겠거니 하고 반례 30분넘게찾다가 문제 질문을 보니
불은 지훈이를 삼키지않습니다!! 돼있길래

허탈하게 불 움직이는 for문 지훔이 for문 두개 자리바꾸고 pass했습니다..

이시간 빼면 한 25분 걸린것같습니다!

from collections import deque

R, C = map(int, input().split())
maze = [list(input().strip()) for _ in range(R)]

fire_q = deque()
jihun_q = deque()
visited = [[False]*C for _ in range(R)]

for i in range(R):
    for j in range(C):
        if maze[i][j] == 'J':
            jihun_q.append((i, j))
            visited[i][j] = True
        elif maze[i][j] == 'F':
            fire_q.append((i, j))

dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]

time = 0
while jihun_q:
    time += 1

    # 불 확산
    for _ in range(len(fire_q)):
        x, y = fire_q.popleft()
        for d in range(4):
            nx, ny = x+dx[d], y+dy[d]
            if 0 <= nx < R and 0 <= ny < C:
                if maze[nx][ny] == '.' or maze[nx][ny] == 'J':
                    maze[nx][ny] = 'F'
                    fire_q.append((nx, ny))

    # 지훈이 이동
    for _ in range(len(jihun_q)):
        x, y = jihun_q.popleft()
        # 탈출 조건: 가장자리
        if x == 0 or x == R-1 or y == 0 or y == C-1:
            print(time)
            exit()
        for d in range(4):
            nx, ny = x+dx[d], y+dy[d]
            if 0 <= nx < R and 0 <= ny < C:
                if maze[nx][ny] == '.' and not visited[nx][ny]:
                    visited[nx][ny] = True
                    jihun_q.append((nx, ny))

print("IMPOSSIBLE")

9kyo-hwang

하 로직은 논스탑으로 쫙쫙쫙 작성했는데, 초반에 데이터 입력받는 부분에서

for(int r = 0; r < R; ++r) {
    string mazeRowStr; 
    cin >> mazeRowStr;

    for(int c = 0; c < C; ++C) {  // 소문자 c를 올려야 하는데 대문자 C를 올림!!
        ...
    }
}

이 난리가 나서 자꾸 시간초과 터져서 찾는 데 30분

auto Loop = [&](int& tick) {
    for(tick = 0; ; ++tick) {
        if(tick == 5) {  // 위에 저거 때문에 시간초과 나서 디버깅 용으로 넣은 조건문
            break;
        }
        int moveResult = MoveJihun();
        if(moveResult == 1) {
            return true;
        } else if(moveResult == -1) {
            break;
        } else {
            SpreadFire();
        }
    }
    
    return false;
};

저 조건문 제거 안해서 틀렸습니다 떠서 또 20분 날렸네요 ㅜㅜㅜㅜㅜㅜㅜ

문제 자체는 독립적으로 움직이는 2개의 물체에 대해 별도로 큐를 동작시키는 방식이죠.
저는 하나의 반복문 내에서 1. 지훈이 움직인 뒤 2. 불을 확산시키는 방식으로 진행했습니다.

auto Loop = [&](int& tick) {
    for(tick = 0; ; ++tick) {
        int moveResult = MoveJihun();
        if(moveResult == 1) {
            return true;
        } else if(moveResult == -1) {
            break;
        } else {
            SpreadFire();
        }
    }
    
    return false;
};

int tick;
if(Loop(tick)) {
    cout << tick;
} else {
    cout << "IMPOSSIBLE";
}

메인 Loop는 아래와 같이 동작합니다.

지훈이를 이동시킴. 1이 반환되면 탈출 성공, -1이라면 실패, 0이라면 아직 미로 안을 의미
지훈이가 아직 미로 안이라면 불 확산을 진행
Loop이 true를 반환한다면 내부적으로 진행된 loop 횟수를 출력, 아니라면 IMPOSSIBLE 출력

auto MoveJihun = [&]() -> int {
    if(jihunQ.empty()) {
        return -1;
    }
    
    for(int repeat = jihunQ.size(); repeat > 0; --repeat) {
        const auto [x, y] = jihunQ.front();
        jihunQ.pop();
        
        if(OutOfBound(x, y)) {
            return 1;
        }

        if(maze[x][y] == -2) {
            continue;
        }
        
        for(const auto& [dx, dy] : OFFSET) {
            int nx = x + dx, ny = y + dy;
            if(!OutOfBound(nx, ny) && maze[nx][ny] == -1) {
                maze[nx][ny] = maze[x][y] + 1;
                jihunQ.emplace(nx, ny);
            } else if(OutOfBound(nx, ny)) {
                jihunQ.emplace(nx, ny);
            }
        }
    }
    
    return 0;
};

지훈이는 다음과 같이 움직입니다.

지훈이 Q가 비어있다면, 더 이상 미로 안에서 이동할 수 없으므로 -1을 리턴
아니라면 이동을 수행, 만약 현재 칸이 미로 밖이라면 탈출 성공이므로 1 리턴
또는 현재 칸이 -2라면 불이 도달한 칸이 되어 현재 확인하고 있는 상태는 제거되어야 할 대상이므로 continue
지훈이가 이동 가능한 상태라면 "미로 안이면서 빈 칸이면 이동" 또는 "미로 밖이라면 이동"을 수행
이번 큐 루프를 완료했다면 아직 미로 안에서 생존 중이므로 0 리턴

auto SpreadFire = [&]() -> void {
    for(int repeat = fireQ.size(); repeat > 0; --repeat) {
        const auto [x, y] = fireQ.front();
        fireQ.pop();
        
        for(const auto& [dx, dy] : OFFSET) {
            int nx = x + dx, ny = y + dy;
            if(OutOfBound(nx, ny) || maze[nx][ny] == -2) {
                continue;
            }
            
            maze[nx][ny] = -2;
            fireQ.emplace(nx, ny);
        }
    }
};

불 확산은 간단합니다. 못 가는 칸만 아니라면, 무조건 다 불 집어넣으면 됩니다.

전체 코드

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    enum {
        WALL = '#',
        EMPTY = '.',
        JIHUN = 'J',
        FIRE = 'F',
    };
    
    int R, C;
    cin >> R >> C;

    queue<pair<int, int>> jihunQ, fireQ;
    vector<vector<int>> maze(R, vector<int>(C));
    
    for(int r = 0; r < R; ++r) {
        string mazeRowStr; 
        cin >> mazeRowStr;

        for(int c = 0; c < C; ++c) {
            switch(mazeRowStr[c]) {
                case WALL:
                    maze[r][c] = -2;
                    break;
                case FIRE:
                    maze[r][c] = -2;
                    fireQ.emplace(r, c);
                    break;
                case EMPTY:
                    maze[r][c] = -1;
                    break;
                case JIHUN:
                    maze[r][c] = 0;
                    jihunQ.emplace(r, c);
                    break;
            }
        }
    }
    
    auto OutOfBound = [R, C](int r, int c) {
        return r < 0 || r >= R || c < 0 || c >= C;
    };
    
    const vector<pair<int, int>> OFFSET{{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    
    auto MoveJihun = [&]() -> int {
        if(jihunQ.empty()) {
            return -1;
        }
        
        for(int repeat = jihunQ.size(); repeat > 0; --repeat) {
            const auto [x, y] = jihunQ.front();
            jihunQ.pop();
            
            if(OutOfBound(x, y)) {
                return 1;
            }

            if(maze[x][y] == -2) {
                continue;
            }
            
            for(const auto& [dx, dy] : OFFSET) {
                int nx = x + dx, ny = y + dy;
                if(!OutOfBound(nx, ny) && maze[nx][ny] == -1) {
                    maze[nx][ny] = maze[x][y] + 1;
                    jihunQ.emplace(nx, ny);
                } else if(OutOfBound(nx, ny)) {
                    jihunQ.emplace(nx, ny);
                }
            }
        }
        
        return 0;
    };
    
    auto SpreadFire = [&]() -> void {
        for(int repeat = fireQ.size(); repeat > 0; --repeat) {
            const auto [x, y] = fireQ.front();
            fireQ.pop();
            
            for(const auto& [dx, dy] : OFFSET) {
                int nx = x + dx, ny = y + dy;
                if(OutOfBound(nx, ny) || maze[nx][ny] == -2) {
                    continue;
                }
                
                maze[nx][ny] = -2;
                fireQ.emplace(nx, ny);
            }
        }
    };
    
    auto Loop = [&](int& tick) {
        for(tick = 0; ; ++tick) {
            int moveResult = MoveJihun();
            if(moveResult == 1) {
                return true;
            } else if(moveResult == -1) {
                break;
            } else {
                SpreadFire();
            }
        }
        
        return false;
    };
    
    int tick;
    if(Loop(tick)) {
        cout << tick;
    } else {
        cout << "IMPOSSIBLE";
    }

    return 0;
}

g0rnn

문제가 좀 불친절 하네요.. 불이 여러 개일 수 있다는 가정도 없고(내가 한개라고 생각한게 이상한건가), 카운트가 1부터 시작한다는 얘기도 없네용..

저는 while문 내에서 fire의 큐와 지훈이의 위치를 담은 큐를 동시에 돌렸습니다. 각각의 size를 기반으로 while문을 돌려서 예상외로 겹칠 일은 없습니다. 그리고 지훈이가 먼저 움직인다면 불과 맞닥들일 수 있으므로 불이 먼저 움직여야한다고 생각했습니다.

그런데 시간을 세는 카운트가 1부터 시작하고, isEdge로 가장자리를 판별하는 순서가 꼬여서 10분정도 손해를 봤네요; 그래도 골드 3 bfs문제는 손쉽게 풀리는 지경에 도달했네요

고생하셨씁니다~~

package beakjoon;

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

public class Sol4179 {

    static final char WALL = '#';
    static int r, c, answer=1;
    static char[][] board;
    static int[] J = new int[2];
    static List<int[]> fireStarts = new ArrayList<>();
    static int[][] offset = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        r = Integer.parseInt(st.nextToken());
        c = Integer.parseInt(st.nextToken());
        board = new char[r][c];
        for (int i = 0; i < r; i++) {
            board[i] = br.readLine().toCharArray();
            for (int j = 0; j < c; j++) {
                if (board[i][j] == 'J') {
                    J[0] = j; // x
                    J[1] = i;
                } else if (board[i][j] == 'F') {
                    fireStarts.add(new int[]{j, i});
                }
            }
        }
        br.close();

        if (bfs()) {
            System.out.println(answer);
        } else {
            System.out.println("IMPOSSIBLE");
        }
    }

    private static boolean bfs() {
        Queue<int[]> jihoon = new ArrayDeque<>();
        Queue<int[]> fire = new ArrayDeque<>();
        boolean[][] jVisited = new boolean[r][c];
        boolean[][] fVisited = new boolean[r][c];

        if (isEdge(J[0], J[1])) return true;

        jihoon.offer(new int[]{J[0], J[1]});
        jVisited[J[1]][J[0]] = true;

        // 불 시작위치 지정
        for (int[] f : fireStarts) {
            fire.offer(f);
            fVisited[f[1]][f[0]] = true;
        }

        while (!jihoon.isEmpty()) {
            int jSize = jihoon.size();
            int fSize = fire.size();

            while (fSize-- > 0) {
                int x = fire.peek()[0];
                int y = fire.poll()[1];

                for (int[] o : offset) {
                    int nx = x + o[0];
                    int ny = y + o[1];

                    if (nx < 0 || nx >= c || ny < 0 || ny >= r) {
                        continue;
                    }
                    if (fVisited[ny][nx] || board[ny][nx] == WALL) {
                        continue;
                    }
                    fire.offer(new int[]{nx, ny});
                    fVisited[ny][nx] = true;
                    board[ny][nx] = 'F';
                }
            }

            while (jSize-- > 0) {
                int x = jihoon.peek()[0];
                int y = jihoon.poll()[1];

                if (isEdge(x, y)) {
                    return true;
                }

                for (int[] o : offset) {
                    int nx = x + o[0];
                    int ny = y + o[1];

                    if (nx < 0 || nx >= c || ny < 0 || ny >= r) {
                        continue;
                    }
                    if (jVisited[ny][nx] || board[ny][nx] == WALL || board[ny][nx] == 'F') {
                        continue;
                    }

                    jihoon.offer(new int[]{nx, ny});
                    jVisited[ny][nx] = true;
                }
            }
            answer++;
        }
        return false;
    }

    private static boolean isEdge(int x, int y) {
        return x == 0 || y == 0 || x == (c-1) || y == (r-1);
    }
}

kokeunho added 2 commits July 21, 2025 05:52

29-kokeunho

54715fa

29-kokeunho

47f0e72

kokeunho requested review from g0rnn, kangrae-jo and wnsmir July 20, 2025 21:06

kokeunho self-assigned this Jul 20, 2025

kokeunho added kokeunho 리뷰 기다리는 중 🔥 labels Jul 20, 2025

kangrae-jo approved these changes Jul 21, 2025

View reviewed changes

wnsmir approved these changes Jul 21, 2025

View reviewed changes

9kyo-hwang approved these changes Jul 25, 2025

View reviewed changes

g0rnn approved these changes Jul 26, 2025

View reviewed changes

g0rnn added 리뷰 완료 ✔️ and removed 리뷰 기다리는 중 🔥 labels Jul 26, 2025

Merge branch 'main' into 29-kokeunho

dc2e681

kokeunho merged commit 4084daf into main Jul 27, 2025

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

29-kokeunho #118

29-kokeunho #118

Uh oh!

kokeunho commented Jul 20, 2025

Uh oh!

kangrae-jo left a comment

Uh oh!

kangrae-jo Jul 21, 2025

Uh oh!

wnsmir left a comment

Uh oh!

9kyo-hwang left a comment

Uh oh!

g0rnn left a comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

6 participants

29-kokeunho #118

29-kokeunho #118

Uh oh!

Conversation

kokeunho commented Jul 20, 2025

🔗 문제 링크

✔️ 소요된 시간

✨ 수도 코드

📚 새롭게 알게된 내용

Uh oh!

kangrae-jo left a comment

Choose a reason for hiding this comment

Uh oh!

kangrae-jo Jul 21, 2025

Choose a reason for hiding this comment

Uh oh!

wnsmir left a comment

Choose a reason for hiding this comment

Uh oh!

9kyo-hwang left a comment

Choose a reason for hiding this comment

Uh oh!

g0rnn left a comment

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

6 participants