인프런 커뮤니티 질문&답변

안녕하세요 선생님

강의 잘 보고 있습니다.

아래의 코드가 왜 탈락하는 지 잘 모르겠습니다..ㅜ

/******************************************************************************

Welcome to GDB Online.
GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
C#, OCaml, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
Code, Compile, Run and Debug online from anywhere in world.

*******************************************************************************/
#include <iostream>
#include <queue>
#include <vector>
#include <string>
#include <cmath>

std::string map[1000];
bool visited[1000][1000];
bool visitedFire[1000][1000];
int personMap[1000][1000];
int fireMap[1000][1000];
int exitY, exitX;
int cnt;

#define INF 420000000

void bfsFire(const int y, const int x, const int R, const int C)
{
    std::queue<std::pair<int, int>> que;
    que.push({y, x});
    visitedFire[y][x] = true;
    
    int newX, newY, currX, currY;
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    
    while(que.empty() != true)
    {
        currY = que.front().first;
        currX = que.front().second;
        que.pop();
        for(int  i = 0; i < 4; ++i)
        {
            newY = currY + dy[i];
            newX = currX + dx[i];
            if (newX >= 0 && newX < C && newY >= 0 && newY < R && !visitedFire[newY][newX] && map[newY][newX] != '#')
            {
                que.push({newY, newX});
                fireMap[newY][newX] = std::min(fireMap[currY][currX] + 1, fireMap[newY][newX]);
                visitedFire[newY][newX] = true;
            }
        }
    }
}

void bfs(const int y, const int x, const int R, const int C)
{
    std::queue<std::pair<int, int>> que;
    que.push({y, x});
    visited[y][x] = true;
    
    int newX, newY, currX, currY;
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    
    while(que.empty() != true)
    {
        currY = que.front().first;
        currX = que.front().second;
        que.pop();
        if (currY == R - 1 || currX == C - 1)
        {
            cnt = personMap[currY][currX];
            return;
        }
        for(int  i = 0; i < 4; ++i)
        {
            newY = currY + dy[i];
            newX = currX + dx[i];
            if (newX >= 0 && newX < C && newY >= 0 && newY < R && !visited[newY][newX] && map[newY][newX] == '.')
            {
                if (fireMap[newY][newX] > personMap[currY][currX] + 1)
                {
                    que.push({newY, newX});
                    personMap[newY][newX] = personMap[currY][currX] + 1;    
                }
                visited[newY][newX] = true;
            }
        }
    }
}

bool isPossible(int R, int C)
{
    for (int i = 0; i < R; ++i)
    {
        if (personMap[i][0] < fireMap[i][0]) return true;
        if (personMap[i][C - 1] < fireMap[i][C - 1]) return true;
    }
    
    for (int i = 0; i < C; ++i)
    {
        if (personMap[0][i] < fireMap[0][i]) return true;
        if (personMap[R - 1][i] < fireMap[R - 1][i]) return true;
    }
    
    return false;
}

int main()
{
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    
    int R, C;
    
    std::cin >> R >> C;
    std::vector<std::pair<int, int>> fire;
    exitX = C;
    exitY = R;
    int y, x;
    
    std::fill(&fireMap[0][0], &fireMap[999][1000], INF);
    for(int i = 0; i < R; ++i)
    {
        std::cin >> map[i];
        for (int j = 0; j < C; ++j)
        {
            if (map[i][j] == 'J') 
            {
                y = i;
                x = j;
                personMap[i][j] = 1;
            }
            else if (map[i][j] == 'F')
            {
                fireMap[i][j] = 1;
                fire.push_back({i, j});
            }
        }
    }
    
    bfs(y, x, R, C);
    for(int i = 0; i < fire.size(); ++i)
        bfsFire(fire[i].first, fire[i].second, R, C);
    
    if (!isPossible(R, C)) cnt = 0;
    
    if(cnt == 0)
    {
        std::cout << "IMPOSSIBLE" << std::endl;
    }
    else
    {
        std::cout << cnt << std::endl;
    }
    
    
    

    return 0;
}