Merge pull request #1679 from AlgorithmWithGod/zinnnn37

[20251215] BOJ / G2 / 벽 부수고 이동하기 4 / 김민진

Author: ShinHeeEul

zinnnn37/202512/15 BOJ G2 벽 부수고 이동하기 4.md

@@ -0,0 +1,121 @@
+```java
+import java.awt.*;
+import java.io.*;
+import java.util.*;
+import java.util.Queue;
+
+public class BJ_16946_벽_부수고_이동하기_4 {
+
+    private static final int[] dx = { 0, 1, 0, -1 };
+    private static final int[] dy = { 1, 0, -1, 0 };
+
+    private static BufferedReader  br = new BufferedReader(new InputStreamReader(System.in));
+    private static BufferedWriter  bw = new BufferedWriter(new OutputStreamWriter(System.out));
+    private static StringBuilder   sb = new StringBuilder();
+    private static StringTokenizer st;
+
+    private static int N, M, index;
+    private static int[][]               matrix;
+    private static boolean[][]           visited;
+    private static Queue<Point>          q;
+    private static Set<Integer>          set;
+    private static Map<Integer, Integer> groups;
+
+    public static void main(String[] args) throws IOException {
+        init();
+        sol();
+    }
+
+    private static void init() throws IOException {
+        st = new StringTokenizer(br.readLine());
+        N = Integer.parseInt(st.nextToken());
+        M = Integer.parseInt(st.nextToken());
+        index = 2;
+
+        matrix = new int[N][M];
+        for (int i = 0; i < N; i++) {
+            String input = br.readLine();
+            for (int j = 0; j < M; j++) {
+                matrix[i][j] = input.charAt(j) - '0';
+            }
+        }
+        visited = new boolean[N][M];
+        q = new ArrayDeque<>();
+        set = new HashSet<>();
+        groups = new HashMap<>();
+    }
+
+    private static void sol() throws IOException {
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                if (matrix[i][j] == 0 && !visited[i][j]) {
+                    bfs(i, j);
+                    index++;
+                }
+            }
+        }
+
+        printMat();
+
+        bw.write(sb.toString());
+        bw.flush();
+        bw.close();
+        br.close();
+    }
+
+    private static void bfs(int i, int j) {
+        q.clear();
+        q.offer(new Point(i, j));
+        visited[i][j] = true;
+        matrix[i][j] = index;
+
+        int cnt = 1;
+        while (!q.isEmpty()) {
+            Point cur = q.poll();
+
+            for (int d = 0; d < 4; d++) {
+                int nx = cur.x + dx[d];
+                int ny = cur.y + dy[d];
+
+                if (OOB(nx, ny) || visited[nx][ny] || matrix[nx][ny] != 0) continue;
+
+                visited[nx][ny] = true;
+                matrix[nx][ny] = index;
+                cnt++;
+                q.offer(new Point(nx, ny));
+            }
+        }
+        groups.put(index, cnt);
+    }
+
+    private static void printMat() {
+        int cnt;
+        for (int i = 0; i < N; i++) {
+            for (int j = 0; j < M; j++) {
+                if (matrix[i][j] != 1) {
+                    sb.append(0);
+                } else {
+                    cnt = 1;
+                    set.clear();
+                    for (int d = 0; d < 4; d++) {
+                        int nx = i + dx[d];
+                        int ny = j + dy[d];
+
+                        if (OOB(nx, ny) || matrix[nx][ny] == 1 || set.contains(matrix[nx][ny])) continue;
+
+                        set.add(matrix[nx][ny]);
+                        cnt += groups.get(matrix[nx][ny]);
+                    }
+                    sb.append(cnt % 10);
+                }
+            }
+            sb.append("\n");
+        }
+    }
+
+    private static boolean OOB(int x, int y) {
+        return x < 0 || N <= x || y < 0 || M <= y;
+    }
+
+}
+```