[Gold III] Title: 캐슬 디펜스, Time: 32 ms, Memory: 79520 KB -BaekjoonHub

Author: 051198Hz

백준/Gold/17135. 캐슬 디펜스/README.md

@@ -0,0 +1,34 @@
+# [Gold III] 캐슬 디펜스 - 17135 
+
+[문제 링크](https://www.acmicpc.net/problem/17135) 
+
+### 성능 요약
+
+메모리: 79520 KB, 시간: 32 ms
+
+### 분류
+
+구현, 그래프 이론, 브루트포스 알고리즘, 그래프 탐색, 시뮬레이션, 너비 우선 탐색
+
+### 제출 일자
+
+2026년 3월 9일 09:18:46
+
+### 문제 설명
+
+<p>캐슬 디펜스는 성을 향해 몰려오는 적을 잡는 턴 방식의 게임이다. 게임이 진행되는 곳은 크기가 N×M인 격자판으로 나타낼 수 있다. 격자판은 1×1 크기의 칸으로 나누어져 있고, 각 칸에 포함된 적의 수는 최대 하나이다. 격자판의 N번행의 바로 아래(N+1번 행)의 모든 칸에는 성이 있다.</p>
+
+<p>성을 적에게서 지키기 위해 궁수 3명을 배치하려고 한다. 궁수는 성이 있는 칸에 배치할 수 있고, 하나의 칸에는 최대 1명의 궁수만 있을 수 있다. 각각의 턴마다 궁수는 적 하나를 공격할 수 있고, 모든 궁수는 동시에 공격한다. 궁수가 공격하는 적은 거리가 D이하인 적 중에서 가장 가까운 적이고, 그러한 적이 여럿일 경우에는 가장 왼쪽에 있는 적을 공격한다. 같은 적이 여러 궁수에게 공격당할 수 있다. 공격받은 적은 게임에서 제외된다. 궁수의 공격이 끝나면, 적이 이동한다. 적은 아래로 한 칸 이동하며, 성이 있는 칸으로 이동한 경우에는 게임에서 제외된다. 모든 적이 격자판에서 제외되면 게임이 끝난다. </p>
+
+<p>게임 설명에서 보다시피 궁수를 배치한 이후의 게임 진행은 정해져있다. 따라서, 이 게임은 궁수의 위치가 중요하다. 격자판의 상태가 주어졌을 때, 궁수의 공격으로 제거할 수 있는 적의 최대 수를 계산해보자.</p>
+
+<p>격자판의 두 위치 (r<sub>1</sub>, c<sub>1</sub>), (r<sub>2</sub>, c<sub>2</sub>)의 거리는 |r<sub>1</sub>-r<sub>2</sub>| + |c<sub>1</sub>-c<sub>2</sub>|이다.</p>
+
+### 입력 
+
+ <p>첫째 줄에 격자판 행의 수 N, 열의 수 M, 궁수의 공격 거리 제한 D가 주어진다. 둘째 줄부터 N개의 줄에는 격자판의 상태가 주어진다. 0은 빈 칸, 1은 적이 있는 칸이다.</p>
+
+### 출력 
+
+ <p>첫째 줄에 궁수의 공격으로 제거할 수 있는 적의 최대 수를 출력한다.</p>
+

백준/Gold/17135. 캐슬 디펜스/캐슬 디펜스.swift

@@ -0,0 +1,72 @@
+import Foundation
+
+let input = readLine()!.split(separator: " ").map { Int($0)! },
+    N = input[0],
+    M = input[1],
+    D = input[2]
+
+var origin = [[Int]]()
+for _ in 0..<N {
+    origin.append(readLine()!.split(separator: " ").map { Int($0)! })
+}
+
+var result = 0
+
+func simulate(_ archers: [Int]) -> Int {
+    var board = origin
+    var kill = 0
+    
+    while true {
+        var targets = Set<[Int]>()
+        
+        for a in archers {
+            var best: (dist:Int, r:Int, c:Int)? = nil
+            
+            for r in 0..<N {
+                for c in 0..<M {
+                    if board[r][c] == 1 {
+                        let dist = abs(N - r) + abs(a - c)
+                        
+                        if dist <= D {
+                            if best == nil ||
+                               dist < best!.dist ||
+                               (dist == best!.dist && c < best!.c) {
+                                best = (dist, r, c)
+                            }
+                        }
+                    }
+                }
+            }
+            
+            if let b = best {
+                targets.insert([b.r, b.c])
+            }
+        }
+        
+        for t in targets {
+            if board[t[0]][t[1]] == 1 {
+                board[t[0]][t[1]] = 0
+                kill += 1
+            }
+        }
+        
+        board.removeLast()
+        board.insert(Array(repeating: 0, count: M), at: 0)
+        
+        if !board.flatMap({$0}).contains(1) {
+            break
+        }
+    }
+    
+    return kill
+}
+
+for i in 0..<M {
+    for j in i+1..<M {
+        for k in j+1..<M {
+            result = max(result, simulate([i,j,k]))
+        }
+    }
+}
+
+print(result)