5-g0rnn

[g0rnn]

🔗 문제 링크

연구소

문제가 어떤 유형인지 숨기기 위해 문제의 이름만 작성하였습니다.

✔️ 소요된 시간

1h

✨ 수도 코드

1. 입력받으면서 바이러스인 칸을 큐에 넣는다.
  1-1. 동시에 바이러스인 칸의 개수와 빈 칸의 개수를 센다.
2. 벽을 3개 설치한다.
    2-1. 벽이 모두 설치되면 bfs를 통해 바이러스를 감염시킨다.
3. 적절한 값을 연산하여 안전한 구역의 갯수를 센다.

위의 수도코드는 코드의 전반적인 흐름입니다. 아마 너무 추상적인 내용이라 구현하는데엔 별 도움이 안될듯합니다.

학습을 위해 문제를 시도해보고 해설을 봐주세용!

이 문제는 bfs와 dfs, 백 트레킹을 사용한 문제입니다. 코드의 흐름에 맞게 dfs/백트래킹, bfs순으로 설명하겠습니다.

벽 설치하기

저는 여기서 막혀서 구글링했습니다. 백트래킹을 사용하여 벽을 설치하더군요.!

void dfs(int wall) {
	if (wall == 3) {
		bfs();
		return;
	}

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
			if (lab[i][j] == EMPTY) {
				lab[i][j] = WALL;
				dfs(wall + 1);
				lab[i][j] = EMPTY;
			}
		}
	}
}

이는 추상화하면 조금 더 이해하기 쉬워집니다.

dfs -> 바이러스 전염시키기 or 벽을 1개씩 설치하기

dfs는 위와 같이 두가지 일을 합니다. 이제 이렇게 함수를 정했으면 dfs라는 함수를 믿어야합니다.

for문 내부에서 dfs를 호출하는 이유는 벽을 1개씩 설치하기 때문입니다.

맨 위 if문에서는 벽을 모두 설치했기 때문에 바이러스를 전염시키기 위해 bfs라는 함수를 실행시킵니다.

바이러스 전염 시키기

이는 bfs로 쉽게 구현할 수 있습니다. 거의 모든 bfs는 큐를 사용한다는 사실을 기억한다면 bfs도 사실 어려운게 아닙니다.
입력을 받을 때 if (lab[i][j] == VIRUS) 로 검사하고 바이러스 칸을 큐에 넣습니다. (해당문제에서는 좌료값을 넣기 위해 pair를 사용했습니다.)

큐에 전처리(문제가 되는 것을 삽입!)가 된 후엔 while(!q.empty())를 통해 큐가 빌 때까지 검사합니다. 이게 국룰입니다.

반복문 내부에 처음 들어왔다면 방명록을 적어야합니다. 이게 무슨 말이냐면 큐에서 문제가 되는 것을 pop을 통해 제거한다는 것입니다. 큐에 값을 넣는 것는 탐색(검사)하고자 하는 항목을 넓게 전개하기 위함입니다. 따라서 반복문이 한번 실행된다면 해당 항목을 큐에서 제거해야겠죠? 😎 물론 마지막에 해도 됩니다.

아무튼 방명록을 작성하고 나면 각 방향에 맞게 검사해줍니다.

		for (int dir = 0; dir < 4; dir++) {
			int nx = x + offset[dir][0];
			int ny = y + offset[dir][1];
			if (canMove(tmp_lab, nx, ny)) {
				tmp_lab[ny][nx] = VISITED;
				tmpq.push(make_pair(nx, ny));
			}
		}

위 코드도 국룰입니다. 각 방향(dir은 방향을 뜻함)마다 이동할 수 있는지 검사하고 이동하면 됩니다.

📚 새롭게 알게된 내용

백트레킹을 복습할 수 있어서 좋았습니다.

저는 안전한 구역을 체크하기 위해 사칙연산을 사용하였는데 이중 for문을 활용하여 일일이 검사해도 됩니다!!
이 방법(중첩 for)이 명료해서 문제를 풀기 더 쉬울겁니다!!

[kangrae-jo]

저한테는 좀 어려운 문제였네요...
(본가 디버프로 2시간 이상 고민했습니다.)

2차원 배열 공간이 작게 제한되어 있다는 걸보고

빈 공간을 벽으로 3개 만들고 (<--브루트포스),
벽 3개를 추가한 2차원 배열을 탐색 해야겠다 (<--BFS)�
그리고 각 BFS에서는 temp값들을 써야겠다 라는 방법 까지는 생각해냈습니다.

근데 DFS로 벽 3개를 브루트포스 하는 것이 쉽게 떠오르지 않았네요.
균호님 코드 슬쩍 봤는데 슥 보자마자 '아!' 하며 이해해버렸습니다.

CPP CODE

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

#define EMPTY 0
#define WALL 1
#define VIRUS 2
#define VISITED 3

using namespace std;

int N, M;
int safeZone = 0, virusZone = 0, maxSafeZone = 0;
vector<vector<int>> lab;
queue<pair<int, int>> q;

int offset[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

bool isMoveable(vector<vector<int>> &tempLab, int x, int y) {
    return 0 <= x && x < M && 0 <= y && y < N && tempLab[y][x] == EMPTY;
}

void bfs() {
    int cntVirus = 0;
    vector<vector<int>> tempLab = lab;
    queue<pair<int, int>> tempQ = q;

    while (!tempQ.empty()) {
        int y = tempQ.front().first;
        int x = tempQ.front().second;
        tempQ.pop();
        cntVirus++;

        for (int dir = 0; dir < 4; dir++) {
            int y_ = y + offset[dir][0];
            int x_ = x + offset[dir][1];

            if (isMoveable(tempLab, x_, y_)) {
                tempLab[y_][x_] = VISITED;
                tempQ.push(make_pair(y_, x_));
            }
        }
    }
    maxSafeZone = max(maxSafeZone, safeZone - 3 - cntVirus + virusZone);
}

void dfs(int wall) {
    if (wall == 3) {
        bfs();
        return;
    }

    for (int y = 0; y < N; y++) {
        for (int x = 0; x < M; x++) {
            if (lab[y][x] == EMPTY) {
                lab[y][x] = WALL;
                dfs(wall + 1);
                lab[y][x] = EMPTY;
            }
        }
    }
}

int main() {
    // 1) input
    cin >> N >> M;

    int temp;
    lab = vector<vector<int>>(N, vector<int>(M));
    for (int y = 0; y < N; y++) {
        for (int x = 0; x < M; x++) {
            cin >> temp;
            lab[y][x] = temp;

            if (temp == VIRUS) {
                q.push(make_pair(y, x));
                virusZone++;
            }
            if (temp == EMPTY) safeZone++;
        }
    }

    // 2) solution
    dfs(0);

    cout << maxSafeZone;
}

[kangrae-jo]

여기가 핵심인 듯 하네요.
주석 설명이 친절해서 쉽게 이해할 수 있었습니다. 굿굿굿

[kangrae-jo]

TMI: 저는 이런 좌표문제 헷갈리지 않기 위해서 for문도 y, x로 두고 풉니다. 좋아요.

[kokeunho]

여기서 벽을 세우고 dfs를 돌리고 나서 벽을 다시 제거하는 이유를 혼자 생각해봤으면 이해하기 어려웠을 것 같은데 저번 미팅에서 설명을 잘 해주셔서 쉽게 이해할 수 있었습니다.
이번 PR도 수고 많으셨습니다~

[wnsmir]

BFS를 사용해 바이러스가 퍼질 수 있는 칸은 0 -> 2로, 퍼지지 않은 칸은 큐에 추가하는 virus함수,

바이러스가 퍼지고 난 위 안전한 영역의 개수를 계산하는 count함수,

빈 칸에서 벽을 3개 세울 수 있는 모든 조합을 찾아 각 조합에 대해 바이러스가 퍼진 뒤 안전영역의 크기를 계산하는 maxSafe함수

이렇게 3개를 만들어 풀어보았습니다.

from collections import deque

# 방향 정의 (상, 하, 좌, 우)
directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]

# 바이러스가 퍼지는 함수
def spread_virus(lab, N, M):
    visited = [[False] * M for _ in range(N)]
    queue = deque()
    
    # 바이러스 위치를 큐에 추가
    for i in range(N):
        for j in range(M):
            if lab[i][j] == 2:
                queue.append((i, j))
                visited[i][j] = True
    
    # BFS로 바이러스 퍼짐
    while queue:
        x, y = queue.popleft()
        
        for dx, dy in directions:
            nx, ny = x + dx, y + dy
            if 0 <= nx < N and 0 <= ny < M and not visited[nx][ny] and lab[nx][ny] == 0:
                visited[nx][ny] = True
                lab[nx][ny] = 2
                queue.append((nx, ny))

# 안전 영역 크기 계산
def count_safe_area(lab, N, M):
    safe_area = 0
    for i in range(N):
        for j in range(M):
            if lab[i][j] == 0:
                safe_area += 1
    return safe_area

# 벽 3개를 세운 경우의 안전 영역 크기 최대값 계산
def get_max_safe_area(lab, N, M):
    empty_spaces = []
    
    # 빈 공간 찾기
    for i in range(N):
        for j in range(M):
            if lab[i][j] == 0:
                empty_spaces.append((i, j))
    
    max_safe_area = 0
    
    # 벽 3개를 설치하는 경우의 모든 조합을 찾아서
    for i in range(len(empty_spaces)):
        for j in range(i + 1, len(empty_spaces)):
            for k in range(j + 1, len(empty_spaces)):
                # 벽 3개 설치
                new_lab = [row[:] for row in lab]  # 원본 lab을 복사
                new_lab[empty_spaces[i][0]][empty_spaces[i][1]] = 1
                new_lab[empty_spaces[j][0]][empty_spaces[j][1]] = 1
                new_lab[empty_spaces[k][0]][empty_spaces[k][1]] = 1
                
                # 바이러스 퍼짐
                spread_virus(new_lab, N, M)
                
                # 안전 영역 크기 계산
                safe_area = count_safe_area(new_lab, N, M)
                max_safe_area = max(max_safe_area, safe_area)
    
    return max_safe_area

# 입력 받기
N, M = map(int, input().split())
lab = [list(map(int, input().split())) for _ in range(N)]

# 결과 출력
print(get_max_safe_area(lab, N, M))

브루트포스로 각 경우마다 BFS로 안전영역의 크기를 계산하는 방식입니다.