BOJ 14502. 연구소

🙇‍♀️[Gold IV] 연구소 - 14502

문제 링크

성능 요약

메모리: 2024 KB, 시간: 40 ms

분류

너비 우선 탐색, 브루트포스 알고리즘, 그래프 이론, 그래프 탐색, 구현

제출 일자

2023년 12월 21일 23:49:24

문제 설명

인체에 치명적인 바이러스를 연구하던 연구소에서 바이러스가 유출되었다. 다행히 바이러스는 아직 퍼지지 않았고, 바이러스의 확산을 막기 위해서 연구소에 벽을 세우려고 한다.

연구소는 크기가 N×M인 직사각형으로 나타낼 수 있으며, 직사각형은 1×1 크기의 정사각형으로 나누어져 있다. 연구소는 빈 칸, 벽으로 이루어져 있으며, 벽은 칸 하나를 가득 차지한다.

일부 칸은 바이러스가 존재하며, 이 바이러스는 상하좌우로 인접한 빈 칸으로 모두 퍼져나갈 수 있다. 새로 세울 수 있는 벽의 개수는 3개이며, 꼭 3개를 세워야 한다.

예를 들어, 아래와 같이 연구소가 생긴 경우를 살펴보자.

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

이때, 0은 빈 칸, 1은 벽, 2는 바이러스가 있는 곳이다. 아무런 벽을 세우지 않는다면, 바이러스는 모든 빈 칸으로 퍼져나갈 수 있다.

2행 1열, 1행 2열, 4행 6열에 벽을 세운다면 지도의 모양은 아래와 같아지게 된다.

2 1 0 0 1 1 0
1 0 1 0 1 2 0
0 1 1 0 1 0 0
0 1 0 0 0 1 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

벽을 3개 세운 뒤, 바이러스가 퍼질 수 없는 곳을 안전 영역이라고 한다. 위의 지도에서 안전 영역의 크기는 27이다.

연구소의 지도가 주어졌을 때 얻을 수 있는 안전 영역 크기의 최댓값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 지도의 세로 크기 N과 가로 크기 M이 주어진다. (3 ≤ N, M ≤ 8)

둘째 줄부터 N개의 줄에 지도의 모양이 주어진다. 0은 빈 칸, 1은 벽, 2는 바이러스가 있는 위치이다. 2의 개수는 2보다 크거나 같고, 10보다 작거나 같은 자연수이다.

빈 칸의 개수는 3개 이상이다.

출력

첫째 줄에 얻을 수 있는 안전 영역의 최대 크기를 출력한다.

🚀풀이

로직의 순서는 다음과 같다.

1. 3개의 벽을 세운다.
2. 바이러스가 퍼진다.
3. 안전한 영역의 개수를 구한다.

구현을 하기 전 세팅부터한다.

// 0 : 빈 칸
// 1 : 벽
// 2 : 바이러스가 있는 위치
void setting()
{
	cin >> n >> m;
	board = vector<vector<int>>(n, vector<int>(m));

	for (int y = 0; y < n; ++y)
	{
		for (int x = 0; x < m; ++x)
		{
			cin >> board[y][x];
			if (board[y][x] == 0) // 벽을 세울수 있는 공간이란 뜻.
				wall.push_back({ y, x });
			if (board[y][x] == 2)
				virus.push_back({ y, x });
		}
	}
}

저렇게 세팅을 하고 이제 구현을 하는데 3개의 벽을 세우는 건 combination이다.
combination함수를 사용하지 않고 3개는 3중 for문으로 구현할 수 있다.

void solve()
{
	int res = 0;

	// 벽을 만든다.
	// 조합
	int wallSize = wall.size();
	for (int i = 0; i < wallSize; ++i)
	{
		for (int j = 0; j < i; ++j)
		{
			for (int k = 0; k < j; ++k)
			{
                // 3개의 벽을 세운다.
				board[wall[i].y][wall[i].x] = 1;
				board[wall[j].y][wall[j].x] = 1;
				board[wall[k].y][wall[k].x] = 1;

				// 여기서 바이러스를 퍼뜨리고 안전한 영역의 개수를 구한다.
				res = max(res, spread());

                // 다음 경우를 위하여 원상 복구 시킨다.
				board[wall[i].y][wall[i].x] = 0;
				board[wall[j].y][wall[j].x] = 0;
				board[wall[k].y][wall[k].x] = 0;
			}
		}
	}

	cout << res << '\n';
}

spread함수가 있는데, 여기서 바이러스가 퍼지는 로직을 구현한다.

int spread()
{
	int res = 0;
	memset(visited, 0, sizeof(visited));
	for (Pos pos : virus)
	{
		visited[pos.y][pos.x] = 1;
		dfs(pos.y, pos.x);
	}
	for (int y = 0; y < n; ++y)
		for (int x = 0; x < m; ++x)
			if (board[y][x] == 0 && visited[y][x] == 0)
				res++;

	return res;
}

spread를 할 때 마다 visited는 초기화 시켜야한다.
첫 번째 for문을 보면 virus 배열을 순회하면서 dfs를 시킨다.
여기서 퍼지는 로직이 된다.

그 로직이 끝나면 아래 이중for문에서 안전한 영역의 개수를 구한다.
board[y][x] == 0 뿐만 아니라 바이러스가 지나간 자리가 아니 곳인 visited[y][x] == 0역시 확인해 주어야한다.

dfs는 아래와 같다.

int dy[] = { -1, 0, 1, 0 };
int dx[] = { 0, 1, 0, -1 };
void dfs(int y, int x)
{
	for (int i = 0; i < 4; ++i)
	{
		int nextY = y + dy[i];
		int nextX = x + dx[i];
		if (nextY < 0 || nextX < 0 || nextY >= n || nextX >= m)
			continue;
		if (visited[nextY][nextX])
			continue;
		if (board[nextY][nextX]) // 벽인 경우
			continue;
		visited[nextY][nextX] = true;
		dfs(nextY, nextX);
	}
}

백준에서 memset을 그냥 사용하면 컴파일 에러가 발생한다.
컴파일 에러를 안나게 하려면 <memory>헤더를 추가하거나 <cstring>헤더를 추가해야한다.

🚀전체 코드

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include<iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <memory>

using namespace std;

struct Pos
{
	int y;
	int x;
};

int visited[10][10];
int n, m;
vector<vector<int>> board;
vector<Pos> wall;
vector<Pos> virus;

// 0 : 빈 칸
// 1 : 벽
// 2 : 바이러스가 있는 위치
void setting()
{
	cin >> n >> m;
	board = vector<vector<int>>(n, vector<int>(m));

	for (int y = 0; y < n; ++y)
	{
		for (int x = 0; x < m; ++x)
		{
			cin >> board[y][x];
			if (board[y][x] == 0)
				wall.push_back({ y, x });
			if (board[y][x] == 2)
				virus.push_back({ y, x });
		}
	}
}

// 퍼지는 함수

void print_board()
{
	for (int y = 0; y < n; ++y)
	{
		for (int x = 0; x < m; ++x)
		{
			cout << board[y][x] << " ";
		}
		cout << endl;
	}

	cout << endl;
}

int dy[] = { -1, 0, 1, 0 };
int dx[] = { 0, 1, 0, -1 };
void dfs(int y, int x)
{
	for (int i = 0; i < 4; ++i)
	{
		int nextY = y + dy[i];
		int nextX = x + dx[i];
		if (nextY < 0 || nextX < 0 || nextY >= n || nextX >= m)
			continue;
		if (visited[nextY][nextX])
			continue;
		if (board[nextY][nextX])
			continue;
		visited[nextY][nextX] = true;
		dfs(nextY, nextX);
	}
}

int spread()
{
	int res = 0;
	memset(visited, 0, sizeof(visited));
	for (Pos pos : virus)
	{
		visited[pos.y][pos.x] = 1;
		dfs(pos.y, pos.x);
	}
	for (int y = 0; y < n; ++y)
		for (int x = 0; x < m; ++x)
			if (board[y][x] == 0 && visited[y][x] == 0)
				res++;

	return res;
}

// 1. 벽을 3개 세운다
// 2. 바이러스가 퍼진다.
// 3. 안전한 영역의 개수를 구한다.
void solve()
{
	int res = 0;

	// 벽을 만든다.
	// 조합
	int wallSize = wall.size();
	for (int i = 0; i < wallSize; ++i)
	{
		for (int j = 0; j < i; ++j)
		{
			for (int k = 0; k < j; ++k)
			{
				board[wall[i].y][wall[i].x] = 1;
				board[wall[j].y][wall[j].x] = 1;
				board[wall[k].y][wall[k].x] = 1;

				//print_board();
				res = max(res, spread());

				board[wall[i].y][wall[i].x] = 0;
				board[wall[j].y][wall[j].x] = 0;
				board[wall[k].y][wall[k].x] = 0;
			}
		}
	}

	cout << res << '\n';
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	//freopen("input.txt", "rt", stdin);

	setting();
	solve();

	return 0;
}