[백준 2174] 로봇 시뮬레이션 -JAVA //le_effort

로봇 시뮬레이션

 

시간 제한	메모리 제한	제출	정답	맞은 사람	정답 비율
2 초	128 MB	6234	1444	1127	22.888%

문제

가로 A(1≤A≤100), 세로 B(1≤B≤100) 크기의 땅이 있다. 이 땅 위에 로봇들이 N(1≤N≤100)개 있다.

로봇들의 초기 위치는 x좌표와 y좌표로 나타난다. 위의 그림에서 보듯 x좌표는 왼쪽부터, y좌표는 아래쪽부터 순서가 매겨진다. 또한 각 로봇은 맨 처음에 NWES 중 하나의 방향을 향해 서 있다. 초기에 서 있는 로봇들의 위치는 서로 다르다.

이러한 로봇들에 M(1≤M≤100)개의 명령을 내리려고 한다. 각각의 명령은 순차적으로 실행된다. 즉, 하나의 명령을 한 로봇에서 내렸으면, 그 명령이 완수될 때까지 그 로봇과 다른 모든 로봇에게 다른 명령을 내릴 수 없다. 각각의 로봇에 대해 수행하는 명령은 다음의 세 가지가 있다.

1. L: 로봇이 향하고 있는 방향을 기준으로 왼쪽으로 90도 회전한다.
2. R: 로봇이 향하고 있는 방향을 기준으로 오른쪽으로 90도 회전한다.
3. F: 로봇이 향하고 있는 방향을 기준으로 앞으로 한 칸 움직인다.

간혹 로봇들에게 내리는 명령이 잘못될 수도 있기 때문에, 당신은 로봇들에게 명령을 내리기 전에 한 번 시뮬레이션을 해 보면서 안전성을 검증하려 한다. 이를 도와주는 프로그램을 작성하시오.

잘못된 명령에는 다음의 두 가지가 있을 수 있다.

1. Robot X crashes into the wall: X번 로봇이 벽에 충돌하는 경우이다. 즉, 주어진 땅의 밖으로 벗어나는 경우가 된다.
2. Robot X crashes into robot Y: X번 로봇이 움직이다가 Y번 로봇에 충돌하는 경우이다.

입력

첫째 줄에 두 정수 A, B가 주어진다. 다음 줄에는 두 정수 N, M이 주어진다. 다음 N개의 줄에는 각 로봇의 초기 위치(x, y좌표 순) 및 방향이 주어진다. 다음 M개의 줄에는 각 명령이 명령을 내리는 순서대로 주어진다. 각각의 명령은 명령을 내리는 로봇, 명령의 종류(위에 나와 있는), 명령의 반복 회수로 나타낸다. 각 명령의 반복 회수는 1이상 100이하이다.

출력

첫째 줄에 시뮬레이션 결과를 출력한다. 문제가 없는 경우에는 OK를, 그 외의 경우에는 위의 형식대로 출력을 한다. 만약 충돌이 여러 번 발생하는 경우에는 가장 먼저 발생하는 충돌을 출력하면 된다.

예제 입력 1 복사

5 4
2 2
1 1 E
5 4 W
1 F 7
2 F 7

예제 출력 1

xxxxxxxxxx
Robot 1 crashes into the wall

 

 

풀이

여태까지 풀던 문제와 x,y 위치가 다르게 나와 이것만 주의하면 시키는데로 구현 하면 어렵지 않게 풀 수 있다

 

 

전체코드

import java.io.*;
import java.util.*;
public class Main {
    static int a,b,n,m;
    static int dx[] = {0,-1,0,1,0};
    static int dy[] =  {0,0,1,0,-1};
    static int map[][];
    static Robot robot[];
    static ArrayList<Order>list = new ArrayList<>();
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        String [] t = br.readLine().split(" ");
        a = Integer.parseInt(t[0]); //  map[0][a]
        b = Integer.parseInt(t[1]); // map[b][0]
        
        map = new int[b+1][a+1];
        String [] tt = br.readLine().split(" ");
        n = Integer.parseInt(tt[0]);        // 로봇의 개수
        m = Integer.parseInt(tt[1]);    // 명령의 개수
        
        robot = new Robot[n+1];
        
        for(int i=0; i<n; i++) {
            String [] input = br.readLine().split(" ");
            int y = Integer.parseInt(input[0]); // map[0][x]
            int x = Integer.parseInt(input[1]); // map[y][0]
            String str = input[2];  // 방향을 숫자로 변환 과정 거칠것
            int dir = change(str);
            map[(b-x)+1][y] = i+1;
            robot[i+1] = new Robot((b-x)+1,y,dir);
        }
        
        for(int i=0; i<m; i++) {
            String[] order_input = br.readLine().split(" ");
            int rn = Integer.parseInt(order_input[0]);
            String ro = order_input[1];
            int rc = Integer.parseInt(order_input[2]);
            list.add(new Order(rn,ro,rc));
        }
​
        solve();
    }
    public static void solve() {
        for(int i=0; i<list.size(); i++) {
            int cnt = list.get(i).cnt;  // 반복횟수
            int robot_num = list.get(i).num;    //로봇번호
            String order = list.get(i).str; // 명령종류
            for(int j=0; j<cnt; j++) {
                int tmp_dir = robot[robot_num].dir;
                int x = robot[robot_num].x;
                int y = robot[robot_num].y;
                switch(order) {
                case "L":
                    tmp_dir--;
                    if(tmp_dir==0) {
                        tmp_dir=4;
                    }
                    robot[robot_num].dir = tmp_dir;
                    break ;
                case "R":
                    tmp_dir++;
                    if(tmp_dir==5) {
                        tmp_dir=1;
                    }
                    robot[robot_num].dir = tmp_dir;
                    break ;
                case "F":
                    int tmp_x = x+dx[tmp_dir];
                    int tmp_y = y+dy[tmp_dir];
                    if(!isRange(tmp_x,tmp_y)) {
                        System.out.println("Robot "+robot_num+" crashes into the wall");
                        System.exit(0);
                    }
                    if(map[tmp_x][tmp_y]!=0) {
                        System.out.println("Robot "+robot_num+" crashes into robot "+map[tmp_x][tmp_y]);
                        System.exit(0);
                    }
                    map[x][y] =0;
                    map[tmp_x][tmp_y] = robot_num;
                    robot[robot_num].x = tmp_x;
                    robot[robot_num].y = tmp_y;
                    break;
                }
            }
        }
        System.out.println("OK");
    }
    public static boolean isRange(int x, int y) {
        if(x>=1 && y>=1 && x<=b && y<=a) {
            return true;
        }
        return false;
    }
    public static int change(String str) {
        switch(str){
            case "N":
                return 1;
            case "E":
                return 2;
            case "S":
                return 3;
            case "W":
                return 4;
        }
        return 1000;
    }
}
class Robot{
    int x,y,dir;
    Robot(int x, int y, int dir){
        this.x=x;
        this.y=y;
        this.dir=dir;
    }
}
class Order{
    int num,cnt;
    String str;
    Order(int num,String str,int cnt){
        this.num=num;
        this.cnt=cnt;
        this.str =str;
    }
}