[백준] SW 역량테스트 문제집

구슬 탈출 2

public class Main {
    static int N, M;
    static char[][] board;
    static boolean[][][][] visited;
    static int[] dx = {0, 0, -1, 1};  // 좌우
    static int[] dy = {-1, 1, 0, 0};  // 상하

    static class Node {
        int rx, ry, bx, by, depth;
        Node(int rx, int ry, int bx, int by, int depth) {
            this.rx = rx; this.ry = ry;
            this.bx = bx; this.by = by;
            this.depth = depth;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken()); M = Integer.parseInt(st.nextToken());
        board = new char[N][M];
        int rx=0, ry=0, bx=0, by=0;

        for (int i = 0; i < N; i++) {
            board[i] = br.readLine().toCharArray();
            for (int j = 0; j < M; j++) {
                if (board[i][j] == 'R') { ry = i; rx = j; board[i][j] = '.'; }
                if (board[i][j] == 'B') { by = i; bx = j; board[i][j] = '.'; }
            }
        }

        visited = new boolean[N][M][N][M];
        System.out.println(bfs(rx, ry, bx, by));
    }

    static int bfs(int rx, int ry, int bx, int by) {
        Queue<Node> q = new LinkedList<>();
        q.offer(new Node(rx, ry, bx, by, 0));
        visited[ry][rx][by][bx] = true;

        while (!q.isEmpty()) {
            Node cur = q.poll();
            if (cur.depth >= 10) break;

            for (int dir = 0; dir < 4; dir++) {
                int nrx = cur.rx, nry = cur.ry;
                int nbx = cur.bx, nby = cur.by;
                int rc = 0, bc = 0;

                // 파란 구슬부터 이동
                while (board[nby+dy[dir]][nbx+dx[dir]] != '#' &&
                      board[nby][nbx] != 'O') {
                    nby += dy[dir];
                    nbx += dx[dir];
                    bc++;
                }

                // 빨간 구슬 이동
                while (board[nry+dy[dir]][nrx+dx[dir]] != '#' &&
                      board[nry][nrx] != 'O') {
                    nry += dy[dir];
                    nrx += dx[dir];
                    rc++;
                }

                // 파란이 빠지면 실패 패스
                if (board[nby][nbx] == 'O') continue;
                // 빨간만 빠지면 성공
                if (board[nry][nrx] == 'O') return cur.depth + 1;

                // 겹쳤다면…
                if (nrx == nbx && nry == nby) {
                    if (rc > bc) { nrx -= dx[dir]; nry -= dy[dir]; }
                    else { nbx -= dx[dir]; nby -= dy[dir]; }
                }

                if (!visited[nry][nrx][nby][nbx]) {
                    visited[nry][nrx][nby][nbx] = true;
                    q.offer(new Node(nrx, nry, nbx, nby, cur.depth + 1));
                }
            }
        }

        return -1;
    }
}

2048

public class Main {
    static int N;
    static int[][] board;
    static int max = 0;

    // 상, 하, 좌, 우
    static int[] dx = {-1, 1, 0, 0};
    static int[] dy = {0, 0, -1, 1};

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());
        board = new int[N][N];

        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                board[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        dfs(board, 0);
        System.out.println(max);
    }

    static void dfs(int[][] currBoard, int depth) {
        if (depth == 5) {
            max = Math.max(max, getMax(currBoard));
            return;
        }

        for (int d = 0; d < 4; d++) {
            int[][] next = move(cloneBoard(currBoard), d);
            dfs(next, depth + 1);
        }
    }

    static int[][] move(int[][] b, int dir) {
        boolean[][] merged = new boolean[N][N];
        if (dir == 0) { // up
            for (int j = 0; j < N; j++) {
                for (int i = 1; i < N; i++) {
                    if (b[i][j] == 0) continue;
                    int x = i;
                    while (x > 0 && b[x - 1][j] == 0) {
                        b[x - 1][j] = b[x][j];
                        b[x][j] = 0;
                        x--;
                    }
                    if (x > 0 && b[x - 1][j] == b[x][j] && !merged[x - 1][j]) {
                        b[x - 1][j] *= 2;
                        b[x][j] = 0;
                        merged[x - 1][j] = true;
                    }
                }
            }
        } else if (dir == 1) { // down
            for (int j = 0; j < N; j++) {
                for (int i = N - 2; i >= 0; i--) {
                    if (b[i][j] == 0) continue;
                    int x = i;
                    while (x < N - 1 && b[x + 1][j] == 0) {
                        b[x + 1][j] = b[x][j];
                        b[x][j] = 0;
                        x++;
                    }
                    if (x < N - 1 && b[x + 1][j] == b[x][j] && !merged[x + 1][j]) {
                        b[x + 1][j] *= 2;
                        b[x][j] = 0;
                        merged[x + 1][j] = true;
                    }
                }
            }
        } else if (dir == 2) { // left
            for (int i = 0; i < N; i++) {
                for (int j = 1; j < N; j++) {
                    if (b[i][j] == 0) continue;
                    int y = j;
                    while (y > 0 && b[i][y - 1] == 0) {
                        b[i][y - 1] = b[i][y];
                        b[i][y] = 0;
                        y--;
                    }
                    if (y > 0 && b[i][y - 1] == b[i][y] && !merged[i][y - 1]) {
                        b[i][y - 1] *= 2;
                        b[i][y] = 0;
                        merged[i][y - 1] = true;
                    }
                }
            }
        } else { // right
            for (int i = 0; i < N; i++) {
                for (int j = N - 2; j >= 0; j--) {
                    if (b[i][j] == 0) continue;
                    int y = j;
                    while (y < N - 1 && b[i][y + 1] == 0) {
                        b[i][y + 1] = b[i][y];
                        b[i][y] = 0;
                        y++;
                    }
                    if (y < N - 1 && b[i][y + 1] == b[i][y] && !merged[i][y + 1]) {
                        b[i][y + 1] *= 2;
                        b[i][y] = 0;
                        merged[i][y + 1] = true;
                    }
                }
            }
        }
        return b;
    }

    static int getMax(int[][] b) {
        int val = 0;
        for (int[] row : b) {
            for (int n : row) {
                val = Math.max(val, n);
            }
        }
        return val;
    }

    static int[][] cloneBoard(int[][] b) {
        int[][] newBoard = new int[N][N];
        for (int i = 0; i < N; i++) newBoard[i] = b[i].clone();
        return newBoard;
    }
} 

뱀

// 시뮬레이션 (1초 단위) & BFS
public class Main {

  private static int N; // 보드의 크기

  private static int K; // 사과의 개수

  private static int L; // 방향전환 수
  private static Map<Integer, String> turns = new HashMap<>();

  private static int[][] map; // 0은 갈 수 있는 곳, 1은 뱀, 2는 사과

  // 우 하, 좌 상
  private static int[] dx = {0, 1, 0, -1};
  private static int[] dy = {1, 0, -1, 0};

  private static Queue<int[]> snake = new LinkedList<>();

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    int dir = 0; // 처음에는 오른쪽

    N = Integer.parseInt(br.readLine());
    map = new int[N][N];

    K = Integer.parseInt(br.readLine());

    for (int i = 0; i < K; i++) {
      StringTokenizer st = new StringTokenizer(br.readLine());
      int a = Integer.parseInt(st.nextToken());
      int b = Integer.parseInt(st.nextToken());

      map[a-1][b-1] = 2;

    }
    L = Integer.parseInt(br.readLine());

    for (int i = 0; i < L; i++) {
      StringTokenizer st = new StringTokenizer(br.readLine());
      int a = Integer.parseInt(st.nextToken());
      String s = st.nextToken();
      turns.put(a, s);
    }

    snake.offer(new int[]{0, 0});
    System.out.println(bfs(0,1, 0, 0)); // 오른쪽 시작
//    printInputData();
  }

  private static int bfs(int dir, int time, int x, int y) {
//    snake.add(new int[]{x, y});
    Queue<int[]> queue = new LinkedList<>();
    queue.offer(new int[]{dir, time, x, y});
    // move

    int currDir = dir;
    int currTime = time;

//    time++;
    while (!queue.isEmpty()) {
      // 방향
      int[] curr = queue.poll();

      currDir = curr[0];
      currTime = curr[1];

      int nx = curr[2] + dx[currDir];
      int ny = curr[3] + dy[currDir];

//      System.out.println("Time: " + currTime);
//      System.out.println("Head: (" + curr[2] + ", " + curr[3] + ")");
//      System.out.println("Dir: " + currDir + " → Next: (" + nx + ", " + ny + ")");
//      System.out.println("Turn: " + (turns.containsKey(currTime) ? turns.get(currTime) : "None"));

//      System.out.print("Snake: [");
//      for (int[] s : snake) {
//        System.out.print("(" + s[0] + "," + s[1] + ") ");
//      }
//      System.out.println("]");
//      System.out.println("-------------");

      if (nx >= 0 && ny >= 0 && nx < N && ny < N) {

        if (map[nx][ny] == 1) { // 자기 자신 만남
//          System.out.println("NO");
          return currTime;
        }
        // 사과 처리
        if (map[nx][ny] == 2) {
//          System.out.println("APPLE");
          snake.offer(new int[]{nx, ny});
          map[nx][ny] = 1;
        }
        // 그냥 처리
        if (map[nx][ny] == 0) {
          snake.offer(new int[]{nx, ny});
          map[nx][ny] = 1;
          if (!snake.isEmpty()) { // 꼬리 자르기
            int[] temp = snake.poll();
            map[temp[0]][temp[1]] = 0;
          }
        }

      } else {     // 탈락 처리
//        System.out.println("YESS");
        return currTime;
      }

      int nextDir = currDir;

      if (turns.containsKey(currTime)) {

        String s = turns.get(currTime);
        if (s.equals("D")) {
          if (nextDir + 1 > 3) nextDir = 0;
          else nextDir++;
        }
        else if (s.equals("L")) {
          if (nextDir - 1 >= 0) nextDir--;
          else nextDir = 3;
        }
      }



      // 방향 전환 처리
      queue.offer(new int[]{nextDir, currTime + 1, nx, ny});
    }

//    System.out.println("NO");
    return currTime;
  }

  public static void printInputData() {
    System.out.println("보드 크기: " + N);
    System.out.println("사과 개수: " + K);
    System.out.println("사과 위치:");
//    for (int[] apple : apples) {
//      System.out.println("  - (" + apple[0] + ", " + apple[1] + ")");
//    }

    System.out.println("방향 전환 횟수: " + L);
    System.out.println("방향 전환 정보:");
    for (Map.Entry<Integer, String> entry : turns.entrySet()) {
      System.out.println("  - 시간: " + entry.getKey() + ", 방향: " + entry.getValue());
    }
  }

}

시험 감독

public class Main {
  private static int N; // 시험장의 개수

  private static int[] examineesPerRoom;

  private static int chiefSupervisorCapacity;       // 총감독관 1명이 커버할 수 있는 인원 수
  private static int assistantSupervisorCapacity;   // 부감독관 1명이 커버할 수 있는 인원 수

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    N = Integer.parseInt(br.readLine());
    examineesPerRoom = new int[N];

    StringTokenizer st = new StringTokenizer(br.readLine());
    for (int i = 0; i < N; i++) {
      int x = Integer.parseInt(st.nextToken());
//      System.out.print(x + ", ");
      examineesPerRoom[i] = x;
    }

//    System.out.println();
    st = new StringTokenizer(br.readLine());
    chiefSupervisorCapacity = Integer.parseInt(st.nextToken());
    assistantSupervisorCapacity = Integer.parseInt(st.nextToken());

//    printInputData();

    // 주 감독관 배치
    long minumumTeachersNum = 0;
    for (int i = 0; i < N; i++) {
//      examineesPerRoom[i] = examineesPerRoom[i] - chiefSupervisorCapacity;
      if (examineesPerRoom[i] - chiefSupervisorCapacity < 0) {
        examineesPerRoom[i] = 0;
      }
      else {
        examineesPerRoom[i] -= chiefSupervisorCapacity;
      }
      //
      minumumTeachersNum += 1;
    }

    // 보조 감독관 배치
    for (int i = 0; i < N; i++) {
      int temp = examineesPerRoom[i] / assistantSupervisorCapacity;
      minumumTeachersNum += temp;

      if (examineesPerRoom[i] % assistantSupervisorCapacity != 0) {
        minumumTeachersNum += 1;
      }
      examineesPerRoom[i] = 0;
    }

    System.out.println(minumumTeachersNum);
  }

  public static void printInputData() {
    System.out.println("시험장 수: " + N);

    System.out.print("각 시험장 응시자 수: [");
    for (int i = 0; i < N; i++) {
      System.out.print(examineesPerRoom[i]);
      if (i < N - 1) System.out.print(", ");
    }
    System.out.println("]");

    System.out.println("총감독관 1인당 감시 가능 인원: " + chiefSupervisorCapacity);
    System.out.println("부감독관 1인당 감시 가능 인원: " + assistantSupervisorCapacity);
  }

}

주사위 굴리기

public class Main {
  private static int N; // 세로
  private static int M; // 가로
  private static int K;

  private static int[][] map;

  private static Queue<Integer> queue = new LinkedList<>();

  // x, 동, 서, 북, 남
  private static int[] dx = {0, 0, 0, -1, 1};
  private static int[] dy = {0, 1, -1, 0, 0};

  // 위, 아래, 북, 남, 왼, 오
  private static int[] dice = new int[6];

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());

    N = Integer.parseInt(st.nextToken());
    M = Integer.parseInt(st.nextToken());

    int x = Integer.parseInt(st.nextToken());
    int y = Integer.parseInt(st.nextToken());

    K = Integer.parseInt(st.nextToken()); // 명령의 개수

    map = new int[N][M];

    for (int i = 0; i < N; i++) { // 세로
      st = new StringTokenizer(br.readLine());
      for (int j = 0; j < M; j++) { // 가로
        map[i][j] = Integer.parseInt(st.nextToken());
      }
    }

    st = new StringTokenizer(br.readLine());
    for (int i = 0; i < K; i++) {
      queue.add(Integer.parseInt(st.nextToken()));
    }

    dfs(x, y);
  }

//  가장 처음에 주사위에는 모든 면에 0이 적혀져 있다.
  private static void dfs(int x, int y) {

    while (!queue.isEmpty()) {
      int dir = queue.poll();

      int nx = x + dx[dir];
      int ny = y + dy[dir];

      // 주사위 이동 범위
      if ((nx) < 0  || (ny) < 0  ||
          nx >= N || ny >= M) {
        continue;
      }

      rollTheDice(dir);

      if (map[nx][ny] == 0) { // 이동한 칸에 쓰여 있는 수가 0이면,
        // 주사위의 바닥면에 쓰여 있는 수가 칸에 복사
        map[nx][ny] = dice[1];
      }
      else { // 0이 아닌 경우에는
        // 칸에 쓰여 있는 수가 주사위의 바닥면으로 복사되며, 칸에 쓰여 있는 수는 0
        dice[1] = map[nx][ny];
        map[nx][ny] = 0;
      }

      x = nx;
      y = ny;

      System.out.println(dice[0]);
    }
  }

  private static void rollTheDice(int dir) {
    int[] temp = dice.clone(); // 기존 주사위 상태 복사

    if (dir == 1) { // 동
      dice[0] = temp[4]; // top ← left
      dice[1] = temp[5]; // bottom ← right
      dice[4] = temp[1]; // left ← bottom
      dice[5] = temp[0]; // right ← top
    } else if (dir == 2) { // 서
      dice[0] = temp[5]; // top ← right
      dice[1] = temp[4]; // bottom ← left
      dice[4] = temp[0]; // left ← top
      dice[5] = temp[1]; // right ← bottom
    } else if (dir == 3) { // 북
      dice[0] = temp[3]; // top ← south
      dice[1] = temp[2]; // bottom ← north
      dice[2] = temp[0]; // north ← top
      dice[3] = temp[1]; // south ← bottom
    } else if (dir == 4) { // 남
      dice[0] = temp[2]; // top ← north
      dice[1] = temp[3]; // bottom ← south
      dice[2] = temp[1]; // north ← bottom
      dice[3] = temp[0]; // south ← top
    }
  }

}

테트로미노

public class Main {
  private static int N;
  private static int M;
  private static int answer = 0;

  private static int[][] map;
  private static boolean[][] visited;
  static int[] dx = {-1, 1, 0, 0}, dy = {0, 0, -1, 1};

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());

    N = Integer.parseInt(st.nextToken());
    M = Integer.parseInt(st.nextToken());

    map = new int[N][M];
    visited = new boolean[N][M];

    for (int i = 0; i < N; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 0; j < M; j++)
        map[i][j] = Integer.parseInt(st.nextToken());
    }

    for (int i = 0; i < N; i++)
      for (int j = 0; j < M; j++) {
        visited[i][j] = true;
        dfs(i, j, 1, map[i][j]);
        visited[i][j] = false;
        checkTShape(i, j); // ㅗ 예외 처리
      }

    System.out.println(answer);
  }

  // 기본 DFS (깊이 4까지)
  static void dfs(int x, int y, int depth, int sum) {
    if (depth == 4) {
      answer = Math.max(answer, sum);
      return;
    }

    for (int d = 0; d < 4; d++) {
      int nx = x + dx[d], ny = y + dy[d];
      if (nx < 0 || nx >= N || ny < 0 || ny >= M || visited[nx][ny]) continue;

      visited[nx][ny] = true;
      dfs(nx, ny, depth + 1, sum + map[nx][ny]);
      visited[nx][ny] = false;
    }
  }

  // ㅗ 모양 처리: 4방향 중 3방향을 고르면 됨
  static void checkTShape(int x, int y) {
    int center = map[x][y];
    for (int i = 0; i < 4; i++) {
      int temp = center;
      boolean valid = true;
      for (int j = 0; j < 4; j++) {
        if (j == i) continue; // 한 방향만 빼고 3개 더하기
        int nx = x + dx[j], ny = y + dy[j];
        if (nx < 0 || nx >= N || ny < 0 || ny >= M) {
          valid = false;
          break;
        }
        temp += map[nx][ny];
      }
      if (valid)
        answer = Math.max(answer, temp);
    }
  }
}

퇴사

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();

        int[] T = new int[N + 2];
        int[] P = new int[N + 2];
        int[] dp = new int[N + 2];

        for (int i = 1; i <= N; i++) {
            T[i] = sc.nextInt(); // 상담 기간
            P[i] = sc.nextInt(); // 보상
        }

        for (int i = N; i >= 1; i--) {
            if (i + T[i] <= N + 1) {
                dp[i] = Math.max(P[i] + dp[i + T[i]], dp[i + 1]);
            } else {
                dp[i] = dp[i + 1];
            }
        }

        System.out.println(dp[1]);
    }
}

public class Main {
  private static int N;

  private static class Schedule {
    int day, payDay, money;

    Schedule(int day, int payDay, int money) {
      this.day = day;
      this.payDay = payDay;
      this.money = money;
    }
  }

  private static List<List<Schedule>> schedules = new ArrayList<>();
  private static Set<Integer> payDays = new HashSet<>();
  // set 대신 schedules.size() != 0이렇게 할 수도 있음

  private static int[] dp;

  // 1주터 시작
  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//    StringTokenizer st = new StringTokenizer(br.readLine());
    N = Integer.parseInt(br.readLine());

    dp = new int[N + 1];
    dp[0] = 0;

    for (int i = 0; i <= N; i++) {
      schedules.add(new ArrayList<>());
    }

    for (int i = 1; i <= N; i++) {
      StringTokenizer st = new StringTokenizer(br.readLine());
      int day = i;
      int workDay = Integer.parseInt(st.nextToken());
      int money = Integer.parseInt(st.nextToken());

      int payDay = workDay + day -1;

      if (payDay > N) continue; // 월급날이 퇴사날 넘어가면 패스
      payDays.add(payDay);
      schedules.get(payDay).add(new Schedule(day, payDay, money));
    }

    // schdules를 payDay 기준으로 오름차순

    for (int i = 1; i <= N; i++) {

      dp[i] = Math.max(dp[i], dp[i - 1]);
      if (payDays.contains(i)) {
        for (Schedule schedule : schedules.get(i)) {
          int d = schedule.day;
          int m = schedule.money;
//          System.out.printf("day %d (ends at %d): dp[%d] = max(dp[%d], dp[%d] + %d)\n", d, i, i, i, d - 1, m);
          dp[i] = Math.max(dp[i], dp[d - 1] + m);
        }
      }
//      System.out.printf("dp[%d] = %d\n", i, dp[i]);
    }


    System.out.println(dp[N]);
  }
}

연구소

// 템플릿 및 개념 꼼꼼하게 정리하자.
// 아니면 똑같은 문제 나와도 못푼다.
public class Main {
  private static int N;
  private static int M;

  private static int[][] map;

  static class Point {
    int x, y;

    public Point(int x, int y) {
      this.x = x;
      this.y = y;
    }
  }

  private static List<Point> emptySpaces;

  // 이게 Point[] 배열로 했는데, 이걸 그 Set으로 해도 될 듯.
  // 아니면 리스트로.
  private static Point[] selected = new Point[3];

  private static int MAX_SAFE_AREA = Integer.MIN_VALUE;

  // 상, 하,
  private static int[] dx = {-1, 1, 0, 0};
  private static int[] dy = {0, 0, -1, 1};

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());

    N = Integer.parseInt(st.nextToken());
    M = Integer.parseInt(st.nextToken());
    map = new int[N][M];

    emptySpaces = new ArrayList<>();

    for (int i = 0; i < N; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 0; j < M; j++) {
        map[i][j] = Integer.parseInt(st.nextToken());
        if (map[i][j] == 0) {
          emptySpaces.add(new Point(i, j));
        }
      }
    }

    // 1. 모든 벽 세우기 조합 탐색
//    Point[] selected = new Point[3];
    combine(0,0);

    // 일단 2 섬 들을 그래프로 구해야될 것 같음.
    // 그리고 주변에
    // 완전탐색 + BFS

    System.out.println(MAX_SAFE_AREA);
  }


  private static void combine(int depth, int start) { // start가 empty spaces 인덱스
//    List<Point> emptySpaces
    if (depth == 3) {
      for (Point p : selected) {
        map[p.x][p.y] = 1;
      }

//      최대 안전지대 구하기
//      현재 벽 세워진 상태
      // 1 : 2가 확산하고
      // 2 : 확산이 끝났을 때 0의 개수
      // 3 : MAX_SAFE_AREA 보다 크면 업데이트
      simulate();

      for (Point p : selected) map[p.x][p.y] = 0;
      return;
    }

    for (int i = start; i < emptySpaces.size(); i++) {
      selected[depth] = emptySpaces.get(i);
      combine(depth + 1, i + 1);
    }
  }

  private static void simulate() {
    // map, MAX_SAFE_AREA

    // 최대 안전지대 구하기
    // 현재 벽 세워진 상태
      // 1 : 2가 확산하고 - map 복사해서 전달하기
    int[][] copy = copyOfMap();
    boolean[][] visited = new boolean[N][M];

    // 2를 전파하기
    for (int i = 0; i < N; i++) {
      for (int j = 0; j < M; j++) {
        if (copy[i][j] == 2) {
          visited[i][j] = true;
          dfs(copy, visited, i, j);
        }
      }
    }

    // 2 : 확산이 끝났을 때 0의 개수
    // 2-1 : MAX_SAFE_AREA 보다 크면 업데이트

    int area = calculateSafeArea(copy);
    if (area > MAX_SAFE_AREA) MAX_SAFE_AREA = area;


  }

  private static void dfs(int[][] copiedMap, boolean[][] visited, int x, int y) {


    for (int i = 0; i < 4; i++) {
      int nx = x + dx[i];
      int ny = y + dy[i];

      if (nx < 0 || nx >= N || ny < 0 || ny >= M || visited[nx][ny]) continue;
      if (copiedMap[nx][ny] == 1 ) continue;
      if (copiedMap[nx][ny] == 2 && !visited[nx][ny]) {
        visited[nx][ny] = true;
        dfs(copiedMap, visited, nx, ny);
      }
      if (copiedMap[nx][ny] == 0) {
        copiedMap[nx][ny] = 2;
        visited[nx][ny] = true;
        dfs(copiedMap, visited, nx, ny);
      }
    }
  }

  private static int[][] copyOfMap() {
    int[][] copy = new int[N][M];
    for (int i = 0; i < N; i++) {
      for (int j = 0; j < M; j++) {
        copy[i][j] = map[i][j];
      }
    }
    return copy;
  }

  private static int calculateSafeArea(int[][] copy) {
    int area = 0;

    for (int i = 0; i < N; i++) {
      for (int j = 0; j < M; j++) {
        if (copy[i][j] == 0) {
          area++;
        }
      }
    }
    return area;
  }

}

로봇 청소기

public class Main {

  private static int N;
  private static int M;

  private static int[][] map;
  private static boolean[][] visited;

  // 북, 동, 남, 서
  private static int[] dx = {-1, 0, 1, 0};
  private static int[] dy = {0, 1, 0, -1};

  private static int CLEANED = 0;
  private static Queue<int[]> queue = new LinkedList<>();

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    StringTokenizer st = new StringTokenizer(br.readLine());
    N = Integer.parseInt(st.nextToken());
    M = Integer.parseInt(st.nextToken());

    map = new int[N][M];
    visited = new boolean[N][M];

    st = new StringTokenizer(br.readLine());
    int r = Integer.parseInt(st.nextToken());
    int c = Integer.parseInt(st.nextToken());
    int dir = Integer.parseInt(st.nextToken());

    for (int i = 0; i < N; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 0; j < M; j++) {
        map[i][j] = Integer.parseInt(st.nextToken());
      }
    }

    queue.add(new int[]{r, c, dir});
    simulate();
    System.out.println(CLEANED);
  }

  private static void simulate() {
    while (!queue.isEmpty()) {
      int[] curr = queue.poll();
      int x = curr[0];
      int y = curr[1];
      int dir = curr[2];

      // 1. 현재 위치 청소
      if (!visited[x][y]) {
        visited[x][y] = true;
        CLEANED++;
      }

      boolean moved = false;

      // 2. 주변 4칸 탐색
      for (int i = 0; i < 4; i++) {
        dir = (dir + 3) % 4; // 반시계 회전
        int nx = x + dx[dir];
        int ny = y + dy[dir];

        if (nx >= 0 && ny >= 0 && nx < N && ny < M &&
            map[nx][ny] == 0 && !visited[nx][ny]) {
          queue.add(new int[]{nx, ny, dir});
          moved = true;
          break;
        }
      }

      // 3. 청소할 곳이 없다면 후진
      if (!moved) {
        int back = (dir + 2) % 4;
        int bx = x + dx[back];
        int by = y + dy[back];

        if (bx >= 0 && by >= 0 && bx < N && by < M && map[bx][by] != 1) {
          queue.add(new int[]{bx, by, dir}); // 방향 유지
        }
      }
    }
  }

  private static void printMap() {
    for (int i = 0; i < N; i++) {
      for (int j = 0; j < M; j++) {
        if (visited[i][j]) System.out.print("C ");
        else if (map[i][j] == 1) System.out.print("■ ");
        else System.out.print("· ");
      }
      System.out.println();
    }
  }
}

연산자 끼워넣기

public class Main {

  private static int N;
  private static int[] numbers;
  // 덧셈, 뺼셈, 곱셈, 나눗셈
  private static int[] operators = new int[4];

  private static int MAX = Integer.MIN_VALUE;
  private static int MIN = Integer.MAX_VALUE;

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    // 순서 O, 순열 이고 중복은 제한적으로
    // 탐색, 전부 탐색, DFS, 브루트포스
    // 시뮬레이션, 구현
    N = Integer.parseInt(br.readLine());
    numbers = new int[N];

    StringTokenizer st = new StringTokenizer(br.readLine());
    for (int i = 0; i < N; i++) {
      numbers[i] = Integer.parseInt(st.nextToken());
    }

    st = new StringTokenizer(br.readLine());
    for (int i = 0; i < 4; i++) {
      operators[i] = Integer.parseInt(st.nextToken()); // ✅ 올바른 방식
    }

    // 얘 같은 경우는 복사해서 넘겨줘야 할 듯.
    int[] permutation = new int[N - 1];
    simulation(operators.clone(), 0, permutation);

    System.out.println(MAX);
    System.out.println(MIN);
  }

  private static void simulation(int[] leftedOperators, int idx, int[] permutation) {
    // 연산자 4개 개수 남아있는거
//    int[] copiedOperators = leftedOperators.clone();

    if (idx >= N - 1) {
      calculate(permutation);
      return;
    }

    // 맨 위에 permutation을 또 돌았는데 그럴 필요 없음
    for (int j = 0; j < 4; j++) {
      int op = leftedOperators[j];

      if (op <= 0) continue;

      leftedOperators[j]--;
      permutation[idx] = j;

      simulation(leftedOperators, idx + 1, permutation);

      permutation[idx] = 0;
      leftedOperators[j]++;
    }

  }

  private static void calculate(int[] currOperators) {
    int sum = numbers[0];
    for (int i = 1; i < N; i++) {
      int operator = currOperators[i - 1];

      if (operator == 0) { // 덧셈
        sum = sum + numbers[i];
      } else if (operator == 1) { // 뺄셈
        sum = sum - numbers[i];
      } else if (operator == 2) { // 곱셈
        sum = sum * numbers[i];
      } else if (operator == 3) { // 나눗셈
        //  나눗셈은 정수 나눗셈으로 몫만 취한다.
        //  음수를 양수로 나눌 때는 C++14의 기준을 따른다.
        //  즉, 양수로 바꾼 뒤 몫을 취하고,
        //  그 몫을 음수로 바꾼 것과 같다.
        if (sum < 0) {
          int temp = -sum;
          int temp2 = temp / numbers[i];
          sum = -temp2;
        } else { // sum >= 0
          sum = sum / numbers[i];
        }
      }

//      if (sum > MAX) {
//        MAX = sum;
//      }
//      if (sum < MIN) {
//        MIN = sum;
//      }

    }
    MAX = Math.max(MAX, sum);
    MIN = Math.min(MIN, sum);
  }
}

스타트와 링크

public class Main {

  static int N;
  static int[][] chemistry;
  static boolean[] visited;
  static int MIN = Integer.MAX_VALUE;

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    N = Integer.parseInt(br.readLine());
    chemistry = new int[N][N];
    visited = new boolean[N];

    for (int i = 0; i < N; i++) {
      StringTokenizer st = new StringTokenizer(br.readLine());
      for (int j = 0; j < N; j++) {
        chemistry[i][j] = Integer.parseInt(st.nextToken());
      }
    }

    // 항상 0번 사람을 포함한 조합만 탐색 (대칭 제거)
    visited[0] = true;
    makeTeam(1, 1);

    System.out.println(MIN);
  }

  static void makeTeam(int idx, int count) {
    if (count == N / 2) {
      int startSum = 0;
      int linkSum = 0;

      for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {
          if (visited[i] && visited[j]) {
            startSum += chemistry[i][j] + chemistry[j][i];
          } else if (!visited[i] && !visited[j]) {
            linkSum += chemistry[i][j] + chemistry[j][i];
          }
        }
      }

      MIN = Math.min(MIN, Math.abs(startSum - linkSum));
      return;
    }

    for (int i = idx; i < N; i++) {
      visited[i] = true;
      makeTeam(i + 1, count + 1);
      visited[i] = false;
    }
  }
}

경사로

public class Main {
  static int N, L;
  static int[][] map;
  static int ANSWER = 0;

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st;

    // 입력 처리
    st = new StringTokenizer(br.readLine());
    N = Integer.parseInt(st.nextToken());
    L = Integer.parseInt(st.nextToken());

    map = new int[N][N];
    for (int i = 0; i < N; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 0; j < N; j++) {
        map[i][j] = Integer.parseInt(st.nextToken());
      }
    }

    // 행 검사
    for (int i = 0; i < N; i++) {
      if (canCross(map[i])) ANSWER++;
    }

    // 열 검사
    for (int i = 0; i < N; i++) {
      int[] col = new int[N];
      for (int j = 0; j < N; j++) {
        col[j] = map[j][i];
      }
      if (canCross(col)) ANSWER++;
    }

    System.out.println(ANSWER);
  }

  // 한 줄(행 또는 열)에서 경사로를 놓을 수 있는지 확인
  private static boolean canCross(int[] line) {
    boolean[] isUsed = new boolean[N];

    for (int i = 0; i < N - 1; i++) {
      int diff = line[i] - line[i + 1];

      if (diff == 0) continue; // 높이 같음 → 통과

      if (Math.abs(diff) > 1) return false; // 높이차 2 이상 → 불가능

      // 내려가는 경사로 (앞이 높고 뒤가 낮음)
      if (diff == 1) {
        for (int j = 1; j <= L; j++) {
          int next = i + j;
          if (next >= N || line[next] != line[i + 1] || isUsed[next]) return false;
        }
        for (int j = 1; j <= L; j++) {
          isUsed[i + j] = true;
        }
      }

      // 올라가는 경사로 (앞이 낮고 뒤가 높음)
      else if (diff == -1) {
        for (int j = 0; j < L; j++) {
          int prev = i - j;
          if (prev < 0 || line[prev] != line[i] || isUsed[prev]) return false;
        }
        for (int j = 0; j < L; j++) {
          isUsed[i - j] = true;
        }
      }
    }
    return true;
  }
}

톱니바퀴

// 구현, 시뮬레이션
public class Main {
//  N극 : 0, S극 : 1
//  시계방향 : 1, 반시계 : -1
  private static List<List<Integer>> cogWheel = new ArrayList<>();

  private static int K;

  private static Map<Integer, int[]> turns = new HashMap<>();

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    for (int i = 0; i < 4; i++) {
      cogWheel.add(new ArrayList<>());
    }

    for (int i = 0; i < 4; i++) {
      String line = br.readLine();  // 공백 없는 문자열
      for (int j = 0; j < 8; j++) {
        cogWheel.get(i).add(line.charAt(j) - '0');  // '0' → 0, '1' → 1로 변환
      }
    }

    K = Integer.parseInt(br.readLine());

    for (int i  = 0; i < K; i++) {
      StringTokenizer st = new StringTokenizer(br.readLine());

      // 톱니바퀴 번호
      int a = Integer.parseInt(st.nextToken());
      // 회전 방향
      int b = Integer.parseInt(st.nextToken());

      turns.put(i, new int[]{a-1, b});
    }

    // 1. 명령 실행 K회
    for (int[] info : turns.values()) {
      int number = info[0];
      int dir = info[1];

      //  N극 : 0, S극 : 1
      //  시계방향 : 1, 반시계 : -1

      // simulation
      simulation(number, dir);
    }

    // 점수 계산 함수
    System.out.println(getScore());
  }


private static void simulation(int startIndex, int startDir) {
  int[] rotateDir = new int[4]; // 0 = 회전 안함, 1 = 시계, -1 = 반시계
  rotateDir[startIndex] = startDir;

  // 왼쪽 방향 확인
  for (int i = startIndex; i > 0; i--) {
    if (cogWheel.get(i).get(6) != cogWheel.get(i - 1).get(2)) {
      rotateDir[i - 1] = -rotateDir[i];
    } else {
      break;
    }
  }

  // 오른쪽 방향 확인
  for (int i = startIndex; i < 3; i++) {
    if (cogWheel.get(i).get(2) != cogWheel.get(i + 1).get(6)) {
      rotateDir[i + 1] = -rotateDir[i];
    } else {
      break;
    }
  }

  // 회전 실행
  for (int i = 0; i < 4; i++) {
    if (rotateDir[i] != 0) {
      rotate(i, rotateDir[i]);
    }
  }
}


  private static void rotate(int number, int dir) {
//    List<Integer> l = cogWheel.get(number);

    if (dir == 1) { // 시계 방향
      int last = cogWheel.get(number).remove(cogWheel.get(number).size() - 1);
      cogWheel.get(number).add(0, last);
    }
    else { // 반시계 방향
      int first = cogWheel.get(number).remove(0);
      cogWheel.get(number).add(first);
    }
  }

  private static int getScore() {
    int score = 0;
    if (cogWheel.get(0).get(0) == 1) score += 1;
    if (cogWheel.get(1).get(0) == 1) score += 2;
    if (cogWheel.get(2).get(0) == 1) score += 4;
    if (cogWheel.get(3).get(0) == 1) score += 8;
    return score;
  }
}

감시

import java.io.*;
import java.util.*;

public class Main {
    static int N, M;
    static int[][] map;
    static List<CCTV> cctvs = new ArrayList<>();
    static int min = Integer.MAX_VALUE;

    // ↑, →, ↓, ←
    static int[] dx = {-1, 0, 1, 0};
    static int[] dy = {0, 1, 0, -1};

    // 각 CCTV 타입별 방향 조합
    static int[][][] dirs = {
        {}, // index 0은 없음
        {{0}, {1}, {2}, {3}},                        // 1번 CCTV
        {{0, 2}, {1, 3}},                            // 2번 CCTV
        {{0, 1}, {1, 2}, {2, 3}, {3, 0}},            // 3번 CCTV
        {{0, 1, 2}, {1, 2, 3}, {2, 3, 0}, {3, 0, 1}}, // 4번 CCTV
        {{0, 1, 2, 3}}                               // 5번 CCTV
    };

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        // 입력
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());

        map = new int[N][M];
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < M; j++) {
                map[i][j] = Integer.parseInt(st.nextToken());
                if (1 <= map[i][j] && map[i][j] <= 5) {
                    cctvs.add(new CCTV(i, j, map[i][j]));
                }
            }
        }

        // 탐색 시작
        dfs(0, map);
        System.out.println(min);
    }

    static void dfs(int depth, int[][] map) {
        if (depth == cctvs.size()) {
            min = Math.min(min, countBlindSpot(map));
            return;
        }

        CCTV cctv = cctvs.get(depth);
        int[][] directionOptions = dirs[cctv.type];

        for (int[] dirSet : directionOptions) {
            int[][] copiedMap = copyMap(map);
            for (int dir : dirSet) {
                monitor(copiedMap, cctv.x, cctv.y, dir);
            }
            dfs(depth + 1, copiedMap);
        }
    }

    static void monitor(int[][] map, int x, int y, int dir) {
        int nx = x, ny = y;
        while (true) {
            nx += dx[dir];
            ny += dy[dir];

            if (nx < 0 || ny < 0 || nx >= N || ny >= M) break;
            if (map[nx][ny] == 6) break; // 벽

            if (map[nx][ny] == 0) map[nx][ny] = 7; // 감시 마킹
        }
    }

    static int[][] copyMap(int[][] src) {
        int[][] newMap = new int[N][M];
        for (int i = 0; i < N; i++) {
            newMap[i] = src[i].clone(); // 배열 깊은 복사
        }
        return newMap;
    }

    static int countBlindSpot(int[][] map) {
        int cnt = 0;
        for (int[] row : map) {
            for (int val : row) {
                if (val == 0) cnt++;
            }
        }
        return cnt;
    }

    static class CCTV {
        int x, y, type;

        CCTV(int x, int y, int type) {
            this.x = x;
            this.y = y;
            this.type = type;
        }
    }
}

사다리 조작

public class Main {
  static int N, M, H;

  static boolean result = false;
  static int ANSWER = -1;

  static int[][] ladder;
  static boolean[][] visited;

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    StringTokenizer st = new StringTokenizer(br.readLine());
    N = Integer.parseInt(st.nextToken()); // 세로 y
    M = Integer.parseInt(st.nextToken()); // 사다리 개수
    H = Integer.parseInt(st.nextToken()); // 가로 x

    ladder = new int[H+1][N+1];
    visited = new boolean[H+1][N+1];

    for (int i = 0; i < M; i++) {
      st = new StringTokenizer(br.readLine());
      int a = Integer.parseInt(st.nextToken());
      int b = Integer.parseInt(st.nextToken());

      ladder[a][b] = b+1;
      ladder[a][b+1] = b;
      // (1, 1) 이면 true이고, 이때 2와 연결
      // (2, 1)도 포함이고, 이때 1과 연결

      // 만약 (2, 3)이면 true 이고, 이때 3과 연결
      // (3, 3)도 true이고 이때 2와 연결_

      // ladder[2][3] = 3
      // ladder[3][2] = 2

      visited[a][b] = true;
      visited[a][b+1] = true;
      // visited[x][y] = true
      // visited[x+1][y] = true
    }

    for (int i = 0; i < 4; i++) { // 놓을 수 있는 사다리 개수
      if (!result) {

        dfs(i, 0);
      }
    }

    System.out.println(ANSWER);
  }

  static void dfs(int ladderCnt, int idx) {
    if (ladderCnt == idx) {

      if (!result && checkResult()) {

        result = true;
        ANSWER = ladderCnt;
      }
      return;
    }

    for (int i = 1; i < N; i++) {
      for (int j = 1; j <= H; j++) {
        if (!visited[j][i]  && !visited[j][i+1]  &&!result) {
          visited[j][i] = true;
          visited[j][i+1] = true;
          ladder[j][i] = i+1;
          ladder[j][i+1] = i;
          dfs(ladderCnt, idx+1);
          visited[j][i] = false;
          visited[j][i+1] = false;
        }
      }
    }
  }

  static boolean checkResult(){

    for (int i = 1; i <= N; i++) { // 세로 선 체크
      int start = i;
      int end = i;
      for (int j = 1; j <= H; j++) { // 가로 축 즉, x 사다리 내려감
        if (visited[j][end]) { // 사다리가 존재
            end = ladder[j][end];
        }
      }
      if (start != end) {

        return false;
      }
    }

    return true;
  }
}

드래곤 커브

public class Main {

  private static int N;

  private static boolean[][] visited = new boolean[101][101];

  private static int ANSWER = 0;

  // 0, 1, 2, 3 : 우, 상, 좌, 하
  private static int[] dx = {1, 0, -1, 0};
  private static int[] dy = {0, -1, 0, 1};


  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    StringTokenizer st = new StringTokenizer(br.readLine());
    N = Integer.parseInt(st.nextToken());

    for (int i = 0; i < N; i++) {
      st = new StringTokenizer(br.readLine());
      int x = Integer.parseInt(st.nextToken());
      int y = Integer.parseInt(st.nextToken());
      int d = Integer.parseInt(st.nextToken());
      int g = Integer.parseInt(st.nextToken());

      setDragon(x, y, d, g);
    }
    counting();
    System.out.println(ANSWER);
  }

  private static void setDragon(int x, int y, int d, int g) {
    List<Integer> directions = new ArrayList<>();
    directions.add(d);  // 0세대

    for (int i = 0; i < g; i++) {
      int size = directions.size();
      for (int j = size - 1; j >= 0; j--) {
        directions.add((directions.get(j) + 1) % 4);
      }
    }

    visited[y][x] = true;
    for (int dir : directions) {
      x += dx[dir];
      y += dy[dir];
      if (x >= 0 && x <= 100 && y >= 0 && y <= 100)
        visited[y][x] = true;
    }
  }

  private static void counting() {
    for (int i = 0; i < 100; i++) {
      for (int j = 0; j < 100; j++) {
        if (visited[i][j] && visited[i][j + 1] && visited[i + 1][j + 1] && visited[i + 1][j]) {
          ANSWER++;
        }
      }
    }
  }
}

치킨 배달

// 조합, DFS
// 구현
public class Main {

  static int N, M;
  static int[][] map;

  static int MIN = Integer.MAX_VALUE;

  static LinkedList<int[]> houses = new LinkedList<>();
  static LinkedList<int[]> chickens = new LinkedList<>();

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st;
    st = new StringTokenizer(br.readLine());

    N = Integer.parseInt(st.nextToken());
    M = Integer.parseInt(st.nextToken());

    map = new int[N + 1][N + 1];

    for (int i = 0; i < N; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 1; j <= N; j++) {
        map[i][j] = Integer.parseInt(st.nextToken());

        if (map[i][j] == 1) {
          houses.add(new int[]{i, j});
        }
        if (map[i][j] == 2) {
          chickens.add(new int[]{i, j});
        }
      }
    }

    List<int[]> selectedChicken = new ArrayList<>();
    combine(0, selectedChicken);
    System.out.println(MIN);
  }

  private static void combine(int idx, List<int[]> selectedChicken) {
    if (selectedChicken.size() == M) { // depth도 안넣어도 될 것 같은데?
      int total = calculateCityChickenDistance(selectedChicken);
      MIN = Math.min(total, MIN);
      return;
    }

    for (int i = idx; i < chickens.size(); i++) {
      selectedChicken.add(chickens.get(i));
      combine(i + 1, selectedChicken);
      selectedChicken.remove(selectedChicken.size() - 1);
    }
  }

  private static int calculateCityChickenDistance(List<int[]> selectedChicken) {
    int cityMinDistance = 0;

    for (int i = 0; i < houses.size(); i++) {
      int x = houses.get(i)[0];
      int y = houses.get(i)[1];
      int dist = Integer.MAX_VALUE;

      for (int[] chickenShop : selectedChicken) {
        int cx = chickenShop[0];
        int cy = chickenShop[1];
        int temp = Math.abs(x - cx) + Math.abs(y - cy);

        if (temp < dist) dist = temp;
      }
      cityMinDistance += dist;
    }
    return cityMinDistance;
  }
}

큐빙

public class Main {

	static char[] Qube, colors;
	static int[][] change;
	static StringTokenizer st;

	public static void main(String[] args) throws Exception {

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		int T = Integer.parseInt(br.readLine());
		for (int t = 1; t <= T; t++) {
			int N = Integer.parseInt(br.readLine());

			// 큐브 초기화
			Qube = new char[] { 'w', 'w', 'w', 'w', 'w', 'w', 'w', 'w', 'w', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g',
					'g', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'o',
					'o', 'o', 'o', 'o', 'o', 'o', 'o', 'o', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y', 'y' };
			colors = new char[] { 'w', 'g', 'r', 'b', 'o', 'y' };

			int colorIdx = 0;
			int idx = 0;

			change = new int[][] { { 38, 37, 36, 29, 28, 27, 20, 19, 18, 11, 10, 9 }, // U - w (흰)
					{ 0, 3, 6, 18, 21, 24, 45, 48, 51, 44, 41, 38 }, // L - g (초록)
					{ 6, 7, 8, 27, 30, 33, 47, 46, 45, 17, 14, 11 }, // F - r (빨간)
					{ 8, 5, 2, 36, 39, 42, 53, 50, 47, 26, 23, 20 }, // R - b (파란)
					{ 2, 1, 0, 9, 12, 15, 51, 52, 53, 35, 32, 29 }, // B - o (오렌지)
					{ 24, 25, 26, 33, 34, 35, 42, 43, 44, 15, 16, 17 } // D - y (노랑)
			};

			st = new StringTokenizer(br.readLine());

			for (int i = 0; i < N; i++) {
				String command = st.nextToken();
				char c = command.charAt(0); // U, L, F, R, B, D
				char d = command.charAt(1); // -, +

				int changeIdx = 0;
				int cnt;
				if (d == '+') {
					cnt = 1;
				} else {
					cnt = 3;
				}
				if (c == 'U') {
					changeIdx = 0;
				} else if (c == 'L') {
					changeIdx = 1;
				} else if (c == 'F') {
					changeIdx = 2;
				} else if (c == 'R') {
					changeIdx = 3;
				} else if (c == 'B') {
					changeIdx = 4;
				} else if (c == 'D') {
					changeIdx = 5;
				}

				change_qube(changeIdx, cnt);

			}
			for (int f = 0; f < 9; f++) {
				System.out.print(Qube[f]);
				if (f % 3 == 2) {
					System.out.println();
				}

			}
		}
	}

	static void change_qube(int changeIdx, int cnt) {

		for (int i = 0; i < cnt; i++) {

//			fourSide(changeIdx);
			// 다른 쪽 면 4방향의 1줄씩 회전
			char temp1 = Qube[change[changeIdx][9]];
			char temp2 = Qube[change[changeIdx][10]];
			char temp3 = Qube[change[changeIdx][11]];

			for (int j = 3; j > 0; j--) {
				Qube[change[changeIdx][j * 3 + 0]] = Qube[change[changeIdx][(j - 1) * 3 + 0]];
				Qube[change[changeIdx][j * 3 + 1]] = Qube[change[changeIdx][(j - 1) * 3 + 1]];
				Qube[change[changeIdx][j * 3 + 2]] = Qube[change[changeIdx][(j - 1) * 3 + 2]];
			}
			Qube[change[changeIdx][0]] = temp1;
			Qube[change[changeIdx][1]] = temp2;
			Qube[change[changeIdx][2]] = temp3;

//			fourSide(changeIdx);
//			nowSide(changeIdx);
			// 현재 해당하는 면 회전
			temp1 = Qube[changeIdx * 9 + 2];
			temp2 = Qube[changeIdx * 9 + 1];
			temp3 = Qube[changeIdx * 9];

			Qube[changeIdx * 9 + 2] = Qube[changeIdx * 9];
			Qube[changeIdx * 9 + 1] = Qube[changeIdx * 9 + 3];
			Qube[changeIdx * 9] = Qube[changeIdx * 9 + 6];

			Qube[changeIdx * 9] = Qube[changeIdx * 9 + 6];
			Qube[changeIdx * 9 + 3] = Qube[changeIdx * 9 + 7];
			Qube[changeIdx * 9 + 6] = Qube[changeIdx * 9 + 8];

			Qube[changeIdx * 9 + 6] = Qube[changeIdx * 9 + 8];
			Qube[changeIdx * 9 + 7] = Qube[changeIdx * 9 + 5];
			Qube[changeIdx * 9 + 8] = Qube[changeIdx * 9 + 2];

			Qube[changeIdx * 9 + 8] = temp1;
			Qube[changeIdx * 9 + 5] = temp2;
			Qube[changeIdx * 9 + 2] = temp3;

//			nowSide(changeIdx);

		}

	}

}

인구 이동

public class Main {
  static int N, L, R;

  static int[][] A;
  static boolean[][] visited;

  static final int[] dr = {-1, 1, 0, 0};
  static final int[] dc = {0, 0, -1, 1};

  static boolean moved = false;

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());
    N = Integer.parseInt(st.nextToken());
    L = Integer.parseInt(st.nextToken());
    R = Integer.parseInt(st.nextToken());

    A = new int[N][N];
    for (int i = 0; i < N; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 0; j < N; j++) A[i][j] = Integer.parseInt(st.nextToken());
    }

    int days = 0;
    while (true) {
      bfs();
      if (!moved) break;
      days++;
    }
    System.out.println(days);
  }

  private static void bfs() {
    visited = new boolean[N][N]; // 이거 그냥 매번 그 체크체크
    moved  = false; // 여기가 키포인트?

    for (int r = 0; r < N; r++) {
      for (int c = 0; c < N; c++) {
        if (visited[r][c]) continue;

        // BFS로 연합 찾기
//          Queue<int[]> q = new ArrayDeque<>();
        ArrayDeque<int[]> q = new ArrayDeque<>();
        ArrayList<int[]> union = new ArrayList<>();

        visited[r][c] = true;
        q.add(new int[]{r, c});
        union.add(new int[]{r, c});
        int sum = A[r][c];

        while (!q.isEmpty()) {
          int[] cur = q.poll();
          int cr = cur[0], cc = cur[1];

          for (int d = 0; d < 4; d++) {
            int nr = cr + dr[d];
            int nc = cc + dc[d];

            if (nr < 0 || nr >= N || nc < 0 || nc >= N || visited[nr][nc]) continue;

            int diff = Math.abs(A[cr][cc] - A[nr][nc]);
            if (L <= diff && diff <= R) {
              visited[nr][nc] = true;
              q.add(new int[]{nr, nc});
              union.add(new int[]{nr, nc});
              sum += A[nr][nc];
            }
          }
        }

        if (union.size() > 1) {
          moved = true;
          int avg = sum / union.size();
          for (int[] cell : union) {
            A[cell[0]][cell[1]] = avg;
          }
        }
        
      }
    }
  }
}

나무 재테크

import java.io.*;
import java.util.*;

public class Main {
  static int N, M, K;
  static int[][] A, land;
  static LinkedList<Integer>[][] trees;
  static int[] dx = {-1, -1, -1, 0, 0, 1, 1, 1};
  static int[] dy = {-1, 0, 1, -1, 1, -1, 0, 1};

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());
    N = Integer.parseInt(st.nextToken());
    M = Integer.parseInt(st.nextToken());
    K = Integer.parseInt(st.nextToken());

    A = new int[N+1][N+1];
    land = new int[N+1][N+1];
    trees = new LinkedList[N+1][N+1];

    for (int i = 1; i <= N; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 1; j <= N; j++) {
        A[i][j] = Integer.parseInt(st.nextToken());
        land[i][j] = 5; // 초기 양분
        trees[i][j] = new LinkedList<>();
      }
    }

    for (int i = 0; i < M; i++) {
      st = new StringTokenizer(br.readLine());
      int x = Integer.parseInt(st.nextToken());
      int y = Integer.parseInt(st.nextToken());
      int z = Integer.parseInt(st.nextToken());
      trees[x][y].add(z);
    }

    for (int year = 0; year < K; year++) {
      springAndSummer();
      autumn();
      winter();
    }

    System.out.println(countTrees());
  }

  static void springAndSummer() {
    for (int i = 1; i <= N; i++) {
      for (int j = 1; j <= N; j++) {
        if (trees[i][j].isEmpty()) continue;

        LinkedList<Integer> alive = new LinkedList<>();
        int deadNutrients = 0;

        for (Iterator<Integer> it = trees[i][j].iterator(); it.hasNext();) {
          int age = it.next();
          if (land[i][j] >= age) {
            land[i][j] -= age;
            alive.add(age + 1);
          } else {
            deadNutrients += age / 2;
          }
        }

        trees[i][j] = alive;
        land[i][j] += deadNutrients;
      }
    }
  }

  static void autumn() {
    for (int i = 1; i <= N; i++) {
      for (int j = 1; j <= N; j++) {
        if (trees[i][j].isEmpty()) continue;

        for (int age : trees[i][j]) {
          if (age % 5 == 0) {
            for (int d = 0; d < 8; d++) {
              int nx = i + dx[d];
              int ny = j + dy[d];
              if (nx >= 1 && ny >= 1 && nx <= N && ny <= N) {
                trees[nx][ny].addFirst(1); // 어린 나무 앞에 추가
              }
            }
          }
        }
      }
    }
  }

  static void winter() {
    for (int i = 1; i <= N; i++) {
      for (int j = 1; j <= N; j++) {
        land[i][j] += A[i][j];
      }
    }
  }

  static int countTrees() {
    int count = 0;
    for (int i = 1; i <= N; i++) {
      for (int j = 1; j <= N; j++) {
        count += trees[i][j].size();
      }
    }
    return count;
  }
}

아기 상어

import java.io.*;
import java.util.*;

public class Main {

    static int N;
    static int[][] map;
    static int sharkX, sharkY, sharkSize = 2, eatCount = 0;
    static int time = 0;
    
    static int[] dx = {-1, 0, 0, 1}; // 위, 왼, 오른, 아래 (위/왼 우선)
    static int[] dy = {0, -1, 1, 0};

    static class Fish implements Comparable<Fish> {
        int x, y, dist;
        Fish(int x, int y, int dist) {
            this.x = x;
            this.y = y;
            this.dist = dist;
        }

        @Override
        public int compareTo(Fish o) {
            // 거리 → 가장 위(x) → 가장 왼(y)
            if (this.dist == o.dist) {
                if (this.x == o.x) return this.y - o.y;
                return this.x - o.x;
            }
            return this.dist - o.dist;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());
        map = new int[N][N];

        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                map[i][j] = Integer.parseInt(st.nextToken());
                if (map[i][j] == 9) {
                    sharkX = i;
                    sharkY = j;
                    map[i][j] = 0; // 아기상어 초기 위치를 0으로
                }
            }
        }

        while (true) {
            Fish fish = bfs();
            if (fish == null) break; // 더 이상 먹을 물고기 없음
            sharkX = fish.x;
            sharkY = fish.y;
            time += fish.dist;

            // 물고기 먹음
            map[sharkX][sharkY] = 0;
            eatCount++;
            if (eatCount == sharkSize) { // 성장
                sharkSize++;
                eatCount = 0;
            }
        }

        System.out.println(time);
    }

    static Fish bfs() {
        boolean[][] visited = new boolean[N][N];
        Queue<int[]> q = new LinkedList<>();
        q.add(new int[]{sharkX, sharkY, 0});
        visited[sharkX][sharkY] = true;

        List<Fish> fishes = new ArrayList<>();

        while (!q.isEmpty()) {
            int[] cur = q.poll();
            int x = cur[0], y = cur[1], dist = cur[2];

            for (int dir = 0; dir < 4; dir++) {
                int nx = x + dx[dir];
                int ny = y + dy[dir];

                if (nx < 0 || ny < 0 || nx >= N || ny >= N) continue;
                if (visited[nx][ny]) continue;
                if (map[nx][ny] > sharkSize) continue; // 지나갈 수 없음

                visited[nx][ny] = true;
                if (map[nx][ny] != 0 && map[nx][ny] < sharkSize) {
                    // 먹을 수 있는 물고기
                    fishes.add(new Fish(nx, ny, dist + 1));
                }
                q.add(new int[]{nx, ny, dist + 1});
            }
        }

        if (fishes.isEmpty()) return null;

        Collections.sort(fishes);
        return fishes.get(0);
    }
}

미세먼지 안녕!

import java.io.*;
import java.util.*;

public class Main {
  static int R, C, T;
  static int[][] room;
  static int upperCleanerX, lowerCleanerX; // 공기청정기 윗부분, 아랫부분 행 좌표

  // 상, 하, 좌, 우
  static int[] dx = {-1, 1, 0, 0};
  static int[] dy = {0, 0, -1, 1};

  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());
    C = Integer.parseInt(st.nextToken());
    T = Integer.parseInt(st.nextToken());

    // 1-based index 사용 → +1
    room = new int[R + 1][C + 1];

    boolean foundUpper = false;
    for (int i = 1; i <= R; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 1; j <= C; j++) {
        room[i][j] = Integer.parseInt(st.nextToken());
        if (room[i][j] == -1) {
          if (!foundUpper) {
            upperCleanerX = i;
            foundUpper = true;
          } else {
            lowerCleanerX = i;
          }
        }
      }
    }

    while (T-- > 0) {
      spreadDust();
      cleanAir();
    }

    System.out.println(countDust());
  }

  // 1. 먼지 확산
  static void spreadDust() {
    int[][] temp = new int[R + 1][C + 1];

    // 공기청정기 위치 유지
    temp[upperCleanerX][1] = -1;
    temp[lowerCleanerX][1] = -1;

    for (int x = 1; x <= R; x++) {
      for (int y = 1; y <= C; y++) {
        if (room[x][y] > 0) {
          int spreadAmount = room[x][y] / 5;
          int spreadCount = 0;

          for (int dir = 0; dir < 4; dir++) {
            int nx = x + dx[dir];
            int ny = y + dy[dir];

            if (nx < 1 || nx > R || ny < 1 || ny > C) continue;
            if (room[nx][ny] == -1) continue; // 공기청정기 위치 제외

            temp[nx][ny] += spreadAmount;
            spreadCount++;
          }
          temp[x][y] += room[x][y] - (spreadAmount * spreadCount);
        }
      }
    }
    room = temp;
  }

  // 2. 공기청정기 작동
  static void cleanAir() {
    // 위쪽 공기청정기 - 반시계
    for (int x = upperCleanerX - 1; x > 1; x--) room[x][1] = room[x - 1][1];
    for (int y = 1; y < C; y++) room[1][y] = room[1][y + 1];
    for (int x = 1; x < upperCleanerX; x++) room[x][C] = room[x + 1][C];
    for (int y = C; y > 2; y--) room[upperCleanerX][y] = room[upperCleanerX][y - 1];
    room[upperCleanerX][2] = 0;

    // 아래쪽 공기청정기 - 시계
    for (int x = lowerCleanerX + 1; x < R; x++) room[x][1] = room[x + 1][1];
    for (int y = 1; y < C; y++) room[R][y] = room[R][y + 1];
    for (int x = R; x > lowerCleanerX; x--) room[x][C] = room[x - 1][C];
    for (int y = C; y > 2; y--) room[lowerCleanerX][y] = room[lowerCleanerX][y - 1];
    room[lowerCleanerX][2] = 0;
  }

  // 3. 남아 있는 먼지 양 합계
  static int countDust() {
    int sum = 0;
    for (int i = 1; i <= R; i++) {
      for (int j = 1; j <= C; j++) {
        if (room[i][j] > 0) sum += room[i][j];
      }
    }
    return sum;
  }
}

낚시왕

public class Main {

  static int R, C, M;
  static int[][] map;

  static class Shark {

    int idx;
    int x, y;
    int speed, dir, size;

    Shark(int idx, int x, int y, int speed, int dir, int size) {
      this.idx = idx;
      this.x = x;
      this.y = y;
      this.speed = speed;
      this.dir = dir;
      this.size = size;
    }
  }

  static Shark[] sharks;

  static int result = 0;

  //  static int[] dx = {-1, 0, 1, 0};
//  static int[] dy = {0, 1, 0, -1};
  static int[] dx = {0, -1, 1, 0, 0}; // 1=위, 2=아래, 3=오른쪽, 4=왼쪽
  static int[] dy = {0, 0, 0, 1, -1};


  // 상어 : x, y,dir,  size, speed
  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());
    C = Integer.parseInt(st.nextToken());
    M = Integer.parseInt(st.nextToken());

    map = new int[R + 1][C + 1]; // 기본은 0이다.
    sharks = new Shark[M + 1];

    for (int i = 1; i <= M; i++) {
      // i번 상어
      st = new StringTokenizer(br.readLine());
      int x = Integer.parseInt(st.nextToken());
      int y = Integer.parseInt(st.nextToken());
      int speed = Integer.parseInt(st.nextToken());
      int dir = Integer.parseInt(st.nextToken());
      int size = Integer.parseInt(st.nextToken());

      sharks[i] = new Shark(i, x, y, speed, dir, size);
      map[x][y] = i;
    }

    // 1. 낚시왕이 오른쪽으로 한 칸 이동한다.
    // 2. 낚시왕이 있는 열에 있는 상어 중에서 땅과 제일 가까운 상어를 잡는다.
    // 상어를 잡으면 격자판에서 잡은 상어가 사라진다.
    // 상어가 이동한다.

    // 1부터 C까지
    for (int i = 1; i <= C; i++) {
      // y => i
      fishing(i);
      swimming();
    }

    System.out.println(result);
  }

  static void fishing(int y) {
    for (int i = 1; i <= R; i++) {
      if (map[i][y] != 0) { // 상어가 존재
        result += sharks[map[i][y]].size;
        sharks[map[i][y]] = null; // 잡힌 상어 제거
        map[i][y] = 0;
        break;
      }
    }
  }

  static void swimming() {
    int[][] newMap = new int[R + 1][C + 1];

    for (int i = 1; i <= M; i++) {
      Shark s = sharks[i];
      if (s == null) {
        continue; // 이미 잡힌 상어
      }

      // 1. 이동 거리 최적화
      int dist = s.speed;
      if (s.dir <= 2) {
        dist %= (R - 1) * 2; // 위/아래
      } else {
        dist %= (C - 1) * 2; // 좌/우
      }

      int x = s.x;
      int y = s.y;
      int d = s.dir;

      // 2. 이동
      while (dist-- > 0) {
        int nx = x + dx[d];
        int ny = y + dy[d];

        if (nx < 1 || nx > R || ny < 1 || ny > C) {
          // 방향 반전
          if (d == 1) {
            d = 2;
          } else if (d == 2) {
            d = 1;
          } else if (d == 3) {
            d = 4;
          } else {
            d = 3;
          }

          nx = x + dx[d];
          ny = y + dy[d];
        }
        x = nx;
        y = ny;
      }

      s.x = x;
      s.y = y;
      s.dir = d;

      // 3. 겹치는 상어 처리
      if (newMap[x][y] == 0) {
        newMap[x][y] = i;
      } else {
        int otherIdx = newMap[x][y];
        if (sharks[otherIdx].size < s.size) {
          sharks[otherIdx] = null; // 작은 상어 제거
          newMap[x][y] = i;
        } else {
          sharks[i] = null; // 내가 작으면 제거
        }
      }
    }

    map = newMap; // 맵 갱신
  }

}

이차원 배열과 연산

import java.io.*;
import java.util.*;

public class Main {

  static int R, C, K;

  public static void main(String[] args) throws Exception {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());

    R = Integer.parseInt(st.nextToken()); // 1-based
    C = Integer.parseInt(st.nextToken()); // 1-based
    K = Integer.parseInt(st.nextToken());

    int[][] A = new int[3][3];
    for (int i = 0; i < 3; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 0; j < 3; j++) {
        A[i][j] = Integer.parseInt(st.nextToken());
      }
    }

    int t = 0;
    while (t <= 100) {
      if (inRange(A, R-1, C-1) && A[R-1][C-1] == K) {
        System.out.println(t);
        return;
      }

      if (A.length >= A[0].length) A = opR(A);
      else A = opC(A);

      t++;
    }
    System.out.println(-1);
  }

  // R 연산: 각 "행"을 정렬 → 행 수는 그대로, 열 길이는 행별 최대 길이로
  static int[][] opR(int[][] A) {
    int rows = A.length, cols = A[0].length;

    List<List<Integer>> rowsList = new ArrayList<>();
    int maxLen = 0;

    for (int i = 0; i < rows; i++) {
      List<Integer> flat = countSortLine(A[i]);
      if (flat.size() > 100) flat = flat.subList(0, 100);
      rowsList.add(flat);
      maxLen = Math.max(maxLen, flat.size());
    }
    maxLen = Math.min(maxLen, 100); // 문제 조건

    int[][] B = new int[rows][Math.max(1, maxLen)];
    for (int i = 0; i < rows; i++) {
      List<Integer> flat = rowsList.get(i);
      int len = Math.min(flat.size(), B[0].length);
      for (int j = 0; j < len; j++) B[i][j] = flat.get(j);
    }
    return B;
  }

  // C 연산: 각 "열"을 정렬 → 열 수는 그대로, 행 길이는 열별 최대 길이로
  static int[][] opC(int[][] A) {
    int rows = A.length, cols = A[0].length;

    List<List<Integer>> colsList = new ArrayList<>();
    int maxLen = 0;

    for (int j = 0; j < cols; j++) {
      int[] col = new int[rows];
      for (int i = 0; i < rows; i++) col[i] = A[i][j];

      List<Integer> flat = countSortLine(col);
      if (flat.size() > 100) flat = flat.subList(0, 100);
      colsList.add(flat);
      maxLen = Math.max(maxLen, flat.size());
    }
    maxLen = Math.min(maxLen, 100);

    int[][] B = new int[Math.max(1, maxLen)][cols];
    for (int j = 0; j < cols; j++) {
      List<Integer> flat = colsList.get(j);
      int len = Math.min(flat.size(), B.length);
      for (int i = 0; i < len; i++) B[i][j] = flat.get(i); // 세로로 채움(중요)
    }
    return B;
  }

  // 한 줄(행 or 열)을 “숫자-빈도”로 압축 후 정렬(빈도↑, 숫자↑) → [수,횟수,수,횟수,...]
  static List<Integer> countSortLine(int[] line) {
    Map<Integer, Integer> freq = new HashMap<>();
    for (int v : line) if (v != 0) freq.merge(v, 1, Integer::sum); // 0 제외

    List<int[]> pairs = new ArrayList<>();
    for (Map.Entry<Integer, Integer> e : freq.entrySet()) {
      pairs.add(new int[]{e.getKey(), e.getValue()});
    }
    pairs.sort((a, b) -> {
      if (a[1] != b[1]) return a[1] - b[1]; // 빈도 오름차순
      return a[0] - b[0]; // 수 오름차순
    });

    List<Integer> flat = new ArrayList<>(pairs.size() * 2);
    for (int[] p : pairs) {
      flat.add(p[0]);
      flat.add(p[1]);
    }
    return flat;
    // 길이 100 제한은 호출부에서 자릅니다.
  }

  static boolean inRange(int[][] A, int r, int c) {
    return 0 <= r && r < A.length && 0 <= c && c < A[0].length;
  }
}

연구소 3

public class Main {

  static int N, M;

  static int[] dx = {-1, 0, 1, 0};
  static int[] dy = {0, -1, 0, 1};

  static int min = Integer.MAX_VALUE;

  static List<int[]> unActivatedVirus = new ArrayList<>();
  static Stack<int[]> activatedVirus = new Stack<>();

  static int[][] map;
  static boolean[][] visited;

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());

    N = Integer.parseInt(st.nextToken());
    M = Integer.parseInt(st.nextToken());

    map = new int[N][N];
    visited = new boolean[N][N];

    for (int i = 0; i < N; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 0; j < N; j++) {
        int x = Integer.parseInt(st.nextToken());
        if (x == 1) visited[i][j] = true;
        if (x == 2) unActivatedVirus.add(new int[]{i, j});
        map[i][j] = x;
      }
    }

    combine(0, 0);

//    checkFinished()
    if (min == Integer.MAX_VALUE) min = -1;
    System.out.println(min);
  }

  // 여기 순열 아니니까, start idx 넣어주어야 함
  static void combine(int start, int size) {

    if (size == M) {
      int[][] timeMap = copyMap();
//      boolean[][] newVisited = visited;

      boolean[][] newVisited = new boolean[N][N];
      for (int i = 0; i < N; i++) {
        System.arraycopy(visited[i], 0, newVisited[i], 0, N);
      }
      spreadVirus(timeMap, newVisited);
      int totalTime = getTime(timeMap);
      if (totalTime != -1 && totalTime < min) min = totalTime;
      return;
    }

    for (int i = start; i < unActivatedVirus.size(); i++) {
      int[] virus = unActivatedVirus.get(i); // {1, 2}
      if (visited[virus[0]][virus[1]]) continue; // 이미 선택된 경우 패스, 중복 선택 안됨
      visited[virus[0]][virus[1]] = true;
      activatedVirus.add(virus);
      combine(i+1, size + 1);
      visited[virus[0]][virus[1]] = false;
      activatedVirus.pop();
    }
  }

  static void spreadVirus(int[][] timeMap, boolean[][] newVisited) {

    Queue<int[]> q = new LinkedList<>();

    for (int i = 0; i < activatedVirus.size(); i++) {
      int[] virus = activatedVirus.get(i);
      q.add(new int[]{virus[0], virus[1], 0});
    }

    while (!q.isEmpty()) {
      int[] virus = q.poll();

      int x = virus[0];
      int y = virus[1];
      int time = virus[2];

      for (int i = 0; i < 4; i++) {
        int newX = x + dx[i];
        int newY = y + dy[i];

        if (newX < 0 || newX >= N || newY < 0 || newY >= N || newVisited[newX][newY]) continue;

        if (map[newX][newY] == 0) {
          newVisited[newX][newY] = true;
          timeMap[newX][newY] = time+1;
          q.add(new int[]{newX, newY, time+1});
        }

        if (map[newX][newY] == 2) {
          boolean isFinished = checkFinished(timeMap);
//          if (checkFinished(timeMap)) break;
          if(!isFinished) {
            newVisited[newX][newY] = true;
            // 여기서 틀림 여기서 틀림
            timeMap[newX][newY] = time+1;
            q.add(new int[]{newX, newY, time+1});
          }
        }
      }
    }
  }

  static int getTime(int[][] timeMap) {
    int maxTime = 0;
    for (int i = 0; i < N; i++) {
      for (int j = 0; j < N; j++) {
        // 원래 빈 공간(0)인데 아직 바이러스가 안 퍼진 경우만 -1 반환
        if (map[i][j] == 0 && timeMap[i][j] == 0) return -1;
        if (timeMap[i][j] > maxTime) maxTime = timeMap[i][j];
      }
    }
    return maxTime;
  }


  static boolean checkFinished(int[][] timeMap) {
    for (int i = 0; i < N; i++) {
      for (int j = 0; j < N; j++) {
        if (timeMap[i][j] == 0) return false;
      }
    }
    return true;
  }

  static int[][] copyMap() {
    int[][] temp = new int[N][N];

    for (int i = 0; i < N; i++) {
      for (int j = 0; j < N; j++) {
        if (map[i][j] == 1) temp[i][j] = -1;
        if (map[i][j] == 2) temp[i][j] = -2;
      }
    }
    return temp;
  }
}

게리맨더링 2

import java.io.*;
import java.util.*;

public class Main {
    static int N;
    static int[][] A;
    static int answer = Integer.MAX_VALUE;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());
        
        A = new int[N + 1][N + 1];
        for (int i = 1; i <= N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int j = 1; j <= N; j++) {
                A[i][j] = Integer.parseInt(st.nextToken());
            }
        }
        
        // 모든 가능한 (x, y, d1, d2) 조합 탐색
        for (int x = 1; x <= N; x++) {
            for (int y = 1; y <= N; y++) {
                for (int d1 = 1; d1 <= N; d1++) {
                    for (int d2 = 1; d2 <= N; d2++) {
                        // 조건 확인
                        if (x + d1 + d2 <= N && 
                            y - d1 >= 1 && 
                            y + d2 <= N) {
                            solve(x, y, d1, d2);
                        }
                    }
                }
            }
        }
        
        System.out.println(answer);
    }
    
    static void solve(int x, int y, int d1, int d2) {
        boolean[][] border = new boolean[N + 1][N + 1];
        
        // 경계선 표시
        for (int i = 0; i <= d1; i++) {
            border[x + i][y - i] = true;
            border[x + d2 + i][y + d2 - i] = true;
        }
        for (int i = 0; i <= d2; i++) {
            border[x + i][y + i] = true;
            border[x + d1 + i][y - d1 + i] = true;
        }
        
        int[] sum = new int[5];
        
        // 1번 선거구
        for (int r = 1; r < x + d1; r++) {
            for (int c = 1; c <= y; c++) {
                if (border[r][c]) break;
                sum[0] += A[r][c];
            }
        }
        
        // 2번 선거구  
        for (int r = 1; r <= x + d2; r++) {
            for (int c = N; c > y; c--) {
                if (border[r][c]) break;
                sum[1] += A[r][c];
            }
        }
        
        // 3번 선거구
        for (int r = x + d1; r <= N; r++) {
            for (int c = 1; c < y - d1 + d2; c++) {
                if (border[r][c]) break;
                sum[2] += A[r][c];
            }
        }
        
        // 4번 선거구
        for (int r = x + d2 + 1; r <= N; r++) {
            for (int c = N; c >= y - d1 + d2; c--) {
                if (border[r][c]) break;
                sum[3] += A[r][c];
            }
        }
        
        // 5번 선거구 (전체에서 1,2,3,4번 빼기)
        int total = 0;
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                total += A[i][j];
            }
        }
        sum[4] = total - sum[0] - sum[1] - sum[2] - sum[3];
        
        // 최댓값과 최솟값의 차이 계산
        int max = sum[0], min = sum[0];
        for (int i = 1; i < 5; i++) {
            max = Math.max(max, sum[i]);
            min = Math.min(min, sum[i]);
        }
        
        answer = Math.min(answer, max - min);
    }
}

새로운 게임 2

import java.io.*;
import java.util.*;

public class Main {
  static int N, K;
  static int[][] map;
  static List<Integer>[][] list;
  static List<Piece> pieces = new ArrayList<>();
  static int turns = 0;

  // →, ←, ↑, ↓ (문제 정의 기준 1~4)
  static int[] dx = {0, 0, 0, -1, 1};
  static int[] dy = {0, 1, -1, 0, 0};

  static class Piece {
    int x, y, dir;
    Piece(int x, int y, int dir) {
      this.x = x;
      this.y = y;
      this.dir = dir;
    }
  }

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());

    N = Integer.parseInt(st.nextToken());
    K = Integer.parseInt(st.nextToken());

    map = new int[N + 1][N + 1];
    list = new ArrayList[N + 1][N + 1];

    for (int i = 1; i <= N; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 1; j <= N; j++) {
        map[i][j] = Integer.parseInt(st.nextToken());
        list[i][j] = new ArrayList<>();
      }
    }

    for (int i = 0; i < K; i++) {
      st = new StringTokenizer(br.readLine());
      int x = Integer.parseInt(st.nextToken());
      int y = Integer.parseInt(st.nextToken());
      int dir = Integer.parseInt(st.nextToken());

      pieces.add(new Piece(x, y, dir));
      list[x][y].add(i); // i번 말이 (x,y)에 존재
    }

    System.out.println(simulate());
  }

  static int simulate() {
    for (turns = 1; turns <= 1000; turns++) {
      for (int i = 0; i < K; i++) {
        if (move(i)) return turns; // 게임 종료
      }
    }
    return -1; // 1000턴 넘어가면 -1
  }

  static boolean move(int idx) {
    Piece curr = pieces.get(idx);
    int x = curr.x, y = curr.y, dir = curr.dir;

    // 현재 칸에서 idx 말이 어디 있는지 찾기
    List<Integer> cell = list[x][y];
    int pos = cell.indexOf(idx);

    // 옮길 말들 (idx 포함 위에 있는 말들)
    List<Integer> moving = new ArrayList<>(cell.subList(pos, cell.size()));
    cell.subList(pos, cell.size()).clear(); // 원래 칸에서 제거

    int nx = x + dx[dir];
    int ny = y + dy[dir];

    // 파란색 or 범위 밖 → 방향 반전
    if (!inRange(nx, ny) || map[nx][ny] == 2) {
      dir = reverse(dir);
      pieces.set(idx, new Piece(x, y, dir)); // 방향만 갱신

      nx = x + dx[dir];
      ny = y + dy[dir];

      // 반대한 곳도 파란색 or 범위 밖 → 제자리 (돌려놓기)
      if (!inRange(nx, ny) || map[nx][ny] == 2) {
        list[x][y].addAll(moving);
        return false;
      }
    }

    // 흰색: 그대로
    if (map[nx][ny] == 0) {
      list[nx][ny].addAll(moving);
    }
    // 빨간색: 순서 반전 후 쌓기
    else if (map[nx][ny] == 1) {
      Collections.reverse(moving);
      list[nx][ny].addAll(moving);
    }

    // 이동한 말들의 좌표 갱신
    for (int m : moving) {
      pieces.set(m, new Piece(nx, ny, pieces.get(m).dir));
    }

    // 4개 이상 쌓였으면 종료
    if (list[nx][ny].size() >= 4) return true;

    return false;
  }

  static boolean inRange(int nx, int ny) {
    return (nx >= 1 && ny >= 1 && nx <= N && ny <= N);
  }

  static int reverse(int dir) {
    if (dir == 1) return 2;
    if (dir == 2) return 1;
    if (dir == 3) return 4;
    return 3;
  }
}

원판 돌리기

// 내 멋대로, 나 편한대로 문제 해석하지 말고
// 처음 문제 조건, 해석, 복잡한거 정확하고 꼼꼼하게 이해하자
public class Main {

  // 1 - based
  static int N, M, T;

  //  static List<Integer>[] dart;
  static int[][] dart;

  static List<int[]> turns = new ArrayList<>();

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());

    N = Integer.parseInt(st.nextToken());
    M = Integer.parseInt(st.nextToken());
    T = Integer.parseInt(st.nextToken());

    dart = new int[N + 1][M + 1];

    for (int i = 1; i <= N; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 1; j <= M; j++) {
        dart[i][j] = Integer.parseInt(st.nextToken());
      }
    }

    for (int i = 0; i < T; i++) {
      st = new StringTokenizer(br.readLine());
      int x = Integer.parseInt(st.nextToken());
      int y = Integer.parseInt(st.nextToken());
      int t = Integer.parseInt(st.nextToken());

      turns.add(new int[]{x, y, t});
    }

    simulation();

    System.out.println(getAnswer());
  }

  static void simulation() {
    for (int i = 0; i < T; i++) {
      int[] t = turns.get(i);

      int x = t[0];
      int d = t[1];
      int k = t[2];

      int currIdx = x;
      int multiple = 1;

      while (true) {
        int currDiscNum = currIdx * multiple;
        if (currDiscNum > N) {
          break;
        }
        rotate(currDiscNum, d, k);

        // 탐색 시작 지점

        multiple++;
      }

      // TODO : 여기 위치 , 문제 이해
      update();
    }
  }

  static void rotate(int idx, int d, int k) {
    // 현재 회전 원판수 : idx
    // 회전 방향 : d (0인 경우는 시계 방향, 1인 경우는 반시계 방향)
    // 회전 칸 수 : k

    // 0 ... M

//    int[] temp = dart[idx]; // [3, 1, 3, 5]
    int[] newDart = new int[M + 1];

    // TODO : 여기 위치 , 문제 이해
    if (d == 0) { // 시계 방향
      for (int i = 1; i <= M; i++) {
        newDart[(i + k - 1) % M + 1] = dart[idx][i];
      }
    } else { // 반시계
      for (int i = 1; i <= M; i++) {
        newDart[(i - k - 1 + M) % M + 1] = dart[idx][i];
      }
    }

    dart[idx] = newDart;
  }

  static void update() {
    // 2. 업데이트
    // 2-1. 인접 수 중 같은거 제거.
    // 2-2. 원판 평균 구하고, 큰 수 -1, 작은수 +1

    boolean[][] visited = new boolean[N + 1][M + 1];

    boolean isDeleted = false;

    // 같은 위치 아래 원판
    // 같은 위치 위의 원판
    // 같은 원판 오른쪽 숫자
    // 같은 원판 왼쪽 숫자
    int[] dx = {1, -1, 0, 0};
    int[] dy = {0, 0, 1, -1};

    // TODO : 여기 위치 , 문제 이해, BFS
    // 원판 언제 돌리고, 인접 어디까지고 뭐 그런거. 문제에서 제대로 말 안한게 아니라 내가 찾아 해야 함
    for (int i = 1; i <= N; i++) {
      for (int j = 1; j <= M; j++) {
        // TODO : 0인 애들은 시작 안해도 됨.
        // 이거 문제랑 해서 다시 한 번 정리하자
        if (visited[i][j] || dart[i][j] == 0) {
          continue;
        }
        visited[i][j] = true;

        Queue<int[]> q = new LinkedList<>();
        q.add(new int[]{i, j});

        // 삭제할 애들 좌표들
        List<int[]> temp = new ArrayList<>();
        temp.add(new int[]{i, j}); // 시작점도 그룹에 포함

        int value = dart[i][j];

        while (!q.isEmpty()) {
          int[] tempArr = q.poll();
          int x = tempArr[0];
          int y = tempArr[1];

          for (int d = 0; d < 4; d++) {
            int nx = x + dx[d];
            if (nx < 1 || nx > N) {
              continue;
            }

            int ny = y + dy[d];
            if (ny < 1) {
              ny = M;
            } else if (ny > M) {
              ny = 1;
            }

            if (visited[nx][ny]) {
              continue;
            }

            if (dart[nx][ny] == value) {
              visited[nx][ny] = true;
              temp.add(new int[]{nx, ny});
              q.add(new int[]{nx, ny});
            }
          }
        }

        if (temp.size() > 1) {
          for (int t = 0; t < temp.size(); t++) {
            int[] tempArr = temp.get(t);
            dart[tempArr[0]][tempArr[1]] = 0;
          }
          isDeleted = true;
        }
      }
    }

    if (!isDeleted) {
      // 2-2. 원판 평균 구하고, 큰 수 -1, 작은수 +1
      // TODO : 여기 위치 , 문제 이해, 0인 애들 제거
      int sum = 0;
      int parent = 0;

      for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= M; j++) {
          if (dart[i][j] != 0) {
            sum += dart[i][j];
            parent++;
          }
        }
      }


      if (parent != 0) {
//        int avg = sum / parent;
        double avg = (double) sum / parent;

        for (int i = 1; i <= N; i++) {
          for (int j = 1; j <= M; j++) {
            if (dart[i][j] == 0) {
              continue;
            }
            if (dart[i][j] > avg) {
              dart[i][j]--;
            } else if (dart[i][j] < avg) {
              dart[i][j]++;
            }
          }
        }
      }

    }

  }


  static int getAnswer() {
    int answer = 0;

    for (int i = 1; i <= N; i++) {
      for (int j = 1; j <= M; j++) {
        answer += dart[i][j];
      }
    }

    return answer;
  }
}

주사위 윷놀이

import java.io.*;
import java.util.*;

public class Main {
  static class Node {
    int val;
    Node next;
    Node branch;
    Node(int v) { val = v; }
  }

  static int[] dice = new int[10];
  static Node start, end;
  static Node[] pieces = new Node[4];
  static int answer = 0;

  public static void main(String[] args) throws Exception {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());
    for (int i = 0; i < 10; i++) dice[i] = Integer.parseInt(st.nextToken());

    buildBoard();

    for (int i = 0; i < 4; i++) pieces[i] = start;
    dfs(0, 0);

    System.out.println(answer);
  }

  // 보드 구성: 메인 경로와 분기 경로들을 Node로 구성
  static void buildBoard() {
    end = new Node(0);
    end.next = end; // 끝은 자기 자신을 가리키게 해서 안전하게 처리

    // 메인 경로: 0,2,4,...,40
    Node[] main = new Node[21];
    for (int i = 0; i <= 20; i++) main[i] = new Node(i * 2);
    for (int i = 0; i < 20; i++) main[i].next = main[i + 1];
    main[20].next = end; // 40 다음은 끝
    start = main[0];

    // 중앙 합류 경로(25->30->35->40)
    Node mid25 = new Node(25);
    Node mid30 = new Node(30);
    Node mid35 = new Node(35);
    mid25.next = mid30;
    mid30.next = mid35;
    mid35.next = main[20]; // 35 -> 40

    // 5(10)에서 분기: 13->16->19->25...
    Node b1 = new Node(13);
    Node b1_2 = new Node(16);
    Node b1_3 = new Node(19);
    b1.next = b1_2; b1_2.next = b1_3; b1_3.next = mid25;
    main[5].branch = b1;

    // 10(20)에서 분기: 22->24->25...
    Node b2 = new Node(22);
    Node b2_2 = new Node(24);
    b2.next = b2_2; b2_2.next = mid25;
    main[10].branch = b2;

    // 15(30)에서 분기: 28->27->26->25...
    Node b3 = new Node(28);
    Node b3_2 = new Node(27);
    Node b3_3 = new Node(26);
    b3.next = b3_2; b3_2.next = b3_3; b3_3.next = mid25;
    main[15].branch = b3;

    // (참고) main 배열의 노드들은 이미 next로 연결되어 있음.
    // start, end, branch 노드들이 모두 연결된 상태.
  }

  // 현재 위치 cur에서 주사위 값 cnt만큼 이동한 최종 노드 반환
  static Node move(Node cur, int cnt) {
    if (cur == end) return end;
    Node cur2 = cur;
    // 첫 걸음: 분기(파란칸)가 있으면 분기를 타고, 아니면 다음 칸으로
    if (cur2.branch != null) {
      cur2 = cur2.branch;
      cnt--;
    } else {
      cur2 = cur2.next;
      cnt--;
    }
    // 남은 걸음은 next로 이동
    while (cnt > 0 && cur2 != end) {
      cur2 = cur2.next;
      cnt--;
    }
    return cur2;
  }

  // DFS로 10턴 전부 시뮬레이션 (각 턴마다 4말 중 하나 선택)
  static void dfs(int turn, int score) {
    if (turn == 10) {
      if (score > answer) answer = score;
      return;
    }

    for (int i = 0; i < 4; i++) {
      Node cur = pieces[i];
      if (cur == end) continue; // 이미 도착한 말은 이동 불가

      Node nxt = move(cur, dice[turn]);

      // 겹침 검사: 도착(end)과 출발(start)는 겹쳐도 됨
      if (nxt != end && nxt != start) {
        boolean collide = false;
        for (int j = 0; j < 4; j++) {
          if (i == j) continue;
          if (pieces[j] == nxt) { // 같은 물리적 칸이면 충돌
            collide = true;
            break;
          }
        }
        if (collide) continue;
      }

      // 이동 적용
      pieces[i] = nxt;
      dfs(turn + 1, score + nxt.val);
      // 백트래킹
      pieces[i] = cur;
    }
  }
}

모노미노도미노 2

// BOJ 20061 모노미노도미노 2
public class Main {

  static class Tile {
    int type, x, y;
    Tile(int type, int x, int y) { this.type = type; this.x = x; this.y = y; }
  }

  // blue: 4행 × 6열(오른쪽으로 이동)  [row][col]
  // green: 6행 × 4열(아래로 이동)     [row][col]
  static int[][] blueBoard = new int[4][6];
  static int[][] greenBoard = new int[6][4];

  static LinkedList<Tile> tiles = new LinkedList<>();
  static int SCORE = 0;

  public static void main(String[] args) throws Exception {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int N = Integer.parseInt(br.readLine().trim());
    for (int i = 0; i < N; i++) {
      StringTokenizer st = new StringTokenizer(br.readLine());
      int t = Integer.parseInt(st.nextToken());
      int x = Integer.parseInt(st.nextToken());
      int y = Integer.parseInt(st.nextToken());
      tiles.add(new Tile(t, x, y));
    }

    simulate();

    System.out.println(SCORE);
    System.out.println(counting());
  }

  private static void simulate() {
    for (Tile tile : tiles) {
      putTile(tile);     // 블록 배치
      updateBoard();     // 어두운 구역 줄/열 제거 (연쇄 제거 포함)
      pushTile();        // 연한 구역(0,1) 처리로 밀어내기
    }
  }

    private static void putTile(Tile tile) {
  int t = tile.type;
  int x = tile.x;
  int y = tile.y;

  // BLUE (오른쪽으로 이동)
  if (t == 1) {
    int c = 0;
    while (c + 1 < 6 && blueBoard[x][c + 1] == 0) c++;
    blueBoard[x][c] = 1;
  } else if (t == 2) { // 가로 2칸
    int c = 1; // 오른쪽 끝 기준
    // 오른쪽으로 한 칸 더 갈 수 있으려면 오른쪽 다음 칸이 비어 있어야 하고
    // (두 칸짜리라서) 현재 오른쪽 끝 칸도 비어있어야 함
    while (c + 1 < 6 && blueBoard[x][c + 1] == 0) c++;
    // 최종 배치 (c, c-1)
    blueBoard[x][c] = 1;
    blueBoard[x][c - 1] = 1;
  } else { // t == 3, 세로 2칸
    int c = 0;
    // 두 행(x, x+1) 모두에서 오른쪽 다음 칸이 비어 있어야 함
    while (c + 1 < 6 && blueBoard[x][c + 1] == 0 && blueBoard[x + 1][c + 1] == 0) c++;
    blueBoard[x][c] = 1;
    blueBoard[x + 1][c] = 1;
  }

  // GREEN (아래로 이동)
  if (t == 1) {
    int r = 0;
    while (r + 1 < 6 && greenBoard[r + 1][y] == 0) r++;
    greenBoard[r][y] = 1;
  } else if (t == 2) { // 가로 2칸
    int r = 0;
    while (r + 1 < 6 && greenBoard[r + 1][y] == 0 && greenBoard[r + 1][y + 1] == 0) r++;
    greenBoard[r][y] = 1;
    greenBoard[r][y + 1] = 1;
  } else { // t == 3, 세로 2칸
    int r = 1; // 아래쪽 끝 기준
    while (r + 1 < 6 && greenBoard[r + 1][y] == 0) r++;
    greenBoard[r][y] = 1;
    greenBoard[r - 1][y] = 1;
  }
}

    private static void updateBoard() {
  // GREEN rows 2..5
  for (int row = 2; row <= 5; row++) {
    boolean full = true;
    for (int c = 0; c < 4; c++) if (greenBoard[row][c] == 0) { full = false; break; }
    if (full) {
      reArrangeBoard(1, row); // 아래에서 위로 당김(위쪽이 0쪽)
      SCORE++;
      row--; // 연쇄 제거를 위해 같은 row 인덱스 재검사
    }
  }

  // BLUE cols 2..5
  for (int col = 2; col <= 5; col++) {
    boolean full = true;
    for (int r = 0; r < 4; r++) if (blueBoard[r][col] == 0) { full = false; break; }
    if (full) {
      reArrangeBoard(0, col); // 오른쪽에서 왼쪽으로 당김(0쪽이 light)
      SCORE++;
      col--; // 연쇄 제거를 위해 같은 col 인덱스 재검사
    }
  }
}


  // boardType: 0 = BLUE(열 제거), 1 = GREEN(행 제거)
  private static void reArrangeBoard(int boardType, int line) {
    if (boardType == 0) { // BLUE: 열 line 제거 → 왼쪽에서 오른쪽으로 당김
      for (int col = line; col > 0; col--) {
        for (int r = 0; r < 4; r++) {
          blueBoard[r][col] = blueBoard[r][col - 1];
        }
      }
      for (int r = 0; r < 4; r++) blueBoard[r][0] = 0;
    } else {              // GREEN: 행 line 제거 → 위에서 아래로 당김
      for (int row = line; row > 0; row--) {
        for (int c = 0; c < 4; c++) {
          greenBoard[row][c] = greenBoard[row - 1][c];
        }
      }
      for (int c = 0; c < 4; c++) greenBoard[0][c] = 0;
    }
  }

  // 연한 구역 처리: BLUE(0,1열), GREEN(0,1행)
  private static void pushTile() {
    // BLUE
    int amountBlue = 0;
    for (int c = 0; c <= 1; c++) {
      boolean any = false;
      for (int r = 0; r < 4; r++) if (blueBoard[r][c] == 1) { any = true; break; }
      if (any) amountBlue++;
    }
    if (amountBlue > 0) {
      for (int col = 5; col >= amountBlue; col--) {
        for (int r = 0; r < 4; r++) blueBoard[r][col] = blueBoard[r][col - amountBlue];
      }
      for (int col = 0; col < amountBlue; col++) {
        for (int r = 0; r < 4; r++) blueBoard[r][col] = 0;
      }
    }

    // GREEN
    int amountGreen = 0;
    for (int row = 0; row <= 1; row++) {
      boolean any = false;
      for (int c = 0; c < 4; c++) if (greenBoard[row][c] == 1) { any = true; break; }
      if (any) amountGreen++;
    }
    if (amountGreen > 0) {
      for (int row = 5; row >= amountGreen; row--) {
        for (int c = 0; c < 4; c++) greenBoard[row][c] = greenBoard[row - amountGreen][c];
      }
      for (int row = 0; row < amountGreen; row++) {
        for (int c = 0; c < 4; c++) greenBoard[row][c] = 0;
      }
    }
  }

  private static int counting() {
    int total = 0;
    for (int r = 0; r < 6; r++) {
      for (int c = 0; c < 4; c++) {
        if (greenBoard[r][c] == 1) total++;
        if (blueBoard[c][r] == 1) total++;
      }
    }
    return total;
  }
}

청소년 상어

// 처음에 바로 정확하게 구현하는게 가장 빠른 길이다.

// 시뮬레이션, 구현

// DFS, 종료 조건은 상어가 못 움직일 때
// 상태는 모두 변환해서 다음 시뮬레이션에 전달하기
// 방향은 8 방향 시뮬레이션
public class Main {

  // 1-based
  //  ↑, ↖, ←, ↙, ↓, ↘, →, ↗
  static int[] dx = {0, -1, -1, 0, 1, 1, 1, 0, -1};
  static int[] dy = {0, 0, -1, -1, -1, 0, 1, 1, 1};

  static class Shark {
    int x, y, dir, size;
    Shark( int x, int y, int dir, int size ) {
      this.x = x;
      this.y = y;
      this.dir = dir;
      this.size = size;
    }
  }

  static class Fish {
    int fishNumber, x, y, dir;
    Fish(int fishNumber,int x, int y, int dir) {
      this.fishNumber = fishNumber;
      this.x = x;
      this.y = y;
      this.dir = dir;
    }
  }

  // key 기준 오름차순 유지
//  static List<Fish> fishes = new ArrayList<>();

  static int maxSize = 0;

  public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st;

    Map<Integer, Fish> fishes =  new TreeMap<>();

    int[][] space = new int[4][4];

    for (int i = 0; i < 4; i++) {
      st = new StringTokenizer(br.readLine());
      for (int j = 0; j < 4; j++) {
        int fishNumber = Integer.parseInt(st.nextToken());
        int fishDirection = Integer.parseInt(st.nextToken());

        Fish fish = new Fish(fishNumber,i,j, fishDirection);
        fishes.put(fishNumber, fish);
//        fishes.add(new Fish(fishNumber, i, j, fishDirection));
        space[i][j] = fishNumber;
      }
    }

    // 상어 시작점 세팅
    Fish firstFish = fishes.get(space[0][0]);
    Shark shark = new Shark(firstFish.x,firstFish.y, firstFish.dir, firstFish.fishNumber);
    // TODO : 먹힌 물고기는 안움직임.
    fishes.remove(firstFish.fishNumber);
    space[0][0] = -1;

    // 45도 반시계 회전

    // 1. 물고기 이동
      // 작은 순서부터 이동
      // 상어 있거나 벽이면 안가고 방향 변경
      // 움직이면 서로 자리 체인지

    // 2. 상어 이동
      // 방향은 이전에 먹은 물고기 방향으로 업데이트
      // 움직일 칸 수는 DFS ==> (자료구조 뭐 쓸까)
      // 조건 : 움직일 칸은 물고기가 있어야함. 먹을게 없으면 집으로 감.

    startMoving(space, shark, fishes);
    System.out.println(maxSize);
  }

  // 재귀
  private static void startMoving(int[][] space, Shark shark, Map<Integer, Fish> fishes) {
    // 물고기 이동
    fishingFish(space, fishes);

    int sx = shark.x, sy = shark.y;
    space[sx][sy] = 0;

    int dir = shark.dir;
    int size = shark.size;
    // 여기서 상어 이동  가능성에 대해서 for문 돌리기.
    List<int[]> moves = new LinkedList<>();


    for (int i = 0; i < 4; i++) {
      sx += dx[dir];
      sy += dy[dir];

      if (isOverSpace(sx, sy)) break;
      if (space[sx][sy] == 0) continue; //  TODO : break아니고 continue임

      moves.add(new int[]{sx, sy});
    }

    // 갈 곳 없으면 종료
    if (moves.size() == 0) {
      if (shark.size > maxSize) maxSize = shark.size;
      return;
    }
    // 상어 이동
      // 여기서 현재 space 복붙해서 넘기기 앞으로

    for (int[] move : moves) {
      // 상어 이동 경우의 수

      // 이동해서 기존
      int eatenFIshIdx = space[move[0]][move[1]];
      Fish eatenFish = fishes.get(eatenFIshIdx);

      // 새 맵
      int[][] newSpace = copySpace(space);
      newSpace[move[0]][move[1]] = -1;

      // 새 상어
      Shark newShark = new Shark(move[0], move[1], eatenFish.dir, shark.size+eatenFish.fishNumber);

      // TODO : 현재 살아있는 물고기 상태도 복사 붙여넣기
      //  fishes.remove(firstFish.fishNumber);
      Map<Integer, Fish> newFishes =  new TreeMap<>();
      for (Fish f : fishes.values()) {
        newFishes.put(f.fishNumber, new Fish(f.fishNumber, f.x, f.y, f.dir));
      }
      newFishes.remove(eatenFish.fishNumber);

      // 재귀 : startMoving
      startMoving(newSpace, newShark, newFishes);
    }
  }

  private static void fishingFish(int[][] space, Map<Integer, Fish> fishes) {
    // 1. 물고기 이동
      // 작은 순서부터 이동
      // 상어 있거나 벽이면 안가고 반시계 45도 방향 변경
      // 만약 사방이 다 안되면 그대로
      // 움직이면 서로 자리 체인지

// 순회하면 항상 작은 fishNumber → 큰 fishNumber 순서
    for (Fish f : fishes.values()) {
      // 정렬된 순서
      int x = f.x, y = f.y;
      int dir = f.dir;

      int nx = x + dx[dir];
      int ny = y + dy[dir];

      boolean stay = false;

      while(true) {
        // 다음칸 미리 움직이기
        // -1
        if (!isOverSpace(nx,ny) && space[nx][ny] != -1 ) break;
        //  if (!isOverSpace(nx,ny) && space[nx][ny] != -1 ) break;

        //  ↑, ↖, ←, ↙, ↓, ↘, →, ↗
        // TODO : 회전
        dir = dir % 8 + 1;
        if (dir == f.dir) {
          stay = true;
          break;
        }

        nx = x + dx[dir];
        ny = y + dy[dir];
      }

      if (!stay) {
        // 보드값 업데이트
        int tempFishIdx = space[nx][ny];


        space[nx][ny] = f.fishNumber;
        space[x][y] = tempFishIdx;

        // TODO : 빈칸이 아니면 상대 물고기 좌표 갱신
        if (tempFishIdx != 0) {
          Fish tempFish = fishes.get(tempFishIdx);
          tempFish.x = x;
          tempFish.y = y;
        }
        // Fish 값 업데이트
//        Fish tempFish = fishes.get(tempFishIdx);
//        tempFish.x = x;
//        tempFish.y = y;

        f.x = nx;
        f.y = ny;
        f.dir = dir;
      }

    }
  }

  private static boolean isOverSpace(int x, int y) {
    if (x < 0 || y < 0 || x >= 4 || y >= 4) return true;
    return false;
  }

  private static int[][] copySpace(int[][] space) {
    int[][] newSpace = new int[4][4];
    for (int i = 0; i < 4; i++) {
      for (int j = 0; j < 4; j++) {
        newSpace[i][j] = space[i][j];
      }
    }
    return newSpace;
  }
}

어른 상어

import java.io.*;
import java.util.*;

/**
 * BOJ 19237 어른 상어 - 정석 구현 (1-based 방향)
 * 방향: 1=↑, 2=↓, 3=←, 4=→
 * 흐름: 모두 이동(우선순위: 빈칸 -> 자기 냄새) -> 냄새 감소 -> 새 냄새 뿌리기
 * 충돌: 번호 작은 상어만 생존
 * 종료: 상어 1만 남으면 시간 출력, 1000초 넘으면 -1
 */
public class Main {

    static int N, M, K;

    // 1-based 방향: 1=↑,2=↓,3=←,4=→
    static final int[] dx = {0, -1, 1, 0, 0};
    static final int[] dy = {0, 0, 0, -1, 1};

    // 각 칸의 냄새
    static int[][] smellOwner; // 0=없음, 그 외=상어 번호
    static int[][] smellTime;  // 남은 시간

    // 상어 정보
    static class Shark {
        int x, y, dir;
        boolean alive = true;
    }
    static Shark[] sharks; // 1..M

    // 우선순위: [sharkNum][dir(1..4)][0..3] -> 1..4
    static int[][][] priority;

    // 현재 상어 위치 보드(상어 번호; 0=빈칸)
    static int[][] board;

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        K = Integer.parseInt(st.nextToken());

        board = new int[N][N];
        smellOwner = new int[N][N];
        smellTime  = new int[N][N];

        sharks = new Shark[M + 1];
        for (int i = 1; i <= M; i++) sharks[i] = new Shark();

        // 초기 보드 & 상어 위치 세팅 + 초기 냄새 뿌리기
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                int v = Integer.parseInt(st.nextToken());
                board[i][j] = v;
                if (v != 0) {
                    sharks[v].x = i;
                    sharks[v].y = j;
                    // 초기 냄새
                    smellOwner[i][j] = v;
                    smellTime[i][j]  = K;
                }
            }
        }

        // 각 상어의 초기 방향 (상어 번호 1..M 순서로 주어짐)
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= M; i++) {
            sharks[i].dir = Integer.parseInt(st.nextToken());
        }

        // 우선순위 입력: 상어 1..M, 각 dir=1..4에 대해 4개 우선순위
        priority = new int[M + 1][5][4];
        for (int s = 1; s <= M; s++) {
            for (int d = 1; d <= 4; d++) {
                st = new StringTokenizer(br.readLine());
                for (int k = 0; k < 4; k++) {
                    priority[s][d][k] = Integer.parseInt(st.nextToken()); // 1..4
                }
            }
        }

        int time = simulate();
        System.out.println(time);
    }

    // 시뮬레이션: 상어 1만 남는 시간 or -1
    static int simulate() {
        for (int t = 1; t <= 1000; t++) {

            // 1) 모든 상어 다음 위치 계산 (빈 칸 우선 → 자기 냄새), 충돌은 이후 일괄 처리
            moveAllSharks();

            // 2) 냄새 감소
            decreaseSmell();

            // 3) 현재 생존 상어가 있는 자리에 새 냄새 뿌리기
            leaveSmell();

            // 종료 조건: 상어 1만 남았는가?
            if (onlySharkOneLeft()) return t;
        }
        return -1;
    }

    static void moveAllSharks() {
        // 다음 보드(점유 결과)
        int[][] nextBoard = new int[N][N];

        // 작은 번호 상어부터 이동(자연스럽게 충돌 시 작은 번호가 점유)
        for (int s = 1; s <= M; s++) {
            Shark sh = sharks[s];
            if (!sh.alive) continue;

            int x = sh.x, y = sh.y, dir = sh.dir;

            // 우선 1) 냄새 없는 칸 탐색
            int ndir = -1, nx = -1, ny = -1;
            for (int p = 0; p < 4; p++) {
                int candDir = priority[s][dir][p];
                int tx = x + dx[candDir];
                int ty = y + dy[candDir];
                if (!in(tx, ty)) continue;
                if (smellTime[tx][ty] == 0) { // 냄새 없는 칸
                    ndir = candDir; nx = tx; ny = ty;
                    break;
                }
            }

            // 없으면 2) 자기 냄새 칸 탐색
            if (ndir == -1) {
                for (int p = 0; p < 4; p++) {
                    int candDir = priority[s][dir][p];
                    int tx = x + dx[candDir];
                    int ty = y + dy[candDir];
                    if (!in(tx, ty)) continue;
                    if (smellTime[tx][ty] > 0 && smellOwner[tx][ty] == s) {
                        ndir = candDir; nx = tx; ny = ty;
                        break;
                    }
                }
            }

            // 이동 결과 반영(충돌 처리: 작은 번호가 먼저 들어오니 승자)
            if (ndir == -1) {
                // 이론상 발생하지 않지만 방어적으로 제자리 유지
                nx = x; ny = y; ndir = dir;
            }
            if (nextBoard[nx][ny] == 0) {
                // 점유 성공
                nextBoard[nx][ny] = s;
                sh.x = nx; sh.y = ny; sh.dir = ndir;
            } else {
                // 이미 더 작은 번호 상어가 점유 → 현재 상어는 사망
                sh.alive = false;
            }
        }

        // 보드 갱신
        board = nextBoard;
    }

    static void decreaseSmell() {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (smellTime[i][j] > 0) {
                    smellTime[i][j]--;
                    if (smellTime[i][j] == 0) {
                        smellOwner[i][j] = 0;
                    }
                }
            }
        }
    }

    static void leaveSmell() {
        for (int s = 1; s <= M; s++) {
            Shark sh = sharks[s];
            if (!sh.alive) continue;
            int x = sh.x, y = sh.y;
            smellOwner[x][y] = s;
            smellTime[x][y] = K;
        }
    }

    static boolean onlySharkOneLeft() {
        // 상어 1만 alive 인가?
        if (!sharks[1].alive) return false;
        for (int s = 2; s <= M; s++) if (sharks[s].alive) return false;
        return true;
    }

    static boolean in(int x, int y) {
        return 0 <= x && x < N && 0 <= y && y < N;
    }
}

스타트 택시

import java.io.*;
import java.util.*;

/**
 * 백준 19238 스타트 택시 - 정답형 구현
 * 핵심:
 * - 매 라운드: (택시 -> 전 칸) BFS로 승객 선택
 * - 픽업까지 연료 차감
 * - (승객 위치 -> 목적지) BFS로 이동, 연료 차감 후 2배 충전
 * - 도달 불가/연료 부족시 -1
 * - 승객 선택 타이브레이커: 거리 -> 행 -> 열
 */
public class Main {

  static int N, M, fuel;
  static int[][] board;              // 0: 빈칸, 1: 벽
  static int[][] passengerMap;       // 승객 위치: 0=없음, >0 = 승객 idx(1..M)
  static int[] destR, destC;         // 목적지 좌표 by idx(1..M)
  static int taxiR, taxiC;           // 택시 위치 (0-indexed)

  static final int[] dr = {-1, 0, 0, 1}; // 상, 좌, 우, 하 (타이브레이커 쉽게)
  static final int[] dc = {0, -1, 1, 0};

  public static void main(String[] args) throws Exception {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());

    N = Integer.parseInt(st.nextToken());
    M = Integer.parseInt(st.nextToken());
    fuel = Integer.parseInt(st.nextToken());

    board = new int[N][N];
    for (int r = 0; r < N; r++) {
      st = new StringTokenizer(br.readLine());
      for (int c = 0; c < N; c++) {
        board[r][c] = Integer.parseInt(st.nextToken());
      }
    }

    st = new StringTokenizer(br.readLine());
    taxiR = Integer.parseInt(st.nextToken()) - 1;
    taxiC = Integer.parseInt(st.nextToken()) - 1;

    passengerMap = new int[N][N];
    destR = new int[M + 1];
    destC = new int[M + 1];

    for (int i = 1; i <= M; i++) {
      st = new StringTokenizer(br.readLine());
      int sr = Integer.parseInt(st.nextToken()) - 1;
      int sc = Integer.parseInt(st.nextToken()) - 1;
      int tr = Integer.parseInt(st.nextToken()) - 1;
      int tc = Integer.parseInt(st.nextToken()) - 1;
      passengerMap[sr][sc] = i;
      destR[i] = tr;
      destC[i] = tc;
    }

    int remained = solve();
    System.out.println(remained);
  }

  static int solve() {
    for (int served = 0; served < M; served++) {
      // 1) 택시 위치에서 BFS → 모든 칸 최단거리
      int[][] distFromTaxi = bfs(taxiR, taxiC);
      // 2) 규칙에 맞게 가장 가까운 승객 선택
      int pickR = -1, pickC = -1, passengerIdx = -1, bestDist = Integer.MAX_VALUE;

      for (int r = 0; r < N; r++) {
        for (int c = 0; c < N; c++) {
          if (passengerMap[r][c] > 0 && distFromTaxi[r][c] >= 0) {
            int d = distFromTaxi[r][c];
            if (d < bestDist) {
              bestDist = d; pickR = r; pickC = c; passengerIdx = passengerMap[r][c];
            } else if (d == bestDist) {
              // 행, 열 우선
              if (r < pickR || (r == pickR && c < pickC)) {
                pickR = r; pickC = c; passengerIdx = passengerMap[r][c];
              }
            }
          }
        }
      }

      // 승객을 못 찾거나, 도달 불가
      if (passengerIdx == -1) return -1;
      // 픽업까지 연료 체크
      if (fuel < bestDist) return -1;

      // 픽업 이동
      fuel -= bestDist;
      taxiR = pickR; taxiC = pickC;

      // 3) 승객 목적지까지 BFS
      int[][] distFromPick = bfs(taxiR, taxiC);
      int tr = destR[passengerIdx], tc = destC[passengerIdx];
      int toDest = distFromPick[tr][tc];

      if (toDest < 0 || fuel < toDest) return -1;

      // 목적지로 이동
      fuel -= toDest;
      // 도착 보너스: 2배 충전
      fuel += (toDest * 2);

      // 택시 위치 갱신, 승객 제거
      taxiR = tr; taxiC = tc;
      passengerMap[pickR][pickC] = 0;
    }
    return fuel;
  }

  // 출발 (sr, sc)에서 각 칸 최단거리 (벽=1은 통과 불가). 도달 불가 칸은 -1.
  static int[][] bfs(int sr, int sc) {
    int[][] dist = new int[N][N];
    for (int[] row : dist) Arrays.fill(row, -1);
    ArrayDeque<int[]> q = new ArrayDeque<>();
    q.offer(new int[]{sr, sc});
    dist[sr][sc] = 0;

    while (!q.isEmpty()) {
      int[] cur = q.poll();
      int r = cur[0], c = cur[1];
      for (int d = 0; d < 4; d++) {
        int nr = r + dr[d], nc = c + dc[d];
        if (nr < 0 || nc < 0 || nr >= N || nc >= N) continue;
        if (board[nr][nc] == 1) continue;       // ★ 벽 체크: board[row][col]
        if (dist[nr][nc] != -1) continue;
        dist[nr][nc] = dist[r][c] + 1;
        q.offer(new int[]{nr, nc});
      }
    }
    return dist;
  }
}

컨베이어 벨트 위의 로봇

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

/**
 * 백준 20055 - 컨베이어 벨트 위의 로봇
 * 구현 포인트
 *  - 벨트 내구도는 2N칸(1-based), 로봇은 윗줄 N칸만 관리(1..N)
 *  - 회전 시 벨트/로봇 모두 한 칸 이동, 내리는 위치(N)는 즉시 비움
 *  - 로봇 이동은 뒤에서 앞으로, 앞칸 비었고 내구도>0이면 이동 + 내구도 감소
 *  - 올리는 위치(1번) 비어 있고 내구도>0이면 로봇 올림 + 내구도 감소
 *  - 내구도 0 칸 수가 K 이상이면 종료
 */
public class Main {
  static int N, K;
  static int[] belt;     // 1..2N (내구도)
  static int[] robot;    // 1..N   (0/1: 로봇 존재 여부)
  static int zeroCnt = 0;

  public static void main(String[] args) throws Exception {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());
    N = Integer.parseInt(st.nextToken());
    K = Integer.parseInt(st.nextToken());

    belt = new int[2 * N + 1];   // 1-based
    robot = new int[N + 1];      // 1-based (윗줄만)

    st = new StringTokenizer(br.readLine());
    for (int i = 1; i <= 2 * N; i++) {
      belt[i] = Integer.parseInt(st.nextToken());
      if (belt[i] == 0) zeroCnt++;
    }

    System.out.println(simulate());
  }

  static int simulate() {
    int turn = 0;
    while (true) {
      turn++;

      // 1) 벨트 + 로봇 회전
      rotate();

      // 2) 로봇 이동 (뒤에서 앞으로), 앞칸 비었고 내구도 > 0이면 이동
      moveRobots();

      // 3) 올리는 위치에 로봇 올리기
      putNewRobot();

      // 4) 종료 조건
      if (zeroCnt >= K) break;
    }
    return turn;
  }

  // 벨트와 로봇을 한 칸 회전 (1-based)
  static void rotate() {
    // 벨트 회전
    int last = belt[2 * N];
    for (int i = 2 * N; i >= 2; i--) {
      belt[i] = belt[i - 1];
    }
    belt[1] = last;

    // 로봇 회전 (윗줄만)
    for (int i = N; i >= 2; i--) {
      robot[i] = robot[i - 1];
    }
    robot[1] = 0;  // 새로 올라온 1번 위치는 비어 있어야 함
    robot[N] = 0;  // 내리는 위치는 즉시 하차
  }

  static void moveRobots() {
    // 내리는 위치는 항상 비움
    robot[N] = 0;

    // 뒤에서 앞으로 이동 시도
    for (int i = N - 1; i >= 1; i--) {
      if (robot[i] == 1 && robot[i + 1] == 0 && belt[i + 1] > 0) {
        robot[i] = 0;
        robot[i + 1] = 1;
        belt[i + 1]--;
        if (belt[i + 1] == 0) zeroCnt++;
      }
    }

    // 이동 결과 N에 있으면 즉시 하차
    robot[N] = 0;
  }

  static void putNewRobot() {
    if (robot[1] == 0 && belt[1] > 0) {
      robot[1] = 1;
      belt[1]--;
      if (belt[1] == 0) zeroCnt++;
    }
  }
}