[백준 17135] 캐슬 디펜스(Java)

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
• 1 ≤ D ≤ 10

풀이 설명

1. 맵 전체의 크기 행N, 열M, 최대 공격거리 D를 입력받고, NxM 크기의 배열 map의 내용을 입력받는다.(0과 1 : 1은 적)

2. 궁수가 0~M-1 인덱스 중 3군데에 위치하므로, 조합을 사용하여 궁수의 위치 조합을 구하고, 각 조합에서의 제거 가능한 적의 수를 구한다.

3. 각 조합마다 원래의 map 배열에서 연산을 해야하므로, copyMap이라는 map을 복사할 배열을 생성하고, 매 조합이 완성될 때마다 map을 복사한다.

4. 조합 combination 함수에서 각 조합이 완성될 때마다 다음을 수행한다.

  4-1. map을 복사한 copyMap 준비

  4-2. 제거 가능한 적의 수를 저장할 변수 count 준비

  4-3. 적이 한 행씩 앞으로 가는 경우를 나타내는 변수 turn 준비(0~N-1)

        (내가 짠 코드에서는 적을 한 행씩 앞으로 옮기는 것보다 마지막 행 다음에 있는 성(궁수들)을 앞으로 옮기는 것이          더 간단하다고 판단하여, 성(궁수들)을 옮겼다.)

  4-4. 제거할 적의 위치를 저장할 큐 q 준비

5. turn이 N보다 작으면 반복

  5-1. 완성된 하나의 조합 temp의 각 궁수들마다 반복(k)

    5-1-1. 궁수의 행 위치는 N-turn, 열 위치는 temp[k]가 된다. (turn이 증가하면서 궁수들의 행 위치도 한 칸씩 전진)

    5-1-2. 각 궁수가 공격할 적까지의 거리, 그 적의 위치를 저장할 변수 min, minX, minY 선언

6. copyMap의 행과 각 행의 열 반복(i, j)

  6-1. copyMap[i][j]가 1이면(적이면) (i, j)와 현재 궁수의 위치 (N-turn, temp[k])의 거리 계산

  6-2. 거리가 최대 공격 거리 D 이하라면,

    6-2-1. min보다 작다면 min, minX, minY 모두 현재 적 정보로 갱신

    6-2-2. min과 같다면 minY와 현재 적의 열 인덱스값을 비교하여 더 작은 적으로 갱신(더 작은게 더 왼쪽이다.)

7. 6번이 끝나면(모든 맵의 칸을 다 조사했다면)

  7-1. 구한 제거할 적의 위치 minX, minY가 -1이 아니라면 큐에 삽입(제거할 적이 없을 땐 -1일 수 있음 -> 스킵)

8. 5-1이 끝나면(한 조합의 모든 궁수들을 다 확인했다면)

  8-1. q가 빌 때까지 계속 x,y좌표를 꺼내어 copyMap의 해당 내용을 0으로 바꾸고 count값 1 증가

        (여러 궁수가 하나의 적을 제거할 수 있으므로 중복된 x,y값이 있을 수 있음 -> 상관 없음)

  8-2. turn값 1 증가

9. 5번이 끝나면(모든 턴이 끝나면) maxVal과 비교하여 더 큰값으로 갱신

 

Java 코드

package com.ssafy;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;

public class Main_17135_캐슬디펜스 {
	
	static int[] soldier;
	static int maxVal;
	
	static int N;
	static int M;
	static int D;
	static int[][] map;
	static int[][] copyMap;

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());
		D = Integer.parseInt(st.nextToken());
		
		soldier = new int[M];
		for(int i=0; i<M; i++)
			soldier[i] = i;
		
		map = new int[N][M];
		copyMap = new int[N][M];
		for(int i=0; i<N; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j=0; j<M; j++) {
				map[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		
		int[] temp = new int[3];
		combination(0, 0, temp);
		System.out.println(maxVal);
	}
	
	public static void combination(int current, int start, int[] temp) {
		if(current == 3) {
			for(int i=0; i<N; i++)
				copyMap[i] = Arrays.copyOf(map[i], M);
			int count = 0;
			int turn = 0;
			Queue<Integer> q = new LinkedList<>();
			
			while(turn < N) {
				//////하나의 턴//////
				for(int k=0; k<3; k++) {
					//다음 턴으로 넘어갈 때마다 각 궁수들의 행을 한 칸 앞으로!(map 전체(적의 위치)를 한 칸씩 앞으로 땡기는 것보다 간단하기 때문)
					int x = N-turn;
					int y = temp[k];
					
					int min = Integer.MAX_VALUE;
					int minX = -1;
					int minY = -1;
					///각 궁수마다 가장 가까운 적을 찾는다.///
					for(int i=N-1-turn; i>=0; i--) { //행은 맨 아래(궁의 바로 앞)부터 탐색
						for(int j=0; j<M; j++) {
							if(copyMap[i][j] == 1) {
								int d = Math.abs(i-x) + Math.abs(j-y);
								if(d <= D) { //만약 적과 현재 궁수(temp[k]) 거리가 D 이하라면!!!
									if(d < min) { //거리가 min보다 작다면 갱신
										min = d;
										minX = i;
										minY = j;
									}else if(d == min) { //거리가 같을땐 더 왼쪽에 있는 적 위치로 갱신
										if(minY > j) {
											minX = i;
											minY = j;
										}
									}
								}
							} //if - copyMap[i][j] == 1
						} //for - j
					} //for - i
					
					//구한 temp[k]가 죽일 적의 위치를 큐에 삽입 - 죽일 적이 없어서 초기값인 (-1,-1)이라면 제외
					if(minX != -1 && minY != -1) {
						q.offer(minX);
						q.offer(minY);
					}
				} //for - k(궁수 3명 탐색)
				
				while(!q.isEmpty()) {
					int x = q.poll();
					int y = q.poll();
					if(copyMap[x][y] == 1) {
						copyMap[x][y] = 0;
						count++;
					}
				}
				//////하나의 턴 끝//////
				turn++;
			}
			
			if(maxVal < count) maxVal = count;
			return;
		}
		for(int i=start; i<soldier.length; i++) {
			temp[current] = soldier[i];
			combination(current+1, i+1, temp);
		}
	}
}