[20250725] BOJ / G4 / 이차원 배열과 연산 / 설진영

Seol-JY/202507/25 G4 이차원 배열과 연산.md

@@ -0,0 +1,124 @@
+```java
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    static int r, c, k;
+    static int[][] arr;
+    static int rowSize = 3, colSize = 3;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        r = Integer.parseInt(st.nextToken()) - 1;
+        c = Integer.parseInt(st.nextToken()) - 1;
+        k = Integer.parseInt(st.nextToken());
+
+        arr = new int[100][100];
+
+        for (int i = 0; i < 3; i++) {
+            st = new StringTokenizer(br.readLine());
+            for (int j = 0; j < 3; j++) {
+                arr[i][j] = Integer.parseInt(st.nextToken());
+            }
+        }
+
+        int time = 0;
+
+        while (time <= 100) {
+            if (r < rowSize && c < colSize && arr[r][c] == k) {
+                System.out.println(time);
+                return;
+            }
+
+            if (time == 100) break;
+
+            if (rowSize >= colSize) {
+                performROperation();
+            } else {
+                performCOperation();
+            }
+
+            time++;
+        }
+
+        System.out.println(-1);
+    }
+
+    static void performROperation() {
+        int maxColSize = 0;
+
+        for (int i = 0; i < rowSize; i++) {
+            Map<Integer, Integer> countMap = new HashMap<>();
+            for (int j = 0; j < colSize; j++) {
+                if (arr[i][j] != 0) {
+                    countMap.put(arr[i][j], countMap.getOrDefault(arr[i][j], 0) + 1);
+                }
+            }
+
+            List<int[]> pairs = new ArrayList<>();
+            for (Map.Entry<Integer, Integer> entry : countMap.entrySet()) {
+                pairs.add(new int[]{entry.getKey(), entry.getValue()});
+            }
+
+            pairs.sort((a, b) -> {
+                if (a[1] != b[1]) return a[1] - b[1];
+                return a[0] - b[0];
+            });
+
+            Arrays.fill(arr[i], 0);
+            int idx = 0;
+            for (int[] pair : pairs) {
+                if (idx >= 100) break;
+                arr[i][idx++] = pair[0];
+                if (idx >= 100) break;
+                arr[i][idx++] = pair[1];
+            }
+
+            maxColSize = Math.max(maxColSize, idx);
+        }
+
+        colSize = maxColSize;
+    }
+
+    static void performCOperation() {
+        int maxRowSize = 0;
+
+        for (int j = 0; j < colSize; j++) {
+            Map<Integer, Integer> countMap = new HashMap<>();
+            for (int i = 0; i < rowSize; i++) {
+                if (arr[i][j] != 0) {
+                    countMap.put(arr[i][j], countMap.getOrDefault(arr[i][j], 0) + 1);
+                }
+            }
+
+            List<int[]> pairs = new ArrayList<>();
+            for (Map.Entry<Integer, Integer> entry : countMap.entrySet()) {
+                pairs.add(new int[]{entry.getKey(), entry.getValue()});
+            }
+
+            pairs.sort((a, b) -> {
+                if (a[1] != b[1]) return a[1] - b[1];
+                return a[0] - b[0];
+            });
+
+            for (int i = 0; i < rowSize; i++) {
+                arr[i][j] = 0;
+            }
+
+            int idx = 0;
+            for (int[] pair : pairs) {
+                if (idx >= 100) break;
+                arr[idx++][j] = pair[0];
+                if (idx >= 100) break;
+                arr[idx++][j] = pair[1];
+            }
+
+            maxRowSize = Math.max(maxRowSize, idx);
+        }
+
+        rowSize = maxRowSize;
+    }
+}
+```