11-suhyun113

[suhyun113]

🔗 문제 링크

🧪연구소🧪

✔️ 소요된 시간

약 2시간...? 더 걸린 것 같은데,,,

✨ 수도 코드

💙1. 문제 선정 이유💙
구현 문제를 많이 하시길래 저도 구현 문제를 한 번 풀어보고려싶어서 관련 문제를 찾아봤는데,,,하다 보니 BFS로 풀게 되었네요...
문제를 처음 보고나서 그냥 빈 칸으로 되어 있으면 바이러스가 퍼지는구나 생각했고, 벽이 있으면 그 뒤로는 퍼지지 않는 것으로 이해했습니다. 어느 정도 맞게 이해한 것 같지만...이것 만으로는 문제를 어떻게 구현할지 로직을 짜보는 과정에서 어려움이 있었습니다. 예시를 보고 이해하려는데, 안전 영역의 최대 크기가 내가 생각한 것과 다르게 나왔습니다. 그래서 문제를 다시 이해해보고자 시간을 많이 쓴 것 같아요.
그 후 생각한 것이, 벽을 3개씩 무조건 세워야 하기 때문에, 구할 수 있는 모든 경우를 벽을 두고 나서 바이러스를 벽 안쪽으로 퍼지도록 한 후, 빈 칸을 모두 세서 안전 영역을 구해 그 크기의 최댓값을 구하면 될 것 이라고 생각하고 문제를 풀었습니다.
먼가 객체지향 수업때 배웠던 문제들 중 오목, 오셀로 등과 유사한 느낌을 받았는데...기억을 떠올리면서 한번 풀어봤습니다!

2. 💙문제 설명💙
1) 🦦설명🦦
바이러스의 확산을 막기 위해 연구소에 벽을 세우고자 함
NxM 크기의 직사각형인 연구소는 빈 칸, 벽으로 이루어져있음

일부 칸 바이러스 존재(상하좌우 인접한 빈 칸으로 퍼짐)
새로운 벽의 개수 : 3개(꼭 다 세워야 함)

=> 벽 3개 세운 뒤, 바이러스 퍼질 수 없는 곳을 안전 영역이라 할 때, 안전 영역의 최대 크기는??

2) 🦦조건🦦

연구소의 크기 : NxM 인 직사각형
직사각형 : 1x1 크기의 정사각형으로 나뉨
연구소 : 빈 칸, 벽(한 칸 가득 채워짐), 바이러스로 이뤄짐

빈 칸 : 0
벽 : 1
바이러스 : 2
=> 벽 없으면 바이러스 모든 빈 칸으로 퍼지게 됨

3. 💙문제 풀이 방법💙

1. N, M 값 받아오기
2. NxM 크기의 지도 생성하기
3. 빈 칸에 벽 세우기(0을 1로 바꾸기) : 총 3개의 벽 => 3중 for문
4. 각 경우에 따라 벽이 없는 빈 칸이면서, 바이러스와 인접한 빈 칸 존재하면, 그 빈 칸을 바이러스로 바꾸기(0을 2로 바꾸기) => BFS
5. 바이러스 퍼진 후, 남은 빈 칸의 개수(안전 영역) 세기(0의 개수)

4. 💙풀이 확인 코드 추가💙
1) 🦦맵 출력 함수 구현🦦

// 맵 출력 함수
void print_map(const vector<vector<int>>& map) {
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < M; j++) {
			cout << map[i][j] << " ";
		}
		cout << endl;
	}
	cout << endl;
}

2) 🦦메인 함수 코드 추가🦦

int main() {
	cin >> N >> M;
	initial_map.resize(N, vector<int>(M));

	for (int i = 0; i < N; i++) {
		for (int j = 0; j < M; j++) {
			cin >> initial_map[i][j];
			if (initial_map[i][j] == BLANK) {
				blank_map.push_back({ i, j }); // 빈 칸 지도 생성
			}
		}
	}

	vector<vector<pair<int, int>>> wall_combinations = building_walls(); // 빈 칸에 벽 세우기
	int max_safe_area = 0; // 안전 영역의 최대 크기
	vector<vector<int>> best_virus_map; // 바이러스 퍼진 후 지도 저장

	for (const auto& walls : wall_combinations) { // 벽 3개를 세운 여러 조합 반복
		// 초기 맵 복사해서 그 맵에 벽 3개 세우는 여러 조합 중 한 경우 적용
		vector<vector<int>> map_copy = initial_map;
		for (const auto& wall : walls) { // 한 경우에서 세운 벽 3개의 각각 위치에 벽 세우기
			map_copy[wall.first][wall.second] = WALL; // 벽 세우기
		}

		bfs(map_copy); // 바이러스 주변 칸 빈 칸이라면 바이러스 번짐

		int safe_area = calculate_safe_area(map_copy); // 안전영역 크기 계산
		if (safe_area > max_safe_area) {
			max_safe_area = safe_area;
			best_virus_map = map_copy;
		}
	}

	cout << "벽을 세운 뒤, 바이러스가 퍼진 뒤의 지도" << endl;
	print_map(best_virus_map);
	cout << max_safe_area << endl;
	return 0;
}

바이러스가 퍼진 후의 여러 지도 모습 중 최적의 지도를 저장하는 지도를 정의한 후, 안전 영역의 크기가 최대일 때의 지도를 구하여 그 지도를 출력하면, 안전 영역의 크기를 직접 구할 수 있습니다. 벽을 세운 뒤, 바이러스가 퍼진 뒤의 지도를 확인하여 안전 영역이 잘 구해지고 있는지 확인할 수 있었습니다.
문제에서 연구소의 모습이

2 0 0 0 1 1 0
0 0 1 0 1 2 0
0 1 1 0 1 0 0
0 1 0 0 0 0 0
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 1 0 0 0 0 0

이러할 때, 벽을 세운 뒤 바이러스가 퍼진 뒤의 연구소 모습을

2 1 0 0 1 1 2
1 0 1 0 1 2 2
0 1 1 0 1 2 2
0 1 0 0 0 1 2
0 0 0 0 0 1 1
0 1 0 0 0 0 0
0 1 0 0 0 0 0

라고 하였습니다. 실제로 이렇게 구해지고 있는지 확인하기 위해 위의 코드를 추가하면,

위의 사진처럼 잘 구해지는 것을 확인할 수 있습니다!

5. 💙최종 코드💙

🦦최종 코드 확인🦦

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

// 메크로 설정
#define BLANK 0
#define WALL 1
#define VIRUS 2

int N, M; // 지도의 세로 크기, 가로 크기
vector<vector<int>> initial_map; // 초기 지도
vector<pair<int, int>> blank_map; // 빈 칸
int directions[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} }; // 방향

// 가능한 모든 벽 세우기 조합 구하기
vector<vector<pair<int, int>>> building_walls() {
	vector<vector<pair<int, int>>> combinations;
	int size = blank_map.size(); // 빈 칸 크기
	for (int i = 0; i < size; i++) {
		for (int j = i + 1; j < size; j++) {
			for (int k = j + 1; k < size; k++) {
				// 빈 칸에 벽 3개 세우기
				combinations.push_back({blank_map[i], blank_map[j], blank_map[k]});
			}
		}
	}
	return combinations;
}

// 너비 우선 탐색(바이러스인 칸 큐에 저장 후, 
// 바이러스 칸 주변 칸이 바이러스 아닌 빈 칸이라면,
// 주변 칸을 바이러스로 바꾸기)
void bfs(vector<vector<int>>& map_copy) {
	queue<pair<int, int>> q;
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < M; j++) {
			if (map_copy[i][j] == VIRUS) {
				q.push({i, j});
			}
		}
	}
	// 바이러스인 칸이 아니고 빈 칸이라면,
	while (!q.empty()) {
		int x = q.front().first;
		int y = q.front().second;
		q.pop();
		for (int d = 0; d < 4; d++) { // 방향 탐색
			int nx = x + directions[d][0];
			int ny = y + directions[d][1];
			if (nx >= 0 && nx < N && ny >= 0 && ny < M && map_copy[nx][ny] == 0) {
				map_copy[nx][ny] = VIRUS; // 빈 칸을 바이러스로 바꾸기
				q.push({nx, ny});
			}
		}
	}
}

// 안전 영역 크기 계산 함수
int calculate_safe_area(vector<vector<int>>& map_copy) {
	int safe_area = 0;
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < M; j++) {
			if (map_copy[i][j] == BLANK) { // 빈 칸의 개수
				safe_area++;
			}
		}
	}
	return safe_area;
}

int main() {
	cin >> N >> M;
	initial_map.resize(N, vector<int>(M));

	for (int i = 0; i < N; i++) {
		for (int j = 0; j < M; j++) {
			cin >> initial_map[i][j];
			if (initial_map[i][j] == BLANK) {
				blank_map.push_back({ i, j }); // 빈 칸 지도 생성
			}
		}
	}

	vector<vector<pair<int, int>>> wall_combinations = building_walls(); // 빈 칸에 벽 세우기
	int max_safe_area = 0; // 안전 영역의 최대 크기

	for (const auto& walls : wall_combinations) { // 벽 3개를 세운 여러 조합 반복
		// 초기 맵 복사해서 그 맵에 벽 3개 세우는 여러 조합 중 한 경우 적용
		vector<vector<int>> map_copy = initial_map;
		for (const auto& wall : walls) { // 한 경우에서 세운 벽 3개의 각각 위치에 벽 세우기
			map_copy[wall.first][wall.second] = WALL; // 벽 세우기
		}

		bfs(map_copy); // 바이러스 주변 칸 빈 칸이라면 바이러스 번짐

		int safe_area = calculate_safe_area(map_copy); // 안전영역 크기 계산
		max_safe_area = max(max_safe_area, safe_area);
	}

	cout << max_safe_area << endl;
	return 0;
}

📚 새롭게 알게된 내용

BFS를 이산수학 시간에 배워서 너비 우선 탐색의 원리를 알고는 있었지만,,, 알고리즘 문제에 직접 적용해 본 것은 처음이었습니다.
bfs 함수를 구현하면서, 큐 자료구조를 사용했습니다. 탐색 지점을 정한 후, 시작 점에서부터 같은 레벨의 모든 지점을 탐색한 후, 그 다음 인접 지점을 탐색하도록 하여 조건을 만족할 때만 큐에 추가하도록 하였습니다. BFS를 이용하여 좀 더 효율적으로 그래프를 탐색할 수 있었습니다.
vector에서 resize는 처음 사용해 보았는데, 이를 통해 initial_map 벡터의 크기를 N으로 설정하고, 각 요소는 크기가 M인 벡터로 초기화 할 수 있었습니다. 2차원 벡터를 만드는 새로운 방법을 알게되었습니다.
또한 queue를 이용하면서, 바이러스인 칸들을 차례로 참조하여 그 칸에서 인접한 칸들이 빈 칸인지 확인하면서 방향을 탐색해 조건을 충족하면 그 칸도 바이러스 칸으로 만들고자 하였습니다. 따라서 매 반복마다 바뀌는 큐의 첫 번째 요소에 접근하고자 하였는데, 그 때 큐의 첫 번째 요소 값을 반환해주는 것이 front라는 것을 알게되었습니다.

[pu2rile]

구현 문제... 쉽고 재미있는 것만 있는 줄 알았는데... 제 오만과 편견이었군요...
수현 님은 bfs로 푸셨네요! 벽을 세우는 조합을 combinations 함수를 통해 미리 생성하셨는데, 여기서 벽을 세울 수 있는 모든 조합을 재귀적으로 시도하는 방식인 백트래킹 알고리즘을 사용하면 벽을 세울 수 있는 모든 조합을 탐색해 최적해를 찾고, 불필요한 경로를 배제해 계산 시간을 줄일 수 있습니다! 이번 pr도 수고하셨어요 ㅎ.ㅎ

[oesnuj]

저도 풀어보고 리뷰하려고 하다보니 너무 늦게 리뷰달았네요. 이제부터 좀 더 빠르게 와보겠습니다.
구현할때 바이러스가 퍼진 이후의 맵을 출력하면서 푸신것 같은데, 이런 디버깅 방법 너무 좋습니다.
저도 이런 구현문제 풀때 디버깅하면서 풀어야 실수가 적더라구요😄

저는

1. 모든 경우로 벽 3개 세우기
2. 바이러스 퍼트리고 안전영역 구하기 -> 최댓값이면 갱신
3. 세운 벽 3개 복구하기
   를 중점으로 해결했습니다.

저는 재귀를 사용한 DFS(깊이우선탐색)를 사용했는데 이 부분에서 조금 다르네요!
또 수현님은 기존 맵을 복사하는 방식으로 처리하셨는데, 저는 기존 맵에서 벽을 3개 세우고 안전영역을 계산한 이후 다시 세운 벽을 지우는 방식을 사용했습니다.

#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>

using namespace std;

const int WAYS = 4;
const int WAY[4][2] = { { -1, 0 },
                        { 1, 0 },
                        { 0, -1 },
                        { 0, 1 }
};

int map[8][8], visited[8][8], N, M, safeArea;
vector<pair<int, int>> blanks, virus;

void dfs(int y, int x) {
    for (int i = 0; i < WAYS; i++) {
        int ny = y + WAY[i][0];
        int nx = x + WAY[i][1];
        if (ny < 0 || nx < 0 || ny >= N || nx >= M) continue;
        if (visited[ny][nx] == 1 || map[ny][nx] == 1) continue;
        visited[ny][nx] = 1;
        dfs(ny, nx);
    }
}

int Spread() {
    memset(visited, 0, sizeof(visited));
    for (pair<int, int> a : virus) {
        visited[a.first][a.second] = 1;
        dfs(a.first, a.second);
    }
    int cnt = 0;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            if (map[i][j] == 0 && visited[i][j] == 0) cnt++;
        }
    }
    return cnt;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> N >> M;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            cin >> map[i][j];
            if (map[i][j] == 0) blanks.push_back({ i, j });
            if (map[i][j] == 2) virus.push_back({ i, j });
        }
    }
    //1. 벽 3개 세우기
    int l = blanks.size();
    for (int i = 0; i < l; i++) {
        for (int j = 0; j < i; j++) {
            for (int k = 0; k < j; k++) {
                map[blanks[i].first][blanks[i].second] = 1;
                map[blanks[j].first][blanks[j].second] = 1;
                map[blanks[k].first][blanks[k].second] = 1;

                //2. 바이러스 확산시키고 안전영역을 계산
                safeArea = max(safeArea, Spread());

                //3. 벽 원상복구
                map[blanks[i].first][blanks[i].second] = 0;
                map[blanks[j].first][blanks[j].second] = 0;
                map[blanks[k].first][blanks[k].second] = 0;
            }
        }
    }
    cout << safeArea << "\n";
}