6-rivkms

[rivkms]

🔗 문제 링크

토마토

✔️ 소요된 시간

2H (문제 푸는 방법을 조금 변형했더니 시간이 더 늘어났네요)

✨ 수도 코드

📝 참고사항

이번 문제를 가지고 온 이유는, 사실 2차원 배열을 1차원 배열로 생각하여 풀어보기 위함이었습니다.
이 문제를 2차원 배열로 풀어도 문제는 없을 것 같으나, 1차원 배열로 바꾸어 풀어보시는 것도 좋을 듯 합니다 ㅎㅎ

※ 2차원 배열 map[i][j]를 1차원 배열로 만든다고 하면 map[i*w+j]로 바꿀 수 있습니다.

✔️ 문제

M*N의 상자의 정보가 주어진다. 이 때 하루가 지날 때마다 익어있는 토마토에 의해 상하좌우의 토마토가 익는다.
이 때 상자에 있는 모든 토마토가 익을 때 까지의 최소 날짜를 출력하고, 모두 익지 못하면 -1을 출력한다.

✔️ 접근 방법

1️⃣ 입력을 받아보자

1. vector인 map에 초기상태를 저장하자.
2. 이 때 익은 토마토(1)의 위치도 queue에 저장하자.

2️⃣ queue의 끝에 -1을 저장하자. (하루가 지났음을 의미하는 -1)

3️⃣ while문을 설정하여 queue가 빌 때까지 수행한다.

1. queue에서 맨 앞의 값을 pop하자
2. 만약 그 값이 -1일 때, queue안에 더 이상 값이 없다면 while문을 종료한다.
3. 그렇지 않다면 날짜(s)를 하루를 증가시키고 queue에 -1을 넣는다.

4. queue에서 pop한 위치의 상하좌우의 토마토가 익지 않았다면( 0이라면 ), 익도록 만든다( 1로 만든다 )
5. 만약 4에 의해 토마토가 익게 되었다면, 익게 된 토마토의 위치를 queue에 넣는다.

4️⃣ 토마토가 모두 익었는지 확인하여 최소 날짜를 출력한다.

1. map에 0이 남아있으면 -1을 출력한다.
2. 그렇지 않다면 s를 출력한다.

🖥️ 코드

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

using namespace std;
int SIZE;

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int w, h, s = 0;
    cin >> w >> h;
    SIZE = w*h;

    vector<int> box(SIZE);
    queue<int> q;

    for(int i = 0; i<SIZE; i++){
        cin >> box[i];
        if(box[i]==1){
            q.push(i);
        }
    }
    q.push(-1);
    while(!q.empty()){
        int tmp = q.front();
        q.pop();
        if(tmp == -1){
            if(q.empty()){
                break;
            }
            s++;
            q.push(-1);
            continue;
        }
        int x = tmp%w;
        int y = tmp/w;
        for(int i = 0; i<4; i++){
            if(x+1<w && box[y*w+x+1]==0){
                box[y*w+x+1] = 1;
                q.push(y*w+x+1);
            }
            else if(y+1<h&&box[(y+1)*w+x]==0){
                box[(y+1)*w+x] = 1;
                q.push((y+1)*w+x);
            }
            else if(x>0 && box[y*w+x-1]==0){
                box[y*w+x-1] = 1;
                q.push(y*w+x-1);
            }
            else if(y>0 && box[(y-1)*w+x]==0){
                box[(y-1)*w+x] = 1;
                q.push((y-1)*w+x);
            }
        }
    }
    for(int y = 0; y<h; y++){
        for(int x = 0; x<w; x++){
            if(box[y*w+x]==0){
                cout << -1;
                return 0;
            }
        }
    }
    cout << s;

    return 0;
}

📚 새롭게 알게된 내용

✔️처음에 접근할 때에는 매 반복마다 map을 확인하고, 변화를 확인하는 과정을 거쳤습니다. ( 7576_2.cpp 참고 )
이 코드로 하니 시간초과가 발생하였습니다.
매번 전체 map을 확인하는 것에서 시간초과가 발생한다고 생각하여 queue를 이용하여 그 시간을 줄였고 성공적으로 코드를 작성할 수 있었습니다.

✔️ 2차원 배열을 1차원 배열로 바꾸어 계산을 하는 것을 보고 신기하여 이 코드를 짜본 것인데, 새로운 방식을 알게 되어 좋았습니다.

[kjs254]

전형적인 BFS문제를 정석적으로 잘 풀어내신 것 같습니다.

또한, 2차원 배열 map[y][x] 를 가중치 w를 사용해 1차원 배열 map[y*w+x]로 잘 표현하신 것 같습니다.

이 둘의 차이가 연산 속도에 크게 영향이 적다고 생각되는데 실제로 그런가요?

[kjs254]

queue를 사용하여 map을 일일히 탐색하지 않고도 토마토가 담긴 위치 만을 배출하는 것이 인상적이었습니다.

[rivkms]

전형적인 BFS문제를 정석적으로 잘 풀어내신 것 같습니다.

또한, 2차원 배열 map[y][x] 를 가중치 w를 사용해 1차원 배열 map[y*w+x]로 잘 표현하신 것 같습니다.

이 둘의 차이가 연산 속도에 크게 영향이 적다고 생각되는데 실제로 그런가요?

✔️ 위의 코드와 같지만, 2차원 배열로 바꾸어 작성해보았습니다!!

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

using namespace std;
int SIZE;

int main(){
    ios_base::sync_with_stdio(false);
	cin.tie(NULL);
    int w, h, s = 0;
    cin >> w >> h;
    
    vector<vector<int>> box(h, vector<int> (w,0));
    queue<pair<int, int>> q;

    for(int i = 0; i <h; i++){
        for(int j = 0; j < w; j++){
            cin >> box[i][j];
            if(box[i][j] == 1){
                q.push(pair<int, int>(i, j));
            }
        }
    }
    q.push(pair<int, int> (-1, 0));
    while(!q.empty()){
        pair<int, int> tmp = q.front();
        q.pop();
        if(tmp.first == -1){
            if(q.empty()){
                break;
            }
            s++;
            q.push(pair<int, int> (-1,0));
            continue;
        }
        for(int i = 0; i<4; i++){
            if(tmp.second+1<w && box[tmp.first][tmp.second+1] == 0){
                box[tmp.first][tmp.second+1] = 1;
                q.push(pair<int, int> (tmp.first, tmp.second+1));
            }
            else if(tmp.first+1<h && box[tmp.first+1][tmp.second] == 0){
                box[tmp.first+1][tmp.second] = 1;
                q.push(pair<int, int> (tmp.first+1, tmp.second));
            }
            else if(tmp.second>0 && box[tmp.first][tmp.second-1] == 0){
                box[tmp.first][tmp.second-1] = 1;
                q.push(pair<int, int> (tmp.first, tmp.second-1));
            }
            else if(tmp.first>0 && box[tmp.first-1][tmp.second] == 0){
                box[tmp.first-1][tmp.second] = 1;
                q.push(pair<int, int> (tmp.first-1, tmp.second));
            }
        }
    }
    for(int y = 0; y<h; y++){
        for(int x = 0; x<w; x++){
            if(box[y][x]==0){
                cout << -1;
                return 0;
            }
        }
    }
    cout << s;

    return 0;
}

다음과 같이 나오는데요.

✔️ 이 때 시간을 비교해보면

위쪽이 1차원 배열, 아랫쪽이 2차원 배열입니다.

‼️ 약간의 차이는 나는 것 같네요. 아마 자료의 크기가 커지면 더 커질수도 있을 듯 합니다.
지금 상황에서는 크게 차이가 나지 않는 거 같기도 하지만, 필요한 때가 있을 수도 있으니 알고 계시면 도움이 되실 것 같기도 합니다.

[YIM2UL2ET]

큐를 이용하는 정석적인 문제 같은데 큐 복습에 조금 도움이 되었습니다.

2차원 배열을 1차원으로 사용하는 이유를 찾아보니 가장 큰 이유가 오버헤드가 없다고 하네요. (참고자료: 링크)

극한의 성능을 추구해야 하거나, 배열 크기가 너무 커서 오버헤드가 많이 발생하는 상황이 아니라면 저는 계속 2차원 배열을 사용할 것 같으나, 1차원 배열을 사용하는 상황이 올 때를 대비해서 저도 1차원 배열을 사용하는 방법도 연습해야겠네요. 수고하셨습니다!

[mong3125]

1차원 배열이 빠른 이유는 캐시메모리 덕분일 수도 있겠다는 생각이 드네요.
메모리 정렬과 캐시

저는 코드 직관성이 떨어진다고 생각해서 잘 사용하진 안을것 같은데 새로운 접근법을 배울 수 있어서 좋았습니다.