24-flydongwoo

[flydongwoo]

🔗 문제 링크

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

✔️ 소요된 시간

40분

✨ 수도 코드

24주차도 시작해보도록 하겠습니다.
보통 BFS는 2차원 배열로 특정 칸을 방문했는지 체크해야 하지만, 이 문제에서는 그렇게 하면, 어떤 칸에 벽을 안 부수고 도착한 경우와 벽을 부수고 도착한 경우를 구분할 수 없습니다.
그러므로, '벽을 안 부수고 온 경로'는 앞으로 벽을 부술 기회가 남아있기 때문에 더 중요할 수 있는데, 이 기회를 무시하게 되는겁니다.

저는 이 문제를 풀기 위해서, 서로 다른 두 개의 맵이 겹쳐져있다고 생각했습니다.

• 0번 맵: 아직 벽을 부술 기회가 남아있는 플레이어가 탐험하는 맵
• 1번 맵: 벽을 부술 기회를 이미 써버린 플레이어가 탐험하는 맵

그리고 이 두 개의 맵을 동시에 탐험하는 것입니다. 3차원 배열로 말이죠.

• visited[r][c][0]: 0번 맵의 (r, c)칸을 방문했는지 기록
• visited[r][c][1]: 1번 맵의 (r, c)칸을 방문했는지 기록

이런 아이디어를 가지고 제 코드를 보시면 이해하실 것 입니다!

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

using namespace std;

int N, M;
vector<string> board;
bool visited[1001][1001][2];

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

int bfs() {
    queue<tuple<int, int, int, bool>> q;

    q.push({ 0, 0, 1, false });
    visited[0][0][0] = true;

    while (!q.empty()) {
        auto [r, c, dist, broken] = q.front();
        q.pop();

        if (r == N - 1 && c == M - 1) {
            return dist;
        }

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

            if (nr >= 0 && nr < N && nc >= 0 && nc < M) {
                if (board[nr][nc] == '0' && !visited[nr][nc][broken]) {
                    visited[nr][nc][broken] = true;
                    q.push({ nr, nc, dist + 1, broken });
                }
                else if (board[nr][nc] == '1' && !broken) {
                    visited[nr][nc][1] = true;
                    q.push({ nr, nc, dist + 1, true });
                }
            }
        }
    }

    return -1;
}

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

    cin >> N >> M;
    board.resize(N);
    for (int i = 0; i < N; i++) {
        cin >> board[i];
    }

    cout << bfs() << endl;

    return 0;
}

저는 이 문제를 풀기 위해서 tuple을 사용했는데요,

• int r, int c: 현재 탐험가의 위치 (row, column)
• int dist: 시작점부터 여기까지 온 거리
• bool broken: 벽을 부쉈는지 여부. false면 0번 맵, true면 1번 맵에 있다는 뜻

탐험을 시작하는데, 처음엔 벽을 부순 적이 없으니 0번 맵에서 시작합니다. 그래서 visited[0][0][0]에 방문했다고 도장을 찍습니다.

이제, while 루프 안에서 두 가지 이동 규칙이 있는데

1. 빈 공간('0')으로 이동할 때

• 가려는 곳이 빈 공간이면, 그냥 지금 있는 맵에서 그대로 이동합니다.
• 만약 내가 0번 맵에 있었다면(broken이 false), 다음 칸도 0번 맵으로 갑니다. 그래서 visited 배열도 [broken] 인덱스를 그대로 사용해서 체크합니다.

2. 벽('1')으로 이동할 때

• 벽을 부수는 건 오직 0번 맵에 있을 때만 가능합니다.
• 벽을 부수는 순간, 탐험가는 0번 맵에서 1번 맵으로 차원을 이동한다고 생각하면 됩니다.
• 그래서 방문 기록은 1번 맵에 해당하는 visited[nr][nc][1]에 남기고, 큐에 새로운 탐험 정보를 넣을 때도 broken 상태를 true로 바꿔주는겁니다.

이 과정을 목적지에 도착할 때까지 반복하는 겁니다.

📚 새롭게 알게된 내용

3차원 배열을 사용하는 경우가 있다는 것을 알게 되었고, tuple을 사용하면 코드가 간편해지고 편해진다는 것을 알게 되었음!

[mj010504]

저는 tuple 대신 제가 자주 사용하는 구조체를 사용했습니다! 추가적인 상태가 필요한 BFS 문제라서 좋은 연습이 된 것 같습니다.
수고하셨습니다!

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

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

bool visited[1001][1001][2];

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

int main() {

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

    int n, m; cin >> n >> m;
    vector<vector<int>> v(n, vector<int> (m));
    for(int i = 0; i < n; i++) {
        string a; cin >> a;
        for(int j = 0; j < m; j++) {
            int temp = a[j] - '0';
            v[i][j] = temp;
        }
    }

    int res = -1;
    queue<p> q; 
    q.push({0, 0, 1, false});
    visited[0][0][0] = true;

    while(!q.empty()) {
        auto tp = q.front(); q.pop();

        if(tp.x == n-1 && tp.y == m-1) {
            res = tp.cnt;
            break;
        }

        for(int d = 0; d < 4; d++) {
            int xx = tp.x + dx[d];
            int yy = tp.y + dy[d];

            if(xx >= 0 && xx < n && yy >= 0 && yy < m) {
                if(v[xx][yy] == 0 && !visited[xx][yy][tp.crashed]) {
                    visited[xx][yy][tp.crashed] = true;
                    q.push({xx, yy, tp.cnt + 1, tp.crashed});
                }

                 if(v[xx][yy] == 1 && !tp.crashed) {
                    visited[xx][yy][1] = true;
                    q.push({xx, yy, tp.cnt + 1, true});
                }
            }
        }
    }

    cout << res;
}