[백준]#17135 캐슬 디펜스

SeungBird·2020년 8월 30일
1

⌨알고리즘(백준)

목록 보기
123/401

문제

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

5 5 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
1 1 1 1 1

예제 출력 1

3

예제 입력 2

5 5 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
1 1 1 1 1
0 0 0 0 0

예제 출력 2

3

예제 입력 3

5 5 2
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
1 1 1 1 1
0 0 0 0 0

예제 출력 3

5

예제 입력 4

5 5 5
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1

예제 출력 4

15

예제 입력 5

6 5 1
1 0 1 0 1
0 1 0 1 0
1 1 0 0 0
0 0 0 1 1
1 1 0 1 1
0 0 1 0 0

예제 출력 5

9

예제 입력 6

6 5 2
1 0 1 0 1
0 1 0 1 0
1 1 0 0 0
0 0 0 1 1
1 1 0 1 1
0 0 1 0 0

예제 출력 6

14

풀이

이 문제는 완전탐색 알고리즘을 이용해서 풀 수 있는 문제였다. DFS 알고리즘을 이용해서 궁수 위치의 경우의 수를 모두 구하고
각 경우 마다 최대 적을 잡은 수를 비교해서 답을 구할 수 있었다.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class Main {
    static int N;
    static int M;
    static int D;
    static int[][] map;
    static int[][] current_map;
    static ArrayList<Pair> dead = new ArrayList<>();
    static boolean[] setted;
    static int max = Integer.MIN_VALUE;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] str = br.readLine().split(" ");
        N = Integer.parseInt(str[0]);
        M = Integer.parseInt(str[1]);
        D = Integer.parseInt(str[2]);
        map = new int[N][M];
        current_map = new int[N+1][M];
        setted = new boolean[M];

        for(int i=0; i<N; i++) {
            String[] input = br.readLine().split(" ");
            for(int j=0; j<M; j++) {
                map[i][j] = Integer.parseInt(input[j]);
            }
        }

        ArrayList<Integer> archer = new ArrayList<>();
        setArcher(0, archer);
        System.out.println(max);
    }

    public static void solution(ArrayList<Integer> archer) {
        for(int i=0; i<N; i++) {
            for(int j=0; j<M; j++)
                current_map[i][j] = map[i][j];
        }

        int sum = 0;

        while(check()) {
            boolean[][] already = new boolean[N][M];

            for(int k=0; k<3; k++) {
                int arch = archer.get(k);
                int min = Integer.MAX_VALUE;
                int X = -1;
                int Y = -1;

                for (int i=N-1; i>N-1-D && i>=0 ; i--) {
                   for(int j=0; j<M; j++) {
                       if((Math.abs(N-i)+Math.abs(j-arch))>D)
                           continue;

                       if(current_map[i][j]==1 && (Math.abs(N-i)+Math.abs(j-arch))<=D) {
                           if(min > (Math.abs(N-i)+Math.abs(j-arch))) {
                               min = Math.abs(N-i)+Math.abs(j-arch);
                               X=i;
                               Y=j;
                           }

                           else if(min == (Math.abs(N-i)+Math.abs(j-arch))) {
                               if(Y>j) {
                                   X = i;
                                   Y = j;
                               }
                           }
                       }
                   }
                }

                if(X>=0 && Y>=0) {
                    if(!already[X][Y]) {
                        already[X][Y] = true;
                        dead.add(new Pair(X, Y));
                        sum++;
                    }
                }
            }

            move();
        }

        max = Math.max(max, sum);
    }

    public static boolean check() {
        for(int i=0; i<N; i++) {
            for(int j=0; j<M; j++) {
                if(current_map[i][j]==1)
                    return true;
            }
        }
        return false;
    }

    public static void move() {
        for (Pair d : dead) {
            current_map[d.x][d.y] = 0;
        }
        dead.clear();

        for (int i=N-1; i>=0; i--) {
            for (int j=0; j<M; j++) {
                if(current_map[i][j]==1) {
                    current_map[i][j]=0;
                    current_map[i+1][j]=1;
                }
            }
        }
    }

    public static void setArcher(int index, ArrayList<Integer> archer) {

        if(archer.size()==3) {
            solution(archer);
            return;
        }

        for(int i=index; i<M; i++) {
            if(!setted[i]) {
                setted[i] = true;
                archer.add(i);
                setArcher(i+1, archer);
                archer.remove(archer.size()-1);
                setted[i] = false;
            }
        }
    }

    public static class Pair {
        int x;
        int y;

        public Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}
profile
👶🏻Jr. Programmer

0개의 댓글