21-flydongwoo

[flydongwoo]

🔗 문제 링크

https://www.acmicpc.net/problem/7576

✔️ 소요된 시간

30분

✨ 수도 코드

이번 문제는 앞과 뒤가 다른 사람이 많은 어지러운 현대사회에 **'앞으로 해도, 뒤로 해도 같은 토마토 같은 사람'**이 되자!
라는 마음으로 토마토 문제 가져왔습니다.. 네...

제가 생각하는 이 토마토 문제의 포인트는 토마토가 익은 상태(1)의 좌표를 토마토 정보를 입력받을때 queue에 저장하는 것을 아는 것이라고 생각합니다. 즉, queue에 담긴 익은 토마토(1)를 시작점으로 해서 BFS를 돌려야하죠.

우선, 창고 크기 m(열), n(행)을 입력받습니다.
n × m 격자를 한 칸씩 읽어 graph[i][j]에 저장하는데, 읽는 동안, 값이 1(익은 토마토) 인 칸 (i, j)는 큐 q에 즉시 넣습니다.
-> 이렇게 하면 "다중 시작점"이 BFS가 됩니다.

이제, BFS를 하는데 큐 앞에서 좌표 (y, x)를 꺼내는데, 4방향 이웃 (ny, nx)에 대해, 범위 안이고, 그 칸이 0(안 익음) 이면, graph[ny][nx] = graph[y][x] + 1로 날짜를 1 늘려 기록하고, 이 좌표 (ny, nx)를 큐에 넣어 다음 전파 대상으로 만듭니다.

그러므로, 처음 1이었던 칸들은 1, 하루 뒤 전파된 칸은 2, 그 다음은 3 … 처럼 값이 “날짜”로 누적되는 것이죠.

그 다음으로, 판정을 하는데 격자를 다시 전부 순회해서 만약 값이 0인 칸이 하나라도 남아 있으면 익히지 못한 토마토가 존재하는 것이므로 -1을 출력하고 종료합니다. 그 외에는 모든 칸의 값 중 최댓값을 result에 저장합니다.

마지막으로, 초기 익은 칸의 값이 1부터 시작하므로, 총 소요 일수는 result에서 1을 빼줘야하죠.

예제 3번을 제가 그림으로 검증해보면

이것은 BFS 탐색이 시작되는 지점입니다. 초록색이 시작점이죠.

이것은 BFS 탐색이 끝나는 지점입니다. 주황색이 도착점이죠.

그러므로 최댓값이 7이 되고 정답은 7에서 1을 뺀 6이 되는 것입니다.

이제 코드 남기고 이만 사라지겠습니다 좋은 주말되세요 총총

#include <iostream>
#include <queue>
#include <cstring>

#define MAX_SIZE 1000 + 1

using namespace std;

struct tomato {
    int y, x;
};

queue<tomato> q;

// 우,하,좌,상
int dx[4] = { 1, 0, -1, 0 };
int dy[4] = { 0, 1, 0, -1 };

int n, m, result = 0;
int graph[MAX_SIZE][MAX_SIZE];

bool IsInside(int ny, int nx) {
    return (0 <= nx && 0 <= ny && nx < m && ny < n);
}

void bfs(void) {
    while (!q.empty()) {
        int y = q.front().y;
        int x = q.front().x;
        q.pop();

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

            if (IsInside(ny, nx) == 1 && graph[ny][nx] == 0) {
                graph[ny][nx] = graph[y][x] + 1;
                q.push({ ny, nx });
            }
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    cin >> m >> n;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> graph[i][j];
            if (graph[i][j] == 1) {
                q.push({ i, j });
            }
        }
    }

    bfs();

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (graph[i][j] == 0) {
                cout << -1 << endl;
                return 0;
            }
            if (result < graph[i][j]) {
                result = graph[i][j];
            }
        }
    }

    cout << (result - 1) << endl;
    return 0;
}

📚 새롭게 알게된 내용

queue는 FIFO 구조를 가지고 있음을 염두해두고 그림을 그려가며 생각하면 이해하기 쉽다는 것을 느꼈습니다.

[Seol-Munhyeok]

생각해볼게 많은 BFS 문제네요... 저는 매번 1로 채워나가면서 각 BFS의 탐색 레벨마다 지금 토마토가 다 익었는지 판단하는 방식으로 풀었는데 Python3는 시간초과를 받고, PyPy로 해서 통과를 받았습니다.

시간초과의 원인은 매번 모든 배열을 순회하며 모든 토마토가 다 익었는지 체크하는 것을 너무 자주 반복해서였습니다. 효율적인 풀이는 동우 님처럼 한번의 BFS로 모든 배열을 다 기록하고, 딱 한번만 전체를 순회해서 정답을 찾는 것입니다.

여러 시작점 BFS 문제라는 유형을 새롭게 알게되었습니다.
BFS 단계마다 레벨을 기록할 때, 배열에 이전에 있던 값 + 1을 기록하는 방식으로 처리하는 부분도 기억하고 갑니다.
수고하셨습니다.

[풀이 1] http://boj.kr/29316c1257b94a7fa1635ea9e1df4579
[풀이 2] http://boj.kr/9083d6d8e0324dfba676cec7574cba63

[hyeokbini]

BFS의 스테디셀러 같은 문제네요. BFS를 진행시키되, 날짜라는 개념이 중요하게 작용하기 때문에 큐의 길이를 미리 재 준 다음, 큐의 길이만큼 전이를 진행하고 날짜를 +1해주는 로직을 사용했습니다.

맨 마지막에는 전체 배열을 한번 훑어보면서 0이 있는지 확인 후, 있다면 -1을 출력해주었습니다.

제출 코드입니다. 고생하셨어요!

토마토 / c++

#include <bits/stdc++.h>

using namespace std;

int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int n, m;
vector<vector<int>> arr;
queue<pair<int, int>> Q;

int main()
{
    //freopen("test.txt", "rt", stdin);
    cin >> m >> n;
    int tmp;
    arr.resize(n, vector<int>(m));
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> tmp;
            arr[i][j] = tmp;
            if (tmp == 1)
            {
                Q.push({i, j});
            }
        }
    }
    int day = -1;
    while (!Q.empty())
    {
        int qlength = Q.size();
        while (qlength--)
        {
            pair<int, int> cur = Q.front();
            Q.pop();
            for(int i = 0; i < 4; i++)
            {
                int nx = cur.first + dx[i];
                int ny = cur.second + dy[i];
                if(nx < 0 || ny < 0 || nx >= n || ny >= m || arr[nx][ny] != 0)
                {
                    continue;
                }
                arr[nx][ny] = 1;
                Q.push({nx,ny});
            }
        }
        day++;
    }
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if(arr[i][j] == 0)
            {
                cout << -1;
                return 0;
            }
        }
    }
    cout << day;
}

[mj010504]

저는 익혀야 하는 토마토 총 수를 미리구하고, 날짜라는 개념이 있기에 새로운 큐를 만들어 새롭게 익힌 토마토를 push하고 탐색이 끝난 후 새로운 큐를 원래 큐에 대입하는 방식을 사용했습니다. 혁빈님처럼 큐의 길이를 통해서 조절하는 방법도 좋은 것 같습니다.
수고하셨습니다!

토마토

#include <bits/stdc++.h>

using namespace std;

int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};

int main() {
  //   freopen("input.txt", "rt", stdin);  
    ios::sync_with_stdio(false);  
    cin.tie(0);
    cout.tie(0);
    
    int n, m; cin >> m >> n;
    vector<vector<int>> v(n, vector<int> (m));
    queue<pair<int, int>> q;
    int ripe = 0; // 익은 토마토 수
    int empty = 0;
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) {
            int a; cin >> a;
            if(a == 1) {
                ripe++;
                q.push({i, j});
            }

            if(a == -1) empty++;

            v[i][j] = a;
        }
    }

    int total = n * m - empty;

    if(ripe == total) {
        cout << 0;
        return 0;
    }

    int res = 0;
    int sum = 0;

    while(1) {
        queue<pair<int, int>> tq;
        res += 1;
        while(!q.empty()) {
            auto tp = q.front(); q.pop();

            for(int d = 0; d < 4; d++) {
                int xx = tp.first + dx[d];
                int yy = tp.second + dy[d];
                if(xx >= 0 && xx < n && yy >=0 && yy < m && v[xx][yy] == 0) {
                    ripe++;
                    v[xx][yy] = 1;
                    tq.push({xx, yy});
                }
            }
        }
        
        if(ripe == total) break;
        if(tq.empty()) break;
        q = tq;
    }

    if(ripe != total) res = -1;

    cout << res;

    return 0;
}

</details>