백준 17135: 캐슬 디펜스 - BFS, 브루트포스 (파이썬, 자바)

캐슬 디펜스 성공

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

 

내 코드

import sys
import copy
from itertools import combinations
from collections import deque

def bfs(thisArchers):
    global answer

    copyMap=copy.deepcopy(myMap) #원본 지도 훼손하지 않기 위해 copy.
    thisAnswer=0

    for archerX in range(n-1,-1,-1): #궁수들의 x좌표를 바꿔가면서 전진 (n-1 ~ 0번째 줄)
        killSet=set() #제거할 대상들을 저장할 set (중복제거)

        for archerY in thisArchers: #세 명의 궁수만큼 반복
            que=deque()
            que.append([archerX,archerY,1]) #기본적으로 궁수 위치에서 한칸 앞에서 시작.(거리 1)

            while que: #특정 궁수에 대해서 bfs
                x,y,thisD=que.popleft() # x, y, 현재 사거리

                if copyMap[x][y]==1: #적을 만나면,
                    killSet.add((x,y)) #제거 대상에 넣고,
                    break #다음 궁수 차례로 넘어감 (1->2->3)

                if thisD<d: #현재 사거리가 주어진 사거리보다 작으면 다음 적 탐색 가능
                    for j in range(3): #적 탐색
                        nx=x+dx[j]
                        ny=y+dy[j]
                        
                        if 0<=nx<n and 0<=ny<m:
                            que.append([nx,ny,thisD+1]) #다음 적은 사거리를 1 늘려야 함


        #세 궁수를 다 돌면, 제거 대상들 제거
        for enemyX,eneymyY in killSet:
            copyMap[enemyX][eneymyY]=0 #제거 후에는 해당 적을 0으로 만듦.
            thisAnswer+=1 #제거한 적의 수++;
        
    answer=max(answer,thisAnswer) #제거할 수 있는 적의 최대 수 업데이트.



#Main
n,m,d=map(int,sys.stdin.readline().split())

myMap=[] #전체 지도
for _ in range(n):
    myMap.append(list(map(int,sys.stdin.readline().split())))

tmp=[i for i in range(m)] #tmp=[0,1,2 ... m-1] (전체 y좌표)
archerList=list(combinations(tmp,3)) #궁수의 y좌표 조합들. (nC3)

# **탐색 우선순위: 왼쪽, 위쪽, 오른쪽**
dx=[0,-1,0]
dy=[-1,0,1]

answer=0
for thisArchers in archerList: #궁수들의 모든 조합만큼 반복
    bfs(thisArchers)

print(answer)

 

풀이 및 접근)

- 해당 문제는 BFS + 시뮬레이션 + 브루트포스 가 결합된 문제이다. 문제의 조건들이 까다로워서 매우 풀기 힘들었다.

 

- 대략적인 흐름은 이렇다.

    1. 궁수 자리의 모든 조합을 구함.

    2. 각 조합별로 게임을 진행.

    3. 첫번째 궁수가 쏠 수 있는 적 저장 -> 두번째 궁수가 쏠 수 있는 적 저장 -> 세번째 궁수가 쏠 수 있는 적 저장

    4. 저장한 적들을 제거

    5. 모든 궁수들을 한 줄 전진 (적이 한 줄 내려오는 것과 동일)

    6. 3~6 반복

 

- 해당 문제에서 중요했던 것들은 탐색이 우선순위, 중복된 적 제거, 궁수들의 이동 이라고 생각한다.

 

- 탐색의 우선순위를 (왼쪽, 위쪽, 오른쪽) 으로 해야한다. 문제에서 적과의 거리가 같을 때 가장 왼쪽에 있는 적을 우선적으로 제거하기 때문이다.

 

- 여러 궁수가 제거할 적이 중복될 수 있는 것을 유의하여야 한다. 그렇기에 바로 적을 제거하는 것이 아니라 제거할 수 있는 적의 위치를 저장한 후, 한번에 제거한다. 해당 코드에서는 set을 써서 그럴 필요가 없긴하였다.

 

- 모든 적들이 한 줄씩 내려오는 것을 모든 궁수들이 한 줄 올라가는 것으로 하였다.

 

 

자바 ver.

package algorithm;

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

public class BOJ17135 {

    static int n,m,d;
    static int[][] arr;
    static List<int[]> archerList = new ArrayList<>();
    static int[] tmp=new int[3];
    static boolean[][] isKilled;
    static int answer;
    static int[] dx={0,-1,0};
    static int[] dy={-1,0,1};

    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());

        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());
        d = Integer.parseInt(st.nextToken());

        arr=new int[n][m];


        for(int i=0; i<n; i++){
            st=new StringTokenizer(br.readLine());
            for(int j=0; j<m; j++){
                arr[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        combi(0,0);

        answer=Integer.MIN_VALUE;
        for(int i=0; i<archerList.size(); i++){
            bfs(archerList.get(i));
        }

        System.out.println(answer);



    } //end of main


    public static void combi(int start, int cnt){
        if(cnt==3){
            int[] thisTmp=new int[3];
            for(int i=0; i<3; i++){
                thisTmp[i]=tmp[i];
            }

            archerList.add(thisTmp);
            return;
        }


        for(int i=start; i<m; i++){
            tmp[cnt]=i;
            combi(i+1,cnt+1);
        }
    }

    public static void bfs(int[] archers){
        int thisAnswer=0;

        isKilled=new boolean[n][m];

        int[][] copyArr;
        copyArr=copy();

        for(int i=n-1; i>-1; i--){
            Set<int[]> mySet=new HashSet<>();
            for (int archer : archers) {
                Deque<int[]> que = new ArrayDeque<>();
                que.offer(new int[]{i, archer,1});

                while(!que.isEmpty()) {
                    int[] newTmp = que.pollFirst();
                    int ax = newTmp[0];
                    int ay = newTmp[1];
                    int thisD=newTmp[2];

                    if (copyArr[ax][ay] == 1) {
                        if (!isKilled[ax][ay]) {
                            thisAnswer += 1;
                            isKilled[ax][ay] = true;
                            mySet.add(new int[]{ax, ay});
                        }
                        break;
                    }

                    if (thisD < d) {
                        for (int j = 0; j < 3; j++) {
                            int nx = ax + dx[j];
                            int ny = ay + dy[j];

                            if (0 <= nx && nx < n && 0 <= ny && ny < m) {
                                que.offer(new int[]{nx, ny,thisD+1});
                            }
                        }
                    }
                }
            }

            for (int[] archerPos : mySet) {
                copyArr[archerPos[0]][archerPos[1]]=0;
            }
        }

        answer=Math.max(answer,thisAnswer);

    }

    public static int[][] copy(){
        int[][] tmp=new int[n][m];

        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                tmp[i][j]=arr[i][j];
            }
        }

        return tmp;
    }
}