solve: [W02] SWEA 26070, 26071, 5656, 5658

studies/week-02/clarityth/26070-보석수집로봇.md

@@ -0,0 +1,127 @@
+<!--
+  📄 문제 풀이 템플릿
+  이 파일을 복사해 studies/week-XX/<깃허브ID>/<문제번호>-<문제이름>.md 로 저장하세요.
+  아래 5요소는 반드시 모두 작성합니다. (접근/시간/공간/핵심/코드)
+-->
+
+# [SWEA 26070] [모의 SW 역량테스트] 보석 수집 로봇
+
+| 항목 | 내용 |
+|:---|:---|
+| 🔗 문제 | https://swexpertacademy.com/main/code/userProblem/userProblemDetail.do?contestProbId=AZwmBfua3q3HBIT3 |
+| 📚 주제 | 다익스트라 |
+| 🎚️ 난이도 | 모의 SW 역량테스트 |
+| ⏱️ 소요 시간 | 3시간 |
+| 🔁 다시 풀기 | 아니오 |
+
+---
+
+## 1. 접근 방법
+<!-- 문제를 어떻게 이해했고, 왜 이 전략을 택했는지. 처음 떠올린 방법과 막혔던 지점도 좋음. -->
+* (0, 0)에서 오른쪽 방향(→)으로 출발하여 1~M번 보석을 순서대로 수집하는 최소 회전 횟수 구하기
+* 위치 외에 방향과 목표 보석 번호를 포함한 4차원 상태 `(d, row, col, target_j)` 정의
+* 로봇의 행동을 **[보석 획득]**, **[제자리 우회전]**, **[직진 이동]** 3가지로 분리하여 다익스트라(Priority Queue) 탐색 적용
+
+
+## 2. 시간 복잡도
+<!-- 예: O(N log N) — 정렬 O(N log N) + 순회 O(N). 근거를 함께 적기. -->
+<!-- SWEA는 시간 제한이 빡빡한 문제가 많으니 반드시 따져볼 것! -->
+**케이스당 O((V + E) log V) = O(N² · M · log(N² · M))**
+* **상태 수 (V)**: 최대 $10 \times 10 \times 4 \times 10 = 4,000$개
+* 상태당 간선은 최대 3개이므로 `E ≤ 3V`
+* 전체 입력 기준 복잡도는 `O(T · N² · M · log(N² · M))`
+
+## 3. 공간 복잡도
+<!-- 예: O(N) — 방문 배열 N개. -->
+**O(N² · M)** —
+* `dist` 딕셔너리 및 `pq` 힙 저장 공간 ($O(N^2 \cdot M)$)
+
+
+## 4. 핵심 풀이 방법 ⭐
+<!-- 이 문제의 결정적 아이디어 / 자주 하는 실수 / 알아야 할 개념. 가장 중요한 항목! -->
+1. **4차원 상태 확장**:
+   - `(d, row, col, target_j)` 튜플 정의 후  `dist` 딕셔너리로 최단 회전수 기록
+2. **동작의 분리**:
+   - **보석 획득**: `target_j + 1` 갱신 후 `continue` (회전 +0)
+   - **제자리 우회전**: `nd = (d + 1) % 4`, 위치 유지 (회전 +1)
+   - **직진 이동**: `row + dy[d], col + dx[d]` (회전 +0)
+3. **시계 방향 오프셋 배열**:
+   - `dx = [1, 0, -1, 0]`, `dy = [0, 1, 0, -1]` (0:우, 1:하, 2:좌, 3:상)로 설정하여 `(d + 1) % 4` 우회전 처리
+
+
+## 5. 실제 코드
+<!-- 통과한 코드. 언어 태그를 정확히 표기하세요. -->
+
+```python
+import heapq
+
+T = int(input())
+
+# 0: 우, 1: 하, 2: 좌, 3: 상 (시계 방향)
+dx = [1, 0, -1, 0]
+dy = [0, 1, 0, -1]
+
+for test_case in range(1, T + 1):
+    N = int(input())
+    grid = [list(map(int, input().split())) for _ in range(N)]
+
+    jewels = {}
+    j_idx = 1
+    for i in range(N):
+        for j in range(N):
+            if grid[i][j] > 0:
+                jewels[grid[i][j]] = (i, j)
+                j_idx += 1
+
+    # dist[(방향, 행, 열, 목표 보석 번호)] = 최소 회전 횟수
+    dist = {}
+    dist[(0, 0, 0, 1)] = 0
+
+    ans = float("inf")
+
+    # 힙 원소: (회전 횟수, 방향, 행, 열, 목표 보석 번호)
+    pq = [(0, 0, 0, 0, 1)]
+
+    while pq:
+        rotate, d, row, col, target_j = heapq.heappop(pq)
+
+        # 더 적은 회전수로 방문한 상태면 스킵
+        if rotate > dist.get((d, row, col, target_j), float("inf")):
+            continue
+
+        # 보석 획득
+        if (row, col) == jewels.get(target_j):
+            next_target = target_j + 1
+
+            if next_target == j_idx:
+                ans = rotate
+                break
+
+            # 보석 번호 증가
+            if rotate < dist.get((d, row, col, next_target), float("inf")):
+                dist[(d, row, col, next_target)] = rotate
+                heapq.heappush(pq, (rotate, d, row, col, next_target))
+            continue
+
+        # 회전
+        nd = (d + 1) % 4
+        if (rotate + 1) < dist.get((nd, row, col, target_j), float("inf")):
+            dist[(nd, row, col, target_j)] = rotate + 1
+            heapq.heappush(pq, (rotate + 1, nd, row, col, target_j))
+
+        # 직진
+        n_r, n_c = row + dy[d], col + dx[d]
+        if 0 <= n_r < N and 0 <= n_c < N:
+            if rotate < dist.get((d, n_r, n_c, target_j), float("inf")):
+                dist[(d, n_r, n_c, target_j)] = rotate
+                heapq.heappush(pq, (rotate, d, n_r, n_c, target_j))
+
+    print(f"#{test_case} {ans}")
+```
+
+---
+
+### 🧠 회고 (선택)
+<!-- 배운 점, 비슷한 유형에서 재사용할 아이디어, 리뷰어에게 묻고 싶은 점 -->
+* 다익스트라를 이런 식으로도 활용 가능하다는 것을 알게 되었다.
+* 상태를 저장하기 위해 어떤 변수들을 저장해야할지 고민이 됐다.

studies/week-02/clarityth/26071-블록제거게임.md

@@ -0,0 +1,113 @@
+<!--
+  📄 문제 풀이 템플릿
+  이 파일을 복사해 studies/week-XX/<깃허브ID>/<문제번호>-<문제이름>.md 로 저장하세요.
+  아래 5요소는 반드시 모두 작성합니다. (접근/시간/공간/핵심/코드)
+-->
+
+# [SWEA 26071] 블록 제거 게임
+
+| 항목 | 내용 |
+|:---|:---|
+| 🔗 문제 | https://swexpertacademy.com/main/code/userProblem/userProblemDetail.do?contestProbId=AZwmCVWq3uLHBIT3 |
+| 📚 주제 | DP (구간 DP / Top-Down 메모이제이션) |
+| 🎚️ 난이도 | SWEA 모의/D4 |
+| ⏱️ 소요 시간 | 3시간 |
+| 🔁 다시 풀기 | 예 |
+
+---
+
+## 1. 접근 방법
+<!-- 문제를 어떻게 이해했고, 왜 이 전략을 택했는지. 처음 떠올린 방법과 막혔던 지점도 좋음. -->
+* 처음엔 permutations 이용해 블록을 고르는 경우를 모두 계산하려했지만, 
+* 순차적으로 먼저 제거할 블록을 고르면 남은 블록들이 인접하게 변해 경우의 수가 $N!$로 폭발하고 상태 관리가 어려워짐
+* **역발상 (구간 DP)**: 특정 구간 `[start, end]`에서 가장 마지막에 제거할 블록 $k$를 기준으로 생각
+* $k$번째 블록이 해당 구간에서 제일 마지막으로 제거된다면, $k$의 좌/우 이웃은 항상 구간 외부인 `blocks[start - 1]`과 `blocks[end + 1]`로 고정
+* 따라서 `dp[start][end]`를 `[start, end]` 구간의 블록을 모두 제거할 때 얻는 최대 점수로 정의하고 메모이제이션(Top-Down DP)을 적용
+
+
+## 2. 시간 복잡도
+<!-- 예: O(N log N) — 정렬 O(N log N) + 순회 O(N). 근거를 함께 적기. -->
+<!-- SWEA는 시간 제한이 빡빡한 문제가 많으니 반드시 따져볼 것! -->
+
+**O(N³)** —
+* **구간 상태 개수**: $0 \le start \le end < N$ 인 구간의 개수 $O(N^2)$.
+* **전이(Transition) 연산**: 각 구간마다 $k$를 $start \sim end$ 범위로 탐색하며 $O(N)$번 비교
+* **총 시간 복잡도**: $O(N^2) \times O(N) = O(N^3)$ (N <= 10)
+
+
+## 3. 공간 복잡도
+<!-- 예: O(N) — 방문 배열 N개. -->
+
+**O(N²)** —
+* `dp[N][N]` 2차원 메모이제이션 배열 생성 $O(N^2)$
+* 재귀 호출 스택 깊이 최대 $O(N)$
+
+
+## 4. 핵심 풀이 방법 ⭐
+<!-- 이 문제의 결정적 아이디어 / 자주 하는 실수 / 알아야 할 개념. 가장 중요한 항목! -->
+1. **마지막에 제거될 블록 기준의 구간 DP (Interval DP)**:
+   - "첫 번째로 깰 블록"을 고르면 남은 양옆 요소가 가변적이지만, "해당 구간에서 마지막으로 깰 블록 $k$"를 고르면 좌우 이웃이 고정되어 좌측 구간 `[start, k-1]`과 우측 구간 `[k+1, end]`로 분할 가능
+2. **경계 처리 (`left_val`, `right_val`)**:
+   - $k$가 맨 마지막에 깨질 때 이웃 블록은 `start - 1`과 `end + 1` 위치
+   - 구간이 배열 양 끝 경계 밖인 경우(-1) 예외 처리
+3. **Top-Down 메모이제이션**:
+   - `dp[start][end]`에 계산된 최댓값을 저장
+
+
+## 5. 실제 코드
+<!-- 통과한 코드. 언어 태그를 정확히 표기하세요. -->
+
+```python
+
+T = int(input())
+
+for test_case in range(1, T+1):
+    N = int(input())
+    blocks = list(map(int, input().split()))
+
+    if N == 1:
+        print(f"#{test_case} {blocks[0]}")
+        continue
+
+    dp = [[-1] * N for _ in range(N)]
+
+    def get_max_score(start, end):
+        if start > end:
+            return 0
+
+        # DP 메모이제이션
+        if dp[start][end] != -1:
+            return dp[start][end]
+
+        max_val = -float('inf')
+
+        # [start, end] 구간에서 마지막으로 깨트릴 블록 k 탐색
+        for k in range(start, end+1):
+            left_val = blocks[start - 1] if start > 0 else -1   # 좌측 이웃
+            right_val = blocks[end + 1] if end < N - 1 else -1  # 우측 이웃
+
+            if left_val == -1 and right_val > 0:       # 왼쪽 끝일 경우
+                score = right_val
+            elif right_val == -1 and left_val > 0:     # 오른쪽 끝일 경우
+                score = left_val
+            elif left_val > 0 and right_val > 0:       # 중간일 경우
+                score = left_val * right_val
+            elif left_val == -1 and right_val == -1:   # 블록이 오직 하나 남은 경우
+                score = blocks[k]
+
+            # top-down DP: 좌측 구간 최댓값 + 우측 구간 최댓값 + 해당 블록 k를 깼을 때 점수
+            val = get_max_score(start, k-1) + get_max_score(k+1, end) + score
+            max_val = max(max_val, val)
+
+        dp[start][end] = max_val
+        return max_val
+
+    print(f"#{test_case} {get_max_score(0, N-1)}")
+```
+
+---
+
+### 🧠 회고 (선택)
+<!-- 배운 점, 비슷한 유형에서 재사용할 아이디어, 리뷰어에게 묻고 싶은 점 -->
+* 아이디어를 생각해내기까지의 과정이 쉽지 않았다 
+* 구간 DP 유형에 대한 추가적인 학습이 필요할 것 같다.

studies/week-02/clarityth/5656-벽돌깨기.md

@@ -0,0 +1,134 @@
+<!--
+  📄 문제 풀이 템플릿
+  이 파일을 복사해 studies/week-XX/<깃허브ID>/<문제번호>-<문제이름>.md 로 저장하세요.
+  아래 5요소는 반드시 모두 작성합니다. (접근/시간/공간/핵심/코드)
+-->
+
+# [SWEA 5656] [모의 SW 역량테스트] 벽돌 깨기
+
+| 항목 | 내용 |
+|:---|:---|
+| 🔗 문제 | https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWXRQm6qfL0DFAUo |
+| 📚 주제 | 구현, 완전탐색(DFS), 백트래킹 |
+| 🎚️ 난이도 | 모의 SW 역량테스트 |
+| ⏱️ 소요 시간 | 1시간 |
+| 🔁 다시 풀기 | 아니오 |
+
+---
+
+## 1. 접근 방법
+<!-- 문제를 어떻게 이해했고, 왜 이 전략을 택했는지. 처음 떠올린 방법과 막혔던 지점도 좋음. -->
+* 구슬을 $N$번 떨어뜨려 맞출 수 있는 모든 위치(열 $W$개)의 경우의 수를 DFS 백트래킹 탐색
+* 구슬을 쏠 열(`col`)을 결정하면, 해당 열에서 가장 상단에 있는 벽돌을 타격하여 연쇄 폭발 처리
+* 폭발이 완료된 후 남아있는 벽돌들을 아래로 떨어뜨리는 중력 처리를 수행한 뒤 다음 단계로 재귀 호출
+* 매 단계마다 남아있는 벽돌 수의 최솟값을 갱신하여 $N$번 구슬을 모두 쏜 뒤 남은 벽돌의 최소 개수 계산
+
+
+## 2. 시간 복잡도
+<!-- 예: O(N log N) — 정렬 O(N log N) + 순회 O(N). 근거를 함께 적기. -->
+<!-- SWEA는 시간 제한이 빡빡한 문제가 많으니 반드시 따져볼 것! -->
+
+**O(W^N · H · W)** —
+* **구슬 투하 경우의 수**: 총 $N$번 구슬을 쏘며 $W$개 열 중 하나를 선택하므로 $W^N$가지 상태 탐색. $W=12, N=4$일 때 실제 DFS 간선 수는 $W + W^2 + W^3 + W^4 = 22,620$개.
+* **단계별 연산**: 각 간선마다 보드 복사, 폭발(최대 $H \times W$) 및 중력 처리($O(H \times W)$) 진행.
+
+
+## 3. 공간 복잡도
+<!-- 예: O(N) — 방문 배열 N개. -->
+
+**O(N · H · W)** —
+* **재귀 호출 스택**: DFS 깊이 최대 $N$개.
+* **보드 복사**: 매 재귀 단계마다 $H \times W$크기의 `next_board` deepcopy ($N \times H \times W$).
+
+
+## 4. 핵심 풀이 방법 ⭐
+<!-- 이 문제의 결정적 아이디어 / 자주 하는 실수 / 알아야 할 개념. 가장 중요한 항목! -->
+1. **DFS 백트래킹과 매 단계 최솟값 갱신**:
+   - `ans = min(ans, remain)`을 DFS 첫 줄에 배치하여 항상 결과 값을 업데이트 했어야 했는데, 최초 풀이시 DFS의 depth가 N일때만 업데이트하도록 잘못 설정
+2. **연쇄 폭발 처리**:
+   - 벽돌의 숫자 K를 먼저 따로 보관한 뒤 해당 위치를 `0`으로 지우고, 상하좌우 dx, dy에 대해 K-1 범위만큼 연쇄 폭발을 재귀함수로 구현 (BFS 큐로도 구현 가능)
+3. **중력 정렬**:
+   - 각 열을 위에서부터 순회해 `0`이 아닌 벽돌을 모은 후, `pop()`으로 바닥부터 채워 넣어 벽돌을 아래로 이동
+4. **가지치기**:
+   - `ans == 0`이 되는 순간 이미 도달 가능한 최댓값이므로 조기 종료
+
+
+## 5. 실제 코드
+<!-- 통과한 코드. 언어 태그를 정확히 표기하세요. -->
+
+```python
+T = int(input())
+
+dx = [0, 0, -1, 1]
+dy = [-1, 1, 0, 0]
+
+for test_case in range(1, T+1):
+    N, W, H = map(int, input().split())
+
+    board = [list(map(int, input().split())) for _ in range(H)]
+
+    def get_brick_cnt(board):
+        cnt = 0
+        for row in board:
+            for room in row:
+                if room > 0:
+                    cnt += 1
+        return cnt
+
+    def boom(row, col, board):
+        power = board[row][col]
+        board[row][col] = 0
+        cnt = 1
+
+        for p in range(1, power):
+            for i in range(4):
+                nr, nc = row + p * dy[i], col + p * dx[i]
+                if 0 <= nr < H and 0 <= nc < W:
+                    if board[nr][nc] > 1:
+                        cnt += boom(nr, nc, board)
+                        board[nr][nc] = 0
+                    elif board[nr][nc] == 1:
+                        board[nr][nc] = 0
+                        cnt += 1
+        return cnt
+
+    def gravity(board):
+        for col in range(W):
+            temp = []
+            for row in range(H):
+                if board[row][col] > 0:
+                    temp.append(board[row][col])
+                board[row][col] = 0
+
+            row = H - 1
+            while temp:
+                board[row][col] = temp.pop()
+                row -= 1
+
+    def dfs(depth, board, remain):
+        global ans
+
+        ans = min(ans, remain)
+
+        if depth == N or ans == 0:
+            return
+
+        for col in range(W):
+            for row in range(H):
+                if board[row][col] > 0:
+                    next_board = [r[:] for r in board]
+                    crashed = boom(row, col, next_board)
+                    gravity(next_board)
+                    dfs(depth + 1, next_board, remain - crashed)
+                    break
+
+    ans = get_brick_cnt(board)
+    dfs(0, board, ans)
+    print(f"#{test_case} {ans}")
+```
+
+### 🧠 회고 (선택)
+<!-- 배운 점, 비슷한 유형에서 재사용할 아이디어, 리뷰어에게 묻고 싶은 점 -->
+* 최초 풀이시, product를 이용해 풀었는데 너무 오래걸려 수정했다.
+* dfs의 호출에 따른 board의 상태 관리를 deepcopy로 각각 전달하는 게 중요했다.
+* 연쇄 폭발 로직을 구현하는데 있어서 큐를 이용하는 방법이 있다는 것을 알게 되었다.