[프로그래머스] Lv1. 공원 산책

 

 

프로그래머스 Lv1 중 서치 없이 푸는데 실패한 문제를 정리한 내용입니다.

정리 내용 출처는 아래를 참고해 주세요.

 

---

 

문제 설명

 

지나다니는 길을 'O', 장애물을 'X'로 나타낸 직사각형 격자 모양의 공원에서 로봇 강아지가 산책을 하려합니다. 산책은 로봇 강아지에 미리 입력된 명령에 따라 진행하며, 명령은 다음과 같은 형식으로 주어집니다.

["방향 거리", "방향 거리" … ]

 

예를 들어 "E 5"는 로봇 강아지가 현재 위치에서 동쪽으로 5칸 이동했다는 의미입니다. 로봇 강아지는 명령을 수행하기 전에 다음 두 가지를 먼저 확인합니다.

 

• 주어진 방향으로 이동할 때 공원을 벗어나는지 확인합니다.
• 주어진 방향으로 이동 중 장애물을 만나는지 확인합니다.

 

위 두 가지중 어느 하나라도 해당된다면, 로봇 강아지는 해당 명령을 무시하고 다음 명령을 수행합니다.
공원의 가로 길이가 W, 세로 길이가 H라고 할 때, 공원의 좌측 상단의 좌표는 (0, 0), 우측 하단의 좌표는 (H - 1, W - 1) 입니다

 

공원을 나타내는 문자열 배열 park,

로봇 강아지가 수행할 명령이 담긴 문자열 배열 routes가

매개변수로 주어질 때,

 

로봇 강아지가 모든 명령을 수행 후 놓인 위치를 [세로 방향 좌표, 가로 방향 좌표] 순으로 배열에 담아 return 하도록

solution 함수를 완성해주세요.

 

 

 

제한사항

• 3 ≤ park의 길이 ≤ 50
• 3 ≤ park[i]의 길이 ≤ 50
  • park[i]는 다음 문자들로 이루어져 있으며 시작지점은 하나만 주어집니다.
    • S : 시작 지점
    • O : 이동 가능한 통로
    • X : 장애물
• park는 직사각형 모양입니다.
• 1 ≤ routes의 길이 ≤ 50
• routes의 각 원소는 로봇 강아지가 수행할 명령어를 나타냅니다.
• 로봇 강아지는 routes의 첫 번째 원소부터 순서대로 명령을 수행합니다.
• routes의 원소는 "op n"과 같은 구조로 이루어져 있으며, op는 이동할 방향, n은 이동할 칸의 수를 의미합니다.
  • op는 다음 네 가지중 하나로 이루어져 있습니다.
    • N : 북쪽으로 주어진 칸만큼 이동합니다.
    • S : 남쪽으로 주어진 칸만큼 이동합니다.
    • W : 서쪽으로 주어진 칸만큼 이동합니다.
    • E : 동쪽으로 주어진 칸만큼 이동합니다.
  • 1 ≤ n ≤ 9

 

 

입출력 예

park	routes	result
["SOO", "OOO", "OOO"]	["E 2", "S 2", "W 1"]	[2, 1]
["SOO", "OXX", "OOO"]	["E 2", "S 2", "W 1"]	[0, 1]
["OSO", "OOO", "OXO", "OOO"]	["E 2", "S 3", "W 1"]	[0, 0]

 

 

 

방식 해설

 

1차원 문자열 배열로 이루어진 park가 입력값으로 주어진다.

해당 배열의 원소들은 각각 공원의 길이(H)에 해당하며, 배열의 각 문자열을 ""로 쪼개면 또 각각 공원의 넓이(W)에 해당하는 정보가 된다.

위 내용을 이용해 공원의 정보("S", "O", "X")를 가지고 있는 2차원 배열을 만들준다.

 

공원의 길이(H), 넓이(W) 만큼 반복문을 이용해 탐색하며 위에서 찾은 공원 정보 배열인 parkArray의 값이 "S"인 경우를 찾아 시작 로봇의 위치를 구한다.

 

입력값으로 주어진 route의 각 원소를 쪼개어 각각 문자(방향)와 숫자(이동 횟수)를 알아낸다.

이때 방향에 따라

"N"이면 위로 이동해야 하기 때문에 로봇의 H를 줄이고

"S"이면 아래로 이동해야 하기 때문에 로봇의 H를 늘리고

"W"이면 왼쪽으로 이동해야 하기 때문에 로봇의 W를 줄이고

"E"이면 오른쪽으로 이동해야 하기 때문에 로봇의 W가 늘어난다.

 

로봇의 이동이 이뤄질때 로봇의 위치(robotH, robotW)가 공원의 범위(0부터 parkH까지, 0부터 parkW까지)를 벗어나지 않아야 하며,

로봇이 이동할 곳의 parkArray[] 원소가  "X"이면 이동을 할 수 없다.

 

* 이 부분이 가장 착각할 수 있는 부분이다.

   parkArray 원소가 "X"인 경우 건너뛰고 다음 원소가 "O"인 경우 이동할 수 있는 것이 아니라

   parkArray 원소가 한번이라도 "X"가 나온 경우 그 다음 이동을 진행할 수 없는 것이다.

 

위 두가지의 조건을 만족하는 경우 로봇의 위치를 이동시킨다.

 

모든 이동이 끝난 이후에 로봇의 위치를 answer에 넣어준다.

class Solution {
    public static int[] solution(String[] park, String[] routes) {
    	// 공원 길이 변수 선언
        int parkH =park.length;
        int parkW =park[0].length();
        
        // 로봇 위치 변수 선언
        int robotH =0;
        int robotW =0;
        
        // 공원 배열 변수 선언하고 값 할당
        String[][] parkArray = new String[parkH][parkW];
        for (int i = 0; i < parkH; i++){
            String[] parkOX = park[i].split("");
            for (int j = 0; j < parkW; j++){
                parkArray[i][j] = parkOX[j];
            }
        }
        
        // 로봇 위치 탐색하기
        for(int i = 0; i < parkH; i++){
            for(int j = 0; j < parkW; j++){
                if(parkArray[i][j].equals("S")){
                    robotH = i;
                    robotW = j;
                    break;
                }
            }
        }
        
        for(int i = 0; i < routes.length; i++){
            // routes (문자 반복횟수)를 나눠 spl 배열에 담아준다.
            String[] spl = routes[i].split(" ");
            
            // 반복횟수를 time 변수에 담아준다.
            int time = Integer.parseInt(spl[1]);
            
            // X를 만나서 더이상 지나갈 수 없을 경우 go를 false로 표시해 이후 단계를 무시하도록 하기 위한 변수 선언
            boolean go = true;
            
            // 각각 문자(방향)에 따라 경우의 수를 준다.
            switch (spl[0]){
                case "N": //H줄이기
                    if(robotH-time<0) {
                        break;
                    }
                    for (int n = 1; n <= time; n++){
                        if (parkArray[robotH - n][robotW].equals("X")) {
                            go = false;
                        }
                    }
                    if (go == false){
                        break;
                    }
                    robotH -= time;
                    break;
                case "S": //H늘리기
                    if (robotH + time >= parkH) {
                        break;
                    }
                    for (int n = 1; n <= time; n++){
                        if (parkArray[robotH + n][robotW].equals("X")) {
                            go = false;
                        }
                    }
                    if (go == false) {
                        break;
                    }
                    robotH += time;
                    break;
                case "W": //W줄이기
                    if (robotW - time < 0) {
                        break;
                    }
                    for (int n = 1; n <= time; n++) {
                        if (parkArray[robotH][robotW - n].equals("X")) {
                            go = false;
                        }
                    }
                    if (go == false) {
                        break;
                    }
                    robotW -= time;
                    break;
                case "E": //W늘리기
                    if (robotW + time >= parkW) {
                        break;
                    }
                    for (int n = 1; n <= time; n++) {
                        if (parkArray[robotH][robotW + n].equals("X")) {
                            go = false;
                        }
                    }
                    if (go == false) {
                        break;
                    }
                    robotW += time;
                    break;
            }
        }
        
        // 경우의 수에 따른 모든 이동 이후에 각각 로봇의 좌표를 answer에 담아준다.
        int[] answer = new int[2];
        answer[0] = robotH;
        answer[1] = robotW;
        return answer;
    }
}

 

 

 

 

---

* https://whwnd5993.tistory.com/32