[C/C++] 백준 - 17135번 (캐슬 디펜스)

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

17135번: 캐슬 디펜스

문제

캐슬 디펜스는 성을 향해 몰려오는 적을 잡는 턴 방식의 게임이다. 게임이 진행되는 곳은 크기가 N×M인 격자판으로 나타낼 수 있다. 격자판은 1×1 크기의 칸으로 나누어져 있고, 각 칸에 포함된 적의 수는 최대 하나이다. 격자판의 N번행의 바로 아래(N+1번 행)의 모든 칸에는 성이 있다.

성을 적에게서 지키기 위해 궁수 3명을 배치하려고 한다. 궁수는 성이 있는 칸에 배치할 수 있고, 하나의 칸에는 최대 1명의 궁수만 있을 수 있다. 각각의 턴마다 궁수는 적 하나를 공격할 수 있고, 모든 궁수는 동시에 공격한다. 궁수가 공격하는 적은 거리가 D이하인 적 중에서 가장 가까운 적이고, 그러한 적이 여럿일 경우에는 가장 왼쪽에 있는 적을 공격한다. 같은 적이 여러 궁수에게 공격당할 수 있다. 공격받은 적은 게임에서 제외된다. 궁수의 공격이 끝나면, 적이 이동한다. 적은 아래로 한 칸 이동하며, 성이 있는 칸으로 이동한 경우에는 게임에서 제외된다. 모든 적이 격자판에서 제외되면 게임이 끝난다. 

게임 설명에서 보다시피 궁수를 배치한 이후의 게임 진행은 정해져있다. 따라서, 이 게임은 궁수의 위치가 중요하다. 격자판의 상태가 주어졌을 때, 궁수의 공격으로 제거할 수 있는 적의 최대 수를 계산해보자.

격자판의 두 위치 (r1, c1), (r2, c2)의 거리는 |r1-r2| + |c1-c2|이다.

입력

첫째 줄에 격자판 행의 수 N, 열의 수 M, 궁수의 공격 거리 제한 D가 주어진다. 둘째 줄부터 N개의 줄에는 격자판의 상태가 주어진다. 0은 빈 칸, 1은 적이 있는 칸이다.

출력

첫째 줄에 궁수의 공격으로 제거할 수 있는 적의 최대 수를 출력한다.

제한

• 3 ≤ N, M ≤ 15

조합을 이용하여 위치를 선정하고 그 위치에서 우선순위에 맞는 적을 찾은 후 없애면서

진행과정을 이어나가면 되는 하라는대로 하면 되는 간단한 문제.

 

딱히 중요하다고 생각되는 알고리즘은 없었던 문제이다.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;

struct node {
	int x;
	int y;
};

int N, M, D, cnt, ans, enemy_cnt, out_enemy_cnt;
int adj[16][16];
int copy_adj[16][16];
int visited[16][16];

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

struct node hero[17];
bool checked[17];

vector<pair<pair<int, int>, int>> len[3];

bool cmp(pair<pair<int,int>,int> a, pair<pair<int,int>, int> b) {
	if (a.second == b.second) {
		return a.first.second < b.first.second;
	}
	else {
		return a.second < b.second;
	}
}

void input() {
	cin >> N >> M >> D;
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= M; j++) {
			cin >> copy_adj[i][j];
			if (copy_adj[i][j] == 1) {
				enemy_cnt++;
			}
		}
	}
}

void copy() {
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= M; j++) {
			adj[i][j] = copy_adj[i][j];
		}
	}
}

void bfs(int idx,int start_x, int start_y) {
	memset(visited, 0, sizeof(visited));
	queue<pair<int, int>> q;
	q.push(make_pair(start_x, start_y));
	visited[start_x][start_y] = 1;
	while (!q.empty()) {
		int cur_x = q.front().first;
		int cur_y = q.front().second;
		q.pop();

		int nx, ny;
		for (int i = 0; i < 4; i++) {
			nx = cur_x + dx[i];
			ny = cur_y + dy[i];
			if (nx < 1 || ny < 1 || nx > N || ny > M) continue;
			if (!visited[nx][ny]) {
				if (!adj[nx][ny]) {
					q.push({ nx,ny });
					visited[nx][ny] = visited[cur_x][cur_y] + 1;
				}
				else if (adj[nx][ny] == 1) {
					q.push({ nx, ny });
					visited[nx][ny] = visited[cur_x][cur_y] + 1;
					if (visited[nx][ny] - 1 <= D) {
						len[idx].push_back(make_pair(make_pair(nx, ny), visited[nx][ny]-1));
					}
				}
			}
		}
	}
}

void Attack() {
	for (int i = 0; i < 3; i++) {
		if (!len[i].empty()) {
			sort(len[i].begin(), len[i].end(), cmp); 
			int x = len[i].front().first.first;
			int y = len[i].front().first.second;
			len[i].clear();

			if (adj[x][y] != 0) {
				adj[x][y] = 0;
				cnt++;
			}
		}
	}
}

void Down_Enemy() {
	for (int i = 1; i <= M; i++) {
		if (adj[N][i] == 1) {
			out_enemy_cnt++;
		}
	}
	for (int i = N; i >= 2; i--) {
		for (int j = 1; j <= M; j++) {
			adj[i][j] = adj[i - 1][j];
		}
	}
	for (int i = 1; i <= M; i++) {
		adj[1][i] = 0;
	}
}

void func(int depth, int start) {
	if (depth == 3) {
		copy();
		cnt = 0, out_enemy_cnt = 0;
		while (1) {
			if (cnt + out_enemy_cnt == enemy_cnt) break;
			for (int i = 0; i < 3; i++) {
				bfs(i, hero[i].x, hero[i].y);
			}
			Attack();
			Down_Enemy();
		}
		ans = max(cnt, ans);
		return;
	}

	for (int i = start; i <= M; i++) {
		if (!checked[i]) {
			checked[i] = true;
			hero[depth].x = N + 1;
			hero[depth].y = i;
			func(depth + 1, i + 1);
			checked[i] = false;
		}
	}
}

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

	input();
	func(0, 1);
	cout << ans << '\n';

	return 0;
}