백준 - 캐슬 디펜스 (17135)

1. 문제

문제 링크

설명

캐슬 디펜스는 성을 향해 몰려오는 적을 잡는 턴 방식의 게임이다. 게임이 진행되는 곳은 크기가 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

2. 풀이

정말 전형적인 삼성 기출 문제 아닌가 싶습니다.
DFS로 궁수를 배치하는 모든 경우의 수를 만들고
시뮬레이션을 진행해서 제거할 수 있는 적의 최대 수를 만들면 됩니다.

계획1 - 궁수를 배치하는 모든 경우의 수를 만듭니다.

// B = 격자판
for (i = s; i < M; i++) {
	B[N][i] = 2;
	ret = Math.max(ret, max(depth + 1, i + 1));
	B[N][i] = 0;
}

앞서 질리도록 얘기했듯이 재귀 함수로 startIndex를 넘겨줘서 탐색시키면
모든 경우의 수를 만들 수 있습니다.
자세한 내용은 치킨 배달 << 이 포스팅으로 확인해주세요.

계획2 - 적을 제거하는 시뮬레이션을 구현합니다.

int i, j, k, l, cnt = 0;

// 시뮬레이션 격자판 복사
for (i = 0; i <= N; i++)
	for (j = 0; j < M; j++)
		test[i][j] = B[i][j];

// 공격 당한 적의 좌표를 담을 큐
Queue<int[]> q = new LinkedList<>();

// 행번만큼 진행
for (i = 0 ; i < N; i++) {
	// 궁수 공격
	for (j = 0; j < M; j++) {
		if (test[N][j] == 0) continue;
		
		int minDist = D, y = N, x = M;
		
		// 궁수의 공격 범위 
		// 행 max(0, N - D) ~ N - 1
		// 열 max(0, j - D) ~ Math.max(0, j + D)
		for (k = Math.max(0, N - D); k < N; k++) {
			for (l = Math.max(0, j - D); l < Math.min(M, j + D); l++) {
				if (test[k][l] == 1) {
					int dist = N - k + Math.abs(j - l);
					
					// 궁수가 공격하는 적은 거리가 D이하인 적 중에서 가장 가까운 적이고, 그러한 적이 여럿일 경우에는 가장 왼쪽에 있는 적을 공격
					if (dist <= D && (dist < minDist || (dist == minDist && l < x))) {
						minDist = dist;
						y = k;
						x = l;
					} 
				}
			}
		}
		
		if (x != M) q.add(new int[] {y, x});
	}
	
	// 적을 없앱니다.
	while (!q.isEmpty()) {
		int[] enemy = q.poll();
		
		if (test[enemy[0]][enemy[1]] == 1) {
			test[enemy[0]][enemy[1]] = 0;
			cnt++;
		}
	}
	
	// 마지막 공격일 땐 굳이 적 이동을 할 필요가 없음
	if (i == N - 1) break;
	
	// 적 한 칸 이동
	for (j = 0; j < M; j++) {
		for (k = i; k < N - 1; k++)
			tmp[k] = test[k][j];
		
        test[i][j] = 0;
        
		for (k = i; k < N - 1; k++)
			test[k + 1][j] = tmp[k];
	}
}
return cnt;

순수 구현 파트라 코드가 사람마다 제각각일 겁니다.
그렇기 때문에 딱히 설명 드릴 부분이 없을 듯하네요.
코드를 잘 음미하셨으면 합니다.

3. 전체 코드

import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class Main {
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static int N, M, D, B[][], test[][], tmp[];
	
	static int max(int depth, int s) throws Exception {
		// 궁수 3명을 다 배치했을 때
		if (depth == 3) {
			int i, j, k, l, cnt = 0;
			
			// 시뮬레이션 격자판 복사
			for (i = 0; i <= N; i++)
				for (j = 0; j < M; j++)
					test[i][j] = B[i][j];
			
			// 공격 당한 적의 좌표를 담을 큐
			Queue<int[]> q = new LinkedList<>();
			
			// 행번만큼 진행
			for (i = 0 ; i < N; i++) {
				// 궁수 공격
				for (j = 0; j < M; j++) {
					if (test[N][j] == 0) continue;
					
					int minDist = D, y = N, x = M;
					
					// 궁수의 공격 범위 
					// 행 max(0, N - D) ~ N - 1
					// 열 max(0, j - D) ~ Math.max(0, j + D)
					for (k = Math.max(0, N - D); k < N; k++) {
						for (l = Math.max(0, j - D); l < Math.min(M, j + D); l++) {
							if (test[k][l] == 1) {
								int dist = N - k + Math.abs(j - l);
								
								// 궁수가 공격하는 적은 거리가 D이하인 적 중에서 가장 가까운 적이고, 그러한 적이 여럿일 경우에는 가장 왼쪽에 있는 적을 공격
								if (dist <= D && (dist < minDist || (dist == minDist && l < x))) {
									minDist = dist;
									y = k;
									x = l;
								} 
							}
						}
					}
					
					if (x != M) q.add(new int[] {y, x});
				}
				
				// 적을 없앱니다.
				while (!q.isEmpty()) {
					int[] enemy = q.poll();
					
					if (test[enemy[0]][enemy[1]] == 1) {
						test[enemy[0]][enemy[1]] = 0;
						cnt++;
					}
				}
				
				// 마지막 공격일 땐 굳이 적 이동을 할 필요가 없음
				if (i == N - 1) break;
				
				// 적 한 칸 이동
				for (j = 0; j < M; j++) {
					for (k = i; k < N - 1; k++)
						tmp[k] = test[k][j];
					
			        test[i][j] = 0;
			        
					for (k = i; k < N - 1; k++)
						test[k + 1][j] = tmp[k];
				}
			}
			return cnt;
		}
		
		int ret = 0, i;
		
		for (i = s; i < M; i++) {
			B[N][i] = 2;
			ret = Math.max(ret, max(depth + 1, i + 1));
			B[N][i] = 0;
		}
		
		return ret;
	}
	
	public static void main(String[] args) throws Exception {
		String[] s = br.readLine().split(" ");
		N = Integer.parseInt(s[0]);
		M = Integer.parseInt(s[1]);
		D = Integer.parseInt(s[2]);
		B = new int[N + 1][M];
		test = new int[N + 1][M];
		tmp = new int[N];
		
		int i, j;
		
		for (i = 0; i < N; i++) {
			s = br.readLine().split(" ");
			for (j = 0; j < M; j++)
				B[i][j] = Integer.parseInt(s[j]);
		}
		
		bw.write(max(0, 0) + "");
		bw.close();
	}
}