Merge pull request #248 from AlgorithmWithGod/lkhyun

[20250317] BOJ / 골드2 / 통나무 옮기기 / 이강현

Author: ShinHeeEul

lkhyun/202503/17 BOJ 골드2 통나무 옮기기.md

@@ -0,0 +1,127 @@
+```java
+import java.util.*;
+import java.io.*;
+class Node{
+    int i;
+    int j;
+    int turn;
+    int count;
+    
+    Node(int i,int j,int turn,int count){
+        this.i = i;
+        this.j = j;
+        this.turn = turn;
+        this.count = count;
+    }
+}
+public class Algo3_이강현 {
+
+    static int N;
+    static char[][] grid;
+    static int[] di = {0,-1,0,0,1};
+    static int[] dj = {0,0,-1,1,0};
+    static int min = Integer.MAX_VALUE;
+    
+    public static void main(String[] args)throws Exception{
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
+        N = Integer.parseInt(br.readLine());
+        grid = new char[N][N];
+        
+        int starti = 0;
+        int startj = 0;
+        int turn = 0; // 0은 가로, 1은 세로
+        for(int i=0;i<N;i++) {
+            char[] str = br.readLine().toCharArray();
+            for(int j=0;j<N;j++) {
+                if(str[j]=='B' && starti == 0 && startj == 0) {
+                    if(j+1<N && str[j+1] == 'B') { // 가로일 경우
+                        starti = i;
+                        startj = j+1;
+                        turn = 0;
+                    } else { // 세로일 경우
+                        starti = i+1;
+                        startj = j;
+                        turn = 1;
+                    }
+                }
+                grid[i][j] = str[j];
+            }
+        }
+        BFS(starti,startj,turn);
+        if(min == Integer.MAX_VALUE){
+            bw.write("0");
+        }else{
+            bw.write(min+"");
+        }
+        
+        bw.close();
+    }
+    public static void BFS(int starti, int startj, int turn) {
+        ArrayDeque<Node> q = new ArrayDeque<>();
+        // 3차원 방문 배열: visited[i][j][0]는 가로, visited[i][j][1]은 세로 상태
+        boolean[][][] visited = new boolean[N][N][2];
+        
+        q.add(new Node(starti, startj, turn, 0));
+        visited[starti][startj][turn] = true;
+        
+        while(!q.isEmpty()) {
+            Node cur = q.poll();
+            
+            // 종료 조건: 목표 'E'에 도달한 경우
+            if(cur.turn == 0) { // 가로일 때
+                if(cur.j-1 >= 0 && cur.j+1 < N) {
+                    if(grid[cur.i][cur.j-1] == 'E' && grid[cur.i][cur.j] == 'E' && grid[cur.i][cur.j+1] == 'E')
+                        min = Math.min(min, cur.count);
+                }
+            } else { // 세로일 때
+                if(cur.i-1 >= 0 && cur.i+1 < N) {
+                    if(grid[cur.i-1][cur.j] == 'E' && grid[cur.i][cur.j] == 'E' && grid[cur.i+1][cur.j] == 'E')
+                        min = Math.min(min, cur.count);
+                }
+            }
+            
+            for(int k = 0; k < 5; k++) {
+                int newi = cur.i + di[k];
+                int newj = cur.j + dj[k];
+                if(cur.turn == 0) { // 가로 상태일 때
+                    if(newi < 0 || newi >= N || newj - 1 < 0 || newj + 1 >= N) continue;
+                    if(grid[newi][newj] == '1' || grid[newi][newj-1] == '1' || grid[newi][newj+1] == '1') continue;
+                    if(k == 0) { // 회전: 가로 -> 세로
+                        if(newi - 1 < 0 || newi + 1 >= N) continue;
+                        if(grid[newi-1][newj-1]=='1' || grid[newi-1][newj]=='1' || grid[newi-1][newj+1]=='1' ||
+                           grid[newi+1][newj-1]=='1' || grid[newi+1][newj]=='1' || grid[newi+1][newj+1]=='1')
+                            continue;
+                        if(!visited[newi][newj][1]){
+                            q.add(new Node(newi, newj, 1, cur.count + 1));
+                            visited[newi][newj][1] = true;
+                        }
+                    } else if(!visited[newi][newj][cur.turn]) { // 단순 이동
+                        q.add(new Node(newi, newj, cur.turn, cur.count + 1));
+                        visited[newi][newj][cur.turn] = true;
+                    }
+                
+                } else { // 세로 상태일 때
+                    if(newi - 1 < 0 || newi + 1 >= N || newj < 0 || newj >= N) continue;
+                    if(grid[newi][newj] == '1' || grid[newi-1][newj] == '1' || grid[newi+1][newj] == '1') continue;
+                    if(k == 0) { // 회전: 세로 -> 가로
+                        if(newj - 1 < 0 || newj + 1 >= N) continue;
+                        if(grid[newi-1][newj-1]=='1' || grid[newi][newj-1]=='1' || grid[newi+1][newj-1]=='1' ||
+                           grid[newi-1][newj+1]=='1' || grid[newi][newj+1]=='1' || grid[newi+1][newj+1]=='1')
+                            continue;
+                        if(!visited[newi][newj][0]){
+                            q.add(new Node(newi, newj, 0, cur.count + 1));
+                            visited[newi][newj][0] = true;
+                        }
+                    } else if(!visited[newi][newj][cur.turn]) { // 단순 이동
+                        q.add(new Node(newi, newj, cur.turn, cur.count + 1));
+                        visited[newi][newj][cur.turn] = true;
+                    }
+                }
+            }
+        }
+    }
+    
+}
+
+```