BOJ-EX: 6/19/2024, 1:57:19 AM

14923번： 미로 탈출/README.md

@@ -0,0 +1,50 @@
+# 14923번: 미로 탈출 - <img src="https://static.solved.ac/tier_small/12.svg" style="height:20px" /> Gold IV
+
+<!-- performance -->
+
+<!-- 문제 제출 후 깃허브에 푸시를 했을 때 제출한 코드의 성능이 입력될 공간입니다.-->
+
+<!-- end -->
+
+## 문제
+
+[문제 링크](https://boj.kr/14923)
+
+
+<p>홍익이는 사악한 마법사의 꾐에 속아 N x M 미로 (Hx, Hy) 위치에 떨어졌다. 다행히도 홍익이는 마법사가 만든 미로의 탈출 위치(Ex, Ey)를 알고 있다. 하지만 미로에는 곳곳에 마법사가 설치한 벽이 있어 홍익이가 탈출하기 어렵게 하고 있다.</p>
+
+<p>홍익이는 마법사의 연구실에서 훔친 지팡이가 있어, 벽을 길로 만들 수 있다. 그렇지만, 안타깝게도 마법의 지팡이는 단 한 번만 사용할 수 있다.</p>
+
+<p>이때, 홍익이를 도와 미로에서 탈출할 수 있는지 알아보고, 할 수 있다면 가장 빠른 경로의 거리 D는 얼마인지 알아보자.</p>
+
+<p>인접한 칸으로 이동하는데 똑같은 시간이 들고, 벽을 부수는 데 시간이 걸리지 않는다.</p>
+
+
+
+## 입력
+
+
+<pre>N M
+Hx Hy
+Ex Ey
+N X M 행렬</pre>
+
+<ul>
+<li>2 ≤ N ≤ 1000, 2&nbsp;≤ M ≤ 1000</li>
+<li>1 ≤ Hx, Hy, Ex, Ey ≤ 1000</li>
+<li>(Hx,&nbsp;Hy)≠ (Ex, Ey)</li>
+<li>행렬은 0과 1로만 이루어져 있고, 0이 빈 칸, 1이 벽이다.</li>
+</ul>
+
+
+
+## 출력
+
+
+<p>D (탈출 할 수 없다면, -1을 출력한다.)</p>
+
+
+
+## 소스코드
+
+[소스코드 보기](미로%20탈출.cpp)

14923번： 미로 탈출/미로 탈출.cpp

@@ -0,0 +1,103 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                      :::    :::    :::     */
+/*   Problem Number: 14923                             :+:    :+:      :+:    */
+/*                                                    +:+    +:+        +:+   */
+/*   By: fkdl4878 <boj.kr/u/fkdl4878>                +#+    +#+          +#+  */
+/*                                                  +#+      +#+        +#+   */
+/*   https://boj.kr/14923                          #+#        #+#      #+#    */
+/*   Solved: 2024/06/19 00:56:40 by fkdl4878      ###          ###   ##.kr    */
+/*                                                                            */
+/* ************************************************************************** */
+
+// 기본적으로 BFS 길찾기 알고리즘
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+class Maze {
+public:
+    Maze(int N, int M) : n(N), m(M), grid(N, vector<int>(M)) {}
+
+    void makeMaze() {
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                cin >> grid[i][j];
+            }
+        }
+    }
+
+    void printMaze() const {
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                cout << grid[i][j];
+            }
+            cout << '\n';
+        }
+    }
+
+    int solve(int startX, int startY, int endX, int endY) {
+        vector<vector<vector<bool>>> visited(n, vector<vector<bool>>(m, vector<bool>(2, false)));
+        queue<tuple<int, int, int, int>> q;
+        q.push({startX, startY, 0, 0});
+        visited[startX][startY][0] = true;
+
+        int dx[4] = {-1, 1, 0, 0};
+        int dy[4] = {0, 0, -1, 1};
+
+        while (!q.empty()) {
+            auto [x, y, dist, wallBroken] = q.front();
+            q.pop();
+
+            if (x == endX && y == endY) {
+                return dist;
+            }
+
+            for (int i = 0; i < 4; i++) {
+                int nx = x + dx[i];
+                int ny = y + dy[i];
+
+                if (isValid(nx, ny)) {
+                    if (grid[nx][ny] == 0 && !visited[nx][ny][wallBroken]) {
+                        visited[nx][ny][wallBroken] = true;
+                        q.push({nx, ny, dist + 1, wallBroken});
+                    }
+
+                    if (grid[nx][ny] == 1 && wallBroken == 0 && !visited[nx][ny][1]) {
+                        visited[nx][ny][1] = true;
+                        q.push({nx, ny, dist + 1, 1});
+                    }
+                }
+            }
+        }
+
+        return -1;
+    }
+
+private:
+    vector<vector<int>> grid;
+    int n, m;
+
+    bool isValid(int x, int y) const {
+        return x >= 0 && x < n && y >= 0 && y < m;
+    }
+};
+
+int main() {
+    int N, M; // 미로 크기
+    int Hx, Hy; // 시작 위치
+    int Ex, Ey; // 탈출 위치
+
+    cin >> N >> M;
+    cin >> Hx >> Hy;
+    cin >> Ex >> Ey;
+
+    Maze maze(N, M);
+    maze.makeMaze();
+
+    int result = maze.solve(Hx - 1, Hy - 1, Ex - 1, Ey - 1);
+    cout << result << endl;
+
+    return 0;
+}

9082번： 지뢰찾기/README.md

@@ -0,0 +1,41 @@
+# 9082번: 지뢰찾기 - <img src="https://static.solved.ac/tier_small/12.svg" style="height:20px" /> Gold IV
+
+<!-- performance -->
+
+<!-- 문제 제출 후 깃허브에 푸시를 했을 때 제출한 코드의 성능이 입력될 공간입니다.-->
+
+<!-- end -->
+
+## 문제
+
+[문제 링크](https://boj.kr/9082)
+
+
+<p>지뢰찾기 게임은 2×N 배열에 숨겨져 있는 지뢰를 찾는 게임이다. 지뢰 주위에 쓰여 있는 숫자들로 지뢰를 찾을 수 있는데, 한 블록에 쓰여진 숫자는 그 블록 주위에 지뢰가 몇 개 있는지를 나타낸다. 지뢰가 확실히 있는 위치를 *, 숨겨진 블록을 #으로 표시한다. 첫째 줄에는 숫자만 나타나고 둘째 줄에는 *와 #만 나타나는데, 지뢰는 둘째 줄에만 있다.</p>
+
+<pre>12110
+##*##</pre>
+
+<p>위의 그림 2×5 배열에는 지뢰가 2개가 있다는 것을 알 수 있다. 숨겨진 블록 중 첫 번째 블록에 지뢰가 숨겨져 있고, 나머지 하나는 두 번째 줄의 가운데에 있다.</p>
+
+<p>2×N 배열이 주어지면 주어진 배열에 있는 모든 지뢰의 개수(*까지 포함)를 찾는 프로그램을 작성하시오.</p>
+
+
+
+## 입력
+
+
+<p>입력의 첫 줄에는 테스트 케이스의 개수 T(1 ≤ T ≤ 10)가 주어진다. 각 테스트 케이스는 첫 줄에 배열의 크기 N(1 ≤ N ≤ 100)이 주어지고, 그 다음 두 줄에 걸쳐서 배열이 주어진다. 첫 줄에는 항상 숫자만이 나타나며 이 숫자들 사이에 공백은 없으며, 둘째 줄에 주어지는 입력들 사이에도 공백은 없다. 그리고 이 숫자들은 올바른 값만이 입력으로 들어온다(지뢰의 위치에 대해 불가능한 값은 입력으로 주지 않는다).</p>
+
+
+
+## 출력
+
+
+<p>각 테스트 케이스에 대해서 주어진 배열에 있는 모든 지뢰의 수를 한 줄에 하나씩 출력한다. 지뢰의 수가 여럿이 될 수 있으면 가능한 지뢰의 수 중 최댓값을 출력한다.</p>
+
+
+
+## 소스코드
+
+[소스코드 보기](지뢰찾기.cpp)

9082번： 지뢰찾기/지뢰찾기.cpp

@@ -0,0 +1,12 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                      :::    :::    :::     */
+/*   Problem Number: 9082                              :+:    :+:      :+:    */
+/*                                                    +:+    +:+        +:+   */
+/*   By: fkdl4878 <boj.kr/u/fkdl4878>                +#+    +#+          +#+  */
+/*                                                  +#+      +#+        +#+   */
+/*   https://boj.kr/9082                           #+#        #+#      #+#    */
+/*   Solved: 2024/06/19 00:06:21 by fkdl4878      ###          ###   ##.kr    */
+/*                                                                            */
+/* ************************************************************************** */
+