99클럽 코테 스터디 27일차 - 완전탐색

문제

공원 산책

풀이

• 주어진 배열에 따라 좌표를 이동시키는 것.
• 제한 조건으로는 'X'를 만나면 해당 move는 상쇄된다.
• 동서남북에 따라 x, y의 움직임을 지정한다
• 시작점이 항상 [0,0]이 아니므로 시작점을 먼저 구한다
• routes를 순회하면서 현재 좌표를 업데이트 한다.

코드 - 절차 지향

import java.util.HashMap;
import java.util.Map;


class Solution {
    public int[] solution(String[] park, String[] routes) {
        // dir map을 생성
        
        Map<String, int[]> direction = new HashMap<>();
       
        direction.put("E", new int[]{0, 1});
        direction.put("W", new int[]{0, -1});
        direction.put("S", new int[]{1, 0});
        direction.put("N", new int[]{-1, 0});
        
        int x = 0; 
        int y = 0;
        
        // 시작점 탐색
        for(int i = 0; i < park.length; i++){
            for(int j = 0; j < park[0].length(); j++){
                if(park[i].charAt(j) == 'S'){
                    x = i;
                    y = j;
                }
            }
        }
        
        for(String route : routes){
            String[] splited = route.split(" ");
            String r = splited[0];
            int n = Integer.parseInt(splited[1]);
            
            int nx = x;
            int ny = y;
            
            int step = 0;
            
            while(step < n) {
                nx = nx + direction.get(r)[0];
                ny = ny + direction.get(r)[1];
                
                if(nx < 0 || nx >= park.length || ny < 0 || ny >= park[0].length() || park[nx].charAt(ny) == 'X') {
                    break;
                }
                  step++;        
            }
            
            if(step == n) {
                x = nx;
                y = ny;
            }
        }
    
      return new int[]{x, y};
    }
}

코드 - 객체 지향 (나름)

class Solution {
    private static final Map<String, int[]> DIRECTION_MAP = new HashMap<>();
            
    static {
        DIRECTION_MAP.put("E", new int[]{0, 1});
        DIRECTION_MAP.put("W", new int[]{0, -1});
        DIRECTION_MAP.put("S", new int[]{1, 0});
        DIRECTION_MAP.put("N", new int[]{-1, 0});
    }
    
    public int[] solution (String[] parkInput, String[] routes) {
        Park park = new Park(parkInput);
        Position pos = park.startPos;
        
        for(String r : routes){
            String[] routeInfo = r.split(" ");
            String dir = routeInfo[0];
            int step = Integer.parseInt(routeInfo[1]);
            
            if(park.canMove(pos, dir, step)) {
                pos.move(DIRECTION_MAP.get(dir), step);
            }
        }
        
        return new int[]{pos.x, pos.y};    
    }
    
    class Park {
        char[][] board;
        Position startPos;

        public Park(String[] park) {
            board = new char[park.length][];

            for(int i = 0; i < park.length; i++){
                board[i] = park[i].toCharArray();
            }

            this.startPos = findStartPos();
        }

        private Position findStartPos() {
            for(int i = 0; i < board.length; i++){
                for(int j = 0; j < board[i].length; j++){
                    if(board[i][j] == 'S') {
                        return new Position(i , j);
                    }
                }
            }
            return null;
      }

      public boolean canMove(Position pos, String dir, int step){
          Position tempPos = new Position(pos.x, pos.y);

          for(int i = 0; i < step; i++){
              tempPos.move(DIRECTION_MAP.get(dir), 1);
              if(tempPos.isLimit(board.length, board[0].length) || tempPos.isBlocked(board)) {
                  return false;
              }
          }

          return true;
      }
}

class Position {
      int x;
      int y;

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

      public void move(int[] direction, int step){
          this.x += direction[0] * step;
          this.y += direction[1] * step;
      }

      public boolean isLimit(int r, int c){
          return x < 0 || x >= r || y < 0 || y >= c;
      }

      public boolean isBlocked(char[][] board){
          return board[x][y] == 'X';
      }
   }
}

정리