23-flydongwoo

[flydongwoo]

🔗 문제 링크

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

✔️ 소요된 시간

40분

✨ 수도 코드

후다닥 23주차 PR도 작성해보도록 하겠습니다.

이 문제 역시 시뮬레이션 문제입니다.

핵심은 아래의 두 가지 주요 단계를 T번 반복하는건데요!

1. 모든 미세먼지가 동시에 인접한 네 방향으로 퍼져나갑니다
2. 위쪽과 아래쪽 공기청정기가 각각 정해진 방향으로 바람을 일으켜 미세먼지를 한 칸씩 이동시킵니다
   그런데, 더 중요한 것은 '동시에' 일어난다는 점입니다.

우선, 제 코드를 보시죠.

#include <iostream>
#include <vector>
#include <numeric>

using namespace std;

int R, C, T;
vector<vector<int>> room;
int purifier_top_r = -1;
int purifier_bottom_r = -1;

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

void spread_dust() {
    vector<vector<int>> diffused_dust(R, vector<int>(C, 0));

    for (int r = 0; r < R; r++) {
        for (int c = 0; c < C; c++) {
            if (room[r][c] > 0) {
                int spread_amount = room[r][c] / 5;
                int spread_count = 0;

                for (int i = 0; i < 4; i++) {
                    int nr = r + dr[i];
                    int nc = c + dc[i];

                    if (nr >= 0 && nr < R && nc >= 0 && nc < C && room[nr][nc] != -1) {
                        diffused_dust[nr][nc] += spread_amount;
                        spread_count++;
                    }
                }
                room[r][c] -= spread_amount * spread_count;
            }
        }
    }

    for (int r = 0; r < R; r++) {
        for (int c = 0; c < C; c++) {
            room[r][c] += diffused_dust[r][c];
        }
    }
}

void circulate_air() {
    for (int r = purifier_top_r - 1; r > 0; r--) {
        room[r][0] = room[r - 1][0];
    }
    for (int c = 0; c < C - 1; c++) {
        room[0][c] = room[0][c + 1];
    }
    for (int r = 0; r < purifier_top_r; r++) {
        room[r][C - 1] = room[r + 1][C - 1];
    }
    for (int c = C - 1; c > 1; c--) {
        room[purifier_top_r][c] = room[purifier_top_r][c - 1];
    }
    room[purifier_top_r][1] = 0;

    for (int r = purifier_bottom_r + 1; r < R - 1; r++) {
        room[r][0] = room[r + 1][0];
    }
    for (int c = 0; c < C - 1; c++) {
        room[R - 1][c] = room[R - 1][c + 1];
    }
    for (int r = R - 1; r > purifier_bottom_r; r--) {
        room[r][C - 1] = room[r - 1][C - 1];
    }
    for (int c = C - 1; c > 1; c--) {
        room[purifier_bottom_r][c] = room[purifier_bottom_r][c - 1];
    }
    room[purifier_bottom_r][1] = 0;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    cin >> R >> C >> T;
    room.resize(R, vector<int>(C));

    for (int i = 0; i < R; i++) {
        for (int j = 0; j < C; j++) {
            cin >> room[i][j];
            if (room[i][j] == -1) {
                if (purifier_top_r == -1) {
                    purifier_top_r = i;
                    purifier_bottom_r = i + 1;
                }
            }
        }
    }

    while (T--) {
        spread_dust();
        circulate_air();
    }

    int total_dust = 0;
    for (int i = 0; i < R; i++) {
        for (int j = 0; j < C; j++) {
            if (room[i][j] > 0) {
                total_dust += room[i][j];
            }
        }
    }

    cout << total_dust << endl;

    return 0;
}

코드에 대한 설명과 새롭게 알게된 내용을 합쳐서 아래에 기술해보겠습니다.

📚 새롭게 알게된 내용

1. 동시성 처리

만약, 원래의 room 배열을 순회하면서, 확산된 미세먼지를 바로 room 배열에 더해버리면 어떻게 되었을까요?

(0,0) 칸의 미세먼지가 (0,1)로 확산 -> room[0][1] 값이 증가하므로
나중에 (0,1) 칸을 계산할 때, 방금 확산받은 양까지 포함해서 또 확산시키는 문제가 발생합니다!

이것은 동시에 확산되는 것이 아니라서, 별도의 임시 배열을 사용해서 이 문제를 해결합니다.

그래서 제 코드에서는
diffused_dust 라는, 모든 값이 0으로 채워진 임시 2차원 배열을 만듭니다.
이 배열은 이번 1초 동안 각 칸에 '새로 추가될' 미세먼지의 양만 기록하는 용도입니다.
그리고 이중 for문을 이용해서 room 배열을 훑어봅니다
room 배열을 다 훑었다면, 이제 diffused_dust에는 각 칸에 새로 추가될 먼지 양이 모두 기록되어있게 됩니다!
마지막으로, room 배열과 diffused_dust 배열을 합쳐주면 됩니다!

이렇게 하면, 1초 동안의 모든 확산이 다른 칸에 영향을 주지 않고 독립적으로 계산된 후, 한 번에 합쳐지므로 "동시에" 확산되는 효과를 낼 수 있습니다!

2. 역방향으로 데이터 옮기기

A -> B -> C -> D 순서로 미세먼지를 옮기고 싶다고 가정해보았을 때,
만약 B = A, C = B, D = C 순서로 코드를 짜면 B = A를 실행하는 순간, 원래 B에 있던 값이 사라집니다.
그래서, C = B를 할 때 잘못된 값(A의 값)이 C로 들어가게 됩니다.

이를 방지하기 위해서는 바람의 방향과 반대로 값을 옮겨야 하는데

1. 아래 -> 위: 왼쪽 맨 아래 칸부터 위로 올라가면서, 바로 아래 칸의 값을 현재 칸으로 복사...
2. 오른쪽 -> 왼쪽: 맨 위 오른쪽 칸부터 왼쪽으로 가면서, 바로 오른쪽 칸의 값을 현재 칸으로 복사...
3. 위 -> 아래: 오른쪽 맨 위 칸부터 아래로 내려오면서...
4. 왼쪽 -> 오른쪽: 공기청정기 오른쪽 칸부터 시작해서...

이렇게 바람의 역방향으로 값을 하나씩 덮어쓰면, 원래 값이 사라지기 전에 안전하게 다음 칸으로 옮길 수 있습니다.
마지막으로 공기청정기 바로 오른쪽 칸은 0으로 만들어주어야합니다!

복잡한 것 같지만 차근히 읽어보면 당연한 얘기들이긴 합니다 ㅎㅎ
내일 남은 PR 올릴게요!

[mj010504]

예전에 굉장히 시간써가면서 푼 문제라 기억이 나네요..
저도 풀면서 문제에선 동시에 일어나는 작업이지만 코드는 순서대로 짜야하기 때문에 임시로 배열을 만들어 사용했습니다. 또한 미세먼지를 방향대로 이동시키기 위해 각 경계값을 미리 변수에 지정해놓고 풀었네요. 예전에는 깔끔하게 짜는 실력이 부족해서 그런지 가독성이 좋진 않습니다. 동우님은 그 부분 신경써서 잘 푸신 것 같습니다.
수고하셨습니다!

미세먼지 안녕!

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

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


struct p{
  int x,y,cnt;
};

int main() {

    //freopen("input.txt", "rt", stdin);
     ios_base::sync_with_stdio(false);
    cin.tie(0);

   int n, m, t;
   cin >> n >> m >> t;

    queue<p> q;
    vector<vector<int>> v(n, vector<int> (m));
    pair<int, int> start, end;
    int sd = 0; // 0, 3, 2, 1
    int ed = 0; // 0, 1, 2, 3
   for(int i = 0; i < n; i++) {
    for(int j = 0; j < m; j++) {
        cin >> v[i][j];

        if(v[i][j] >= 5) q.push({i, j, v[i][j]});
        else if(v[i][j] == -1) {
            end = {i, j};
            start  = {i -1, j};
        } 
    }
   }
   for(int i = 0; i < t; i++) {
    vector<vector<int>> tv = v;
    
    while(!q.empty()) {
        p tp = q.front();
        q.pop();


            int temp = 0;
            for(int k = 0; k < 4; k++) {
                int xx = tp.x + dx[k];
                int yy = tp.y + dy[k];
                if(xx >= 0 && xx < n && yy >= 0 && yy < m  && v[xx][yy] >= 0) {
                    tv[xx][yy] += tp.cnt / 5;
                    temp++;
                }
            }

            tv[tp.x][tp.y] -= (tp.cnt / 5) * temp;
        
    }

    int ts = tv[0][0];
    int se = tv[start.first][m-1];
    int ee = tv[end.first][m-1];
    int bs = tv[n-1][0];

    for(int k = 0; k <= m - 1; k++) {
        tv[0][k] = tv[0][k + 1];
        tv[n-1][k] = tv[n-1][k + 1];
    } 

    for(int k = m -1; k >= 2; k--) {
        tv[start.first][k] = tv[start.first][k-1];
        tv[end.first][k] = tv[end.first][k-1];
    }

    tv[start.first][1] = 0;
    tv[end.first][1] = 0;

    for(int k= start.first -1; k >= 2; k--) {
        tv[k][0] = tv[k -1][0];
    } 

    tv[1][0] = ts;

    for(int k = 0; k <= start.first - 2; k++) {
        tv[k][m-1] = tv[k + 1][m - 1];
    }

    tv[start.first - 1][m-1] = se;

    for(int k = end.first + 1; k < n - 2; k++) {
        tv[k][0] = tv[k + 1][0];        
    } 

    tv[n -2][0] = bs;

    for(int k = n - 1; k > end.first + 1; k--) {
        tv[k][m-1] = tv[k -1][m-1];
    }

    tv[end.first + 1][m -1] = ee;
    
    for(int i = 0; i < n; i++) {
    for(int j = 0; j < m; j++) {
        if(tv[i][j] >= 5) q.push({i, j, tv[i][j]});
    }
    }

    v = tv;
    
   }

   int sum = 0;
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) {
            if(v[i][j] > 0) sum += v[i][j];
        }
     }

 cout << sum;

}

[hyeokbini]

처음 문제를 접하고 구현할 때 하면서도 이게 맞나..? 싶은 생각이 계속 들었던 문제네요.

청소하는 로직 clean()에서는 인덱싱을 잘 처리하는 기법을 배울 수 있고, 확산하는 로직 spread()에서는 동시성 처리를 위한 임시 배열 사용에 대해 리마인드할 수 있었습니다.

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

로봇 청소기 / c++

#include <bits/stdc++.h>

using namespace std;

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

void spread()
{
    vector<vector<int>> tmparr = arr;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (arr[i][j] == 0)
            {
                continue;
            }
            int curidxdust = arr[i][j];
            int spreaddustamount = curidxdust / 5;
            int spreaddir = 0;
            for (int t = 0; t < 4; t++)
            {
                int nx = dx[t] + i;
                int ny = dy[t] + j;
                if (nx >= n || ny >= m || nx < 0 || ny < 0)
                {
                    continue;
                }
                if (arr[nx][ny] == -1)
                {
                    continue;
                }
                tmparr[nx][ny] += spreaddustamount;
                spreaddir++;
            }
            tmparr[i][j] -= spreaddustamount * spreaddir;
        }
    }
    arr = tmparr;
    return;
}

void clean() // cleaneridx[0]은 위쪽 기준점, cleaneridx[1]은 아래쪽 기준점
{
    vector<vector<int>> tmparr = arr;
    for (int i = 1; i < m - 1; i++)
    {
        tmparr[cleaneridx[0]][i + 1] = arr[cleaneridx[0]][i];
    }
    tmparr[cleaneridx[0]][1] = 0;
    for (int i = cleaneridx[0]; i > 0; i--)
    {
        tmparr[i - 1][m - 1] = arr[i][m - 1];
    }
    for (int i = m - 1; i > 0; i--)
    {
        tmparr[0][i - 1] = arr[0][i];
    }
    for (int i = 0; i < cleaneridx[0] - 1; i++)
    {
        tmparr[i + 1][0] = arr[i][0];
    }

    for (int i = 1; i < m - 1; i++)
    {
        tmparr[cleaneridx[1]][i + 1] = arr[cleaneridx[1]][i];
    }
    tmparr[cleaneridx[1]][1] = 0;
    for (int i = cleaneridx[1]; i < n - 1; i++)
    {
        tmparr[i + 1][m - 1] = arr[i][m - 1];
    }
    for (int i = m - 1; i > 0; i--)
    {
        tmparr[n - 1][i - 1] = arr[n - 1][i];
    }
    for (int i = n - 1; i > cleaneridx[1] + 1; i--)
    {
        tmparr[i - 1][0] = arr[i][0];
    }
    arr = tmparr;
    return;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    //freopen("test.txt", "rt", stdin);
    cin >> n >> m >> t;
    arr.resize(n, vector<int>(m));
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            cin >> arr[i][j];
            if (arr[i][j] == -1)
            {
                cleaneridx.push_back(i);
            }
        }
    }
    while (t--)
    {
        spread();
        clean();
    }
    int ans = 0;
    for (auto i : arr)
    {
        for (auto j : i)
        {
            ans += j;
        }
    }
    cout << ans + 2;
    return 0;
}