로봇 청소기

[2017-04-16 일요일]

* 내용: 로봇 청소기

1. 문제

2. 해결 방법

 

1. 문제

---

* 내용

- 문제: 생략

 

* 예제 입출력

번호	입력	출력
1	생략	* 과정 (중략)   * 최종 결과

 

2. 해결 방법

---

* 이슈

A. 배열의 index의 y, x를 잘 구별해야한다.

B. 로봇을 움직인다고 생각하기보다는 지도를 움직인다고 생각한다.

C. 지도와 마찬가지로 로봇도 적절히 좌표 값을 변경해주어야 한다.

 

* 소스코드

import java.util.*;
 
/**
 * Created by WindingRoad on 2017-04-15.
 */
 
public class RobotCleaner {
    @SuppressWarnings("resource")
    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
 
        int times = scanner.nextInt();
        int execTimes = 0;
 
        while (execTimes < times) {
 
            int size = scanner.nextInt();
            int curX = scanner.nextInt();
            int curY = scanner.nextInt();
            int nesw = scanner.nextInt();
            int[][] mapTemp = new int[size][size];
 
            for (int y = 0; y < size; y++) {
                for (int x = 0; x < size; x++) {
                    mapTemp[y][x] = scanner.nextInt();
                }
            }
 
            Robot robot = new Robot(curX, curY, nesw, size);
            Map map = new Map(size, mapTemp, robot);
            robot.setMap(map);
 
            map.setMapByNesw(nesw); // 로봇 시작 동서남북 위치 결정
 
            robot.clean(); // 청소 시작
 
            execTimes++;
        }
    }
}
 
class Robot {
    public int curX;
    public int curY;
    public int realX;
    public int realY;
    public int nesw; // 0:
    public int size;
    private Map map;
    public int rotateCnt = 0;
 
    public Robot(int curX, int curY, int nesw, int size) {
        this.curX = curX;
        this.curY = curY;
        this.nesw = nesw;
        this.size = size;
    }
 
    public Map getMap() {
        return map;
    }
 
    public void setMap(Map map) {
        this.map = map;
    }
    
    public void roateCurYX(int cnt) {
        for(int i = 0; i < cnt; i++) {
            int temp = curY;
            curY = curX;
            curX = size - 1 - temp;
        }
    }
    
    public void setRealYX(int curY, int curX) {
        this.realY = curY;
        this.realX = curX;
    }
    
    public void roateRealYX(int cnt) {
        this.realY = curY;
        this.realX = curX;
        
        for(int i = 0; i < 4 - cnt; i++) {
            int temp = realY;
            realY = realX;
            realX = size - 1 - temp;
        }
    }
 
    public void clean() {
        map.setMapYX(curY, curX, 2); // 2가 클린 상태
        while(true) {
            if(map.getMapYX(curY, curX - 1) == 0) { // 왼
                curX = curX - 1;
                map.setMapYX(curY, curX, 2); 
                map.rotateMap(1);
                roateCurYX(1);
                rotateCnt += 1;
            }
            else if(map.getMapYX(curY - 1, curX) == 0) { // 위
                curY = curY - 1;
                map.setMapYX(curY, curX, 2); 
                setRealYX(curY, curX);
            }
            else if(map.getMapYX(curY, curX + 1) == 0) { // 오른
                curX = curX + 1;
                map.setMapYX(curY, curX, 3); 
                map.rotateMap(3);
                roateCurYX(3);
                rotateCnt += 3;
            }
            else if(map.getMapYX(curY + 1, curX) == 0) { // 아래
                curY = curY + 1;
                map.setMapYX(curY, curX, 2); 
                map.rotateMap(2);
                roateCurYX(2);
                rotateCnt += 2;
            }
            else {
                if(map.getMapYX(curY + 1, curX) != 1) { // 후진
                    curY = curY + 1;
                    map.setMapYX(curY, curX, 2); 
                    setRealYX(curY, curX);
                }
                else {
                    break;
                }
            }
            
            if(rotateCnt % 4 != 0) {
                map.rotateRealMap(rotateCnt % 4);
                roateRealYX(rotateCnt % 4);
                map.printRealMap();
            }
            else {
                setRealYX(curY, curX);
                map.syncRealMap();
                map.printRealMap();
            }
        }
    }
}
 
class Map {
    public int size;
    private int[][] map;
    int[][] realMap;
    Robot robot;
 
    public Map(int size, int[][] map, Robot robot) {
        this.size = size;
        this.map = map;
        this.robot = robot;
        this.realMap = new int[size][size];
    }
    
    public int[][] getMap() {
        return map;
    }
 
    public void setMap(int[][] map) {
        this.map = map;
    }
    
    public void setMapYX(int y, int x, int v) {
        map[y][x] = v;
    }
    
    public int getMapYX(int y, int x) {
        return map[y][x]; 
    }
 
    public void printMap() {
        for (int y = 0; y < size; y++) {
            for (int x = 0; x < size; x++) {
                if (x == robot.curX && y == robot.curY)
                    System.out.print("■ ");
                else
                    System.out.print(String.valueOf(map[y][x]) + " ");
            }
            System.out.println("");
        }
        System.out.println("");
    }
    
    public void syncRealMap() { // 회전이 없을 시 현재 map 상태를 그대로 가져온다
        for (int y = 0; y < size; y++) {
            for (int x = 0; x < size; x++) {
                realMap[y][x] = map[y][x];
            }
        }
    }
 
    public void printRealMap() {
        for (int y = 0; y < size; y++) {
            for (int x = 0; x < size; x++) {
                if (x == robot.realX && y == robot.realY)
                    System.out.print("■ ");
                else if (realMap[y][x] == 1)
                    System.out.print("# ");
                else if (realMap[y][x] == 0)
                    System.out.print("0 ");
                else
                    System.out.print("  ");
            }
            System.out.println("");
        }
        System.out.println("");
    }
 
    public void rotateMap(int cnt) {
        int[][] mapTemp = new int[size][size];
 
        for (int i = 0; i < cnt; i++) {
            for (int y = 0; y < size; y++) {
                for (int x = 0; x < size; x++) {
                    mapTemp[y][x] = map[y][x]; // map 복사
                }
            }
            for (int y = 0; y < size; y++) {
                for (int x = 0; x < size; x++) {
                    map[x][size - 1 - y] = mapTemp[y][x]; // map 회전
                }
            }
        }
    }
 
    public void rotateRealMap(int rotateCnt) { // 이전에 회전된 횟수를 파라미터로 받는다
        int[][] mapTemp = new int[size][size];
 
        for (int y = 0; y < size; y++) {
            for (int x = 0; x < size; x++) {
                realMap[y][x] = map[y][x]; // map 복사
            }
        }
 
        for (int i = 0; i < 4 - rotateCnt; i++) {
            for (int y = 0; y < size; y++) {
                for (int x = 0; x < size; x++) {
                    mapTemp[y][x] = realMap[y][x]; // map 복사
                }
            }
            for (int y = 0; y < size; y++) {
                for (int x = 0; x < size; x++) {
                    realMap[x][size - 1 - y] = mapTemp[y][x]; // map 회전
                }
            }
        }
    }
 
    public void setMapByNesw(int nesw) {
        if (nesw == 0) { // 위
            // 위 방향 기준으로 맵을 세팅하기 때문에 위 방향일 때는 고치지 않는다 
        } 
        else if (nesw == 1) { // 오른
            rotateMap(3);
            rotateRealMap(3);
            robot.rotateCnt += 3;
        } else if (nesw == 2) { // 아래
            rotateMap(2);
            rotateRealMap(2);
            robot.rotateCnt += 2;
        } else if (nesw == 3) { // 왼
            rotateMap(1);
            rotateRealMap(1);
            robot.rotateCnt += 1;
        }
    }
 
}