[백준 14503번] 로봇 청소기 :: 늦깎이 IT

[백준 14503번 로봇 청소기 URL]

문제 풀이 방법은, 문제 설명에 나온 그대로 진행하면 된다...설명할게 없다..

1. 현재 위치를 청소한다.
2. 현재 위치에서 현재 방향을 기준으로 왼쪽방향부터 차례대로 탐색을 진행한다.
   1. 왼쪽 방향에 아직 청소하지 않은 공간이 존재한다면, 그 방향으로 회전한 다음 한 칸을 전진하고 1번부터 진행한다.
   2. 왼쪽 방향에 청소할 공간이 없다면, 그 방향으로 회전하고 2번으로 돌아간다.
   3. 네 방향 모두 청소가 이미 되어있거나 벽인 경우에는, 바라보는 방향을 유지한 채로 한 칸 후진을 하고 2번으로 돌아간다.
   4. 네 방향 모두 청소가 이미 되어있거나 벽이면서, 뒤쪽 방향이 벽이라 후진도 할 수 없는 경우에는 작동을 멈춘다.

[소스 코드]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;
 
public class Main {
 
    public static int N, M, ans = 0;
    public static int[][] map;
    public static Node robot;
    public static int[] dirX = new int[] { -1, 0, 1, 0 }; // 북 동 남 서
    public static int[] dirY = new int[] { 0, 1, 0, -1 };
    public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 
    public static void main(String[] args) throws Exception {
 
        StringTokenizer st = new StringTokenizer(br.readLine());
 
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
 
        map = new int[N][M];
 
        st = new StringTokenizer(br.readLine());
        int row = Integer.parseInt(st.nextToken());
        int col = Integer.parseInt(st.nextToken());
        int dir = Integer.parseInt(st.nextToken());
        robot = new Node(row, col, dir);
 
        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());
            }
        }
        solve();
        System.out.println(ans);
    }
 
    public static void solve() {
 
        map[robot.row][robot.col] = 2;
        ans += 1;
 
        while (true) {
            // 방향 회전
            boolean flag = false;
 
            for (int i = 0; i < 4; i++) {
 
                robot.dir = getNextDir(robot.dir);
 
                // 청소할 공간이 있다면 로봇을 이동시킨다.
                if (map[robot.row + dirX[robot.dir]][robot.col + dirY[robot.dir]] == 0) {
                    flag = true;
                    robot.row += dirX[robot.dir];
                    robot.col += dirY[robot.dir];
                    map[robot.row][robot.col] = 2;
                    ans += 1;
                    break;
                }
            }
 
            // 4방향에 청소할 공간이 없다면
            if (!flag) {
 
                // 로봇의 뒤가 벽이 아니라면 뒤로 한칸 후진한다.
                if (map[robot.row - dirX[robot.dir]][robot.col - dirY[robot.dir]] != 1) {
                    robot.row -= dirX[robot.dir];
                    robot.col -= dirY[robot.dir];
                } else
                    return;
            }
        }
    }
 
    public static int getNextDir(int dir) {
 
        if (dir == 0) {
            return 3;
        } else if (dir == 1) {
            return 0;
        } else if (dir == 2) {
            return 1;
        } else {
            return 2;
        }
    }
 
    public static boolean isBoundary(int row, int col) {
        return (row >= 0 && row < N) && (col >= 0 && col < M);
    }
 
    public static void showMap(int[][] map) {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println();
    }
}
 
class Node {
    int row;
    int col;
    int dir;
 
    public Node(int row, int col, int dir) {
        this.row = row;
        this.col = col;
        this.dir = dir;
    }
 
}