[백준/c++] 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은 적이 있는 칸이다.

출력

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

구현해야할 조건

궁수의 위치는 완전 탐색으로 모든 조건에 맞게 대신 중복되지 않는 방법으로 구하면 됩니다. 이제 궁수의 범위에 맞춰서 공격당하는 위치를 선정해주면 되는데, 각 궁수 마다 위치를 구해서 sort해주면 됩니다. 거리가 D이하인 적중에서 가장 가까운 적, 그러한 적이 여럿 가장 왼쪽(x가 0에 가까울수록)!!! 구현해봅시다!

code

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

#define MAX 15
using namespace std;

int n,m,d;
int castle[MAX][MAX];
int copyCastle[MAX][MAX];

int main()
{
	cin >> n >> m >> d;
	
	vector<pair<int,int> > enemy;
	
	for(int i = 0; i < n; i++)
	{
		for(int j = 0; j < m; j++)
		{
			cin >> castle[i][j];
			
			if(castle[i][j] == 1)
			{
				enemy.push_back({i,j});
			}
		}
	}
	
	vector<int> archer;
	
	for(int i = 0; i < m-3; i++)
		archer.push_back(0);
	
	for(int i = 0; i < 3; i++)
		archer.push_back(1);
	
	
	int answer = 0;
	
	do{
		
		int cnt = 0;
		
		vector<pair<int,int> > temp = enemy;
		
		vector<int> v;
		
		for(int i = 0; i < archer.size(); i++)
		{
			if(archer[i] == 1)
				v.push_back(i);
		}
		
		while(!temp.empty())
		{
			int y = n;
			vector<int> target;
			
			for(int i = 0; i < v.size(); i++)
			{
				int x = v[i];
				int idx = 0;
				
				int enemyX = temp[0].second;
				int dist = abs(y - temp[0].first) + abs(x - temp[0].second);
				for(int j = 1; j < temp.size(); j++)
				{
					int tempDist = abs(y - temp[j].first) + abs(x - temp[j].second);
					
					if(dist > tempDist)
					{
						enemyX = temp[j].second;
						dist = tempDist;
						idx = j;
					}
					else if(dist == tempDist && enemyX > temp[j].second)
					{
						enemyX = temp[j].second;
						idx = j;
					}
				}
				
				if(dist <= d)
				{
					target.push_back(idx);
				}
			}
			
			target.erase(unique(target.begin(),target.end()), target.end());
			sort(target.begin(),target.end());
			int kill = 0;
			
			for(int i = 0; i < target.size(); i++)
			{
				temp.erase(temp.begin() + (target[i] - kill++));
				cnt++;
			}
			
			if(temp.empty())
			{
				break;
			}
			
			vector<pair<int,int> > copyTemp;
			
			for(int i = 0; i < temp.size(); i++)
			{
				if(temp[i].first < n - 1)
				{
					copyTemp.push_back({temp[i].first +1, temp[i].second});
				}
			}
			
			temp = copyTemp;
		}
		
		answer = max(answer,cnt);
		
		
	}while(next_permutation(archer.begin(),archer.end()));
	
	cout << answer << "\n";
	
	return 0;
	
}