did_story

[ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค / ์ž๋ฐ”] ๊ณต์›์‚ฐ์ฑ… ๋ณธ๋ฌธ

Algorithm๐ŸŒŠ/ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค(Programmers)

[ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค / ์ž๋ฐ”] ๊ณต์›์‚ฐ์ฑ…

์–ด์ œ์‹œ์ž‘ 2025. 9. 12. 22:01

์˜ค๋Š˜๋„ ๋‚˜๋Š” ๋ฉ์ฒญํ•จ์„ ๋А๋ผ๋ฉฐ, ์ž์กฐ์ ์ด๊ฒŒ ๋‹ค์‹œ ์ฝ”๋“œ ์ง ๊ฒƒ์„ ์ด์•ผ๊ธฐ ํ•ด๋ณผ๋ ค๊ณ  ํ•œ๋‹ค.

 

๋ฌธ์ œ ์ •์˜

์ง€๋‚˜๋‹ค๋‹ˆ๋Š” ๊ธธ์„ 'O', ์žฅ์• ๋ฌผ์„ 'X'๋กœ ๋‚˜ํƒ€๋‚ธ ์ง์‚ฌ๊ฐํ˜• ๊ฒฉ์ž ๋ชจ์–‘์˜ ๊ณต์›์—์„œ ๋กœ๋ด‡ ๊ฐ•์•„์ง€๊ฐ€ ์‚ฐ์ฑ…์„ ํ•˜๋ คํ•ฉ๋‹ˆ๋‹ค. ์‚ฐ์ฑ…์€ ๋กœ๋ด‡ ๊ฐ•์•„์ง€์— ๋ฏธ๋ฆฌ ์ž…๋ ฅ๋œ ๋ช…๋ น์— ๋”ฐ๋ผ ์ง„ํ–‰ํ•˜๋ฉฐ, ๋ช…๋ น์€ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ํ˜•์‹์œผ๋กœ ์ฃผ์–ด์ง‘๋‹ˆ๋‹ค.

["๋ฐฉํ–ฅ ๊ฑฐ๋ฆฌ", "๋ฐฉํ–ฅ ๊ฑฐ๋ฆฌ" … ]

์˜ˆ๋ฅผ ๋“ค์–ด "E 5"๋Š” ๋กœ๋ด‡ ๊ฐ•์•„์ง€๊ฐ€ ํ˜„์žฌ ์œ„์น˜์—์„œ ๋™์ชฝ์œผ๋กœ 5์นธ ์ด๋™ํ–ˆ๋‹ค๋Š” ์˜๋ฏธ์ž…๋‹ˆ๋‹ค. ๋กœ๋ด‡ ๊ฐ•์•„์ง€๋Š” ๋ช…๋ น์„ ์ˆ˜ํ–‰ํ•˜๊ธฐ ์ „์— ๋‹ค์Œ ๋‘ ๊ฐ€์ง€๋ฅผ ๋จผ์ € ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.

์ฃผ์–ด์ง„ ๋ฐฉํ–ฅ์œผ๋กœ ์ด๋™ํ•  ๋•Œ ๊ณต์›์„ ๋ฒ—์–ด๋‚˜๋Š”์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค. ์ฃผ์–ด์ง„ ๋ฐฉํ–ฅ์œผ๋กœ ์ด๋™ ์ค‘ ์žฅ์• ๋ฌผ์„ ๋งŒ๋‚˜๋Š”์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.

์œ„ ๋‘ ๊ฐ€์ง€์ค‘ ์–ด๋А ํ•˜๋‚˜๋ผ๋„ ํ•ด๋‹น๋œ๋‹ค๋ฉด, ๋กœ๋ด‡ ๊ฐ•์•„์ง€๋Š” ํ•ด๋‹น ๋ช…๋ น์„ ๋ฌด์‹œํ•˜๊ณ  ๋‹ค์Œ ๋ช…๋ น์„ ์ˆ˜ํ–‰ํ•ฉ๋‹ˆ๋‹ค. ๊ณต์›์˜ ๊ฐ€๋กœ ๊ธธ์ด๊ฐ€ W, ์„ธ๋กœ ๊ธธ์ด๊ฐ€ H๋ผ๊ณ  ํ•  ๋•Œ, ๊ณต์›์˜ ์ขŒ์ธก ์ƒ๋‹จ์˜ ์ขŒํ‘œ๋Š” (0, 0), ์šฐ์ธก ํ•˜๋‹จ์˜ ์ขŒํ‘œ๋Š” (H - 1, W - 1) ์ž…๋‹ˆ๋‹ค.

 

ํ•ด๊ฒฐ ๋ฐฉ๋ฒ• ๊ณ ์•ˆ

1. ํ•ด๋‹น ๋ฐฉํ–ฅ์œผ๋กœ ๊ฒฝ๋กœ ๊ฒ€์ฆ๋งŒ ํ•˜๋ฉด ๋œ๋‹ค๊ณ  ์ƒ๊ฐํ–ˆ๊ณ .

2. Map์œผ๋กœ ํ•ด๋‹น ๋ฐฉํ–ฅ๊ณผ ์›€์ง์ด๋Š” ๊ฒฝ๋กœ๋ฅผ mapping ํ•ด์„œ ์‚ฌ์šฉํ•˜๋ฉด ๋  ๊ฒƒ์ด๋ผ๊ณ  ์ƒ๊ฐํ•ด์„œ ๊ทธ๋ ‡๊ฒŒ ์ฝ”๋“œ๋ฅผ ๋งŒ๋“ค์–ด ๋ณด์•˜๋‹ค.

 

ํ•ด๊ฒฐ

import java.util.Map;
class Solution {
    private final Map<String, int[]> DIRECTIONS = Map.of(
            "E", new int[]{0, 1},
            "W", new int[]{0, -1},
            "S", new int[]{1, 0},
            "N", new int[]{-1, 0}
    );

    private static boolean isValidMove(int startX, int startY, int[][] graph, String direction, int distance) {
        int[] move = DIRECTIONS.get(direction);
        for (int step = 1; step <= distance; step++) {
            int newX = startX + move[0] * step;
            int newY = startY + move[1] * step;
            if (!(x >= 0 && x < maxX && y >= 0 && y < maxY) || graph[newX][newY] == -1) {
                return false;
            }
        }
        return true;
    }

    public int[] solution(String[] park, String[] routes){
        int startX = 0, startY = 0;
        int rows = park.length;
        int cols = park[0].length();
        int[][] graph = new int[rows][cols];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                char cell = park[i].charAt(j);
                if (cell == 'S') {
                    startX = i;
                    startY = j;
                    graph[i][j] = 0;
                } else if (cell == 'O') {
                    graph[i][j] = 0;
                } else {
                    graph[i][j] = -1;
                }
            }
        }

        for (String route : routes) {
            String[] parts = route.split(" ");
            String direction = parts[0];
            int distance = Integer.parseInt(parts[1]);

            if (isValidMove(startX, startY, graph, direction, distance)) {
                int[] move = DIR.get(direction);
                startX += move[0] * distance;
                startY += move[1] * distance;
            }
        }

        return new int[]{startX, startY};
    }
}

 

 

์•„์‰ฌ์šด์ .

1. ์ฒ˜์Œ ์ฝ”๋“œ๋ฅผ ๊ตฌ์ƒํ•˜๊ณ  ๋งŒ๋“ค๋•Œ, method๋ฅผ ๋งŒ๋“ค์ง€ ์•Š๋‹ค๋ณด๋‹ˆ if๋ฌธ ์•ˆ์— ์ด์ค‘ for๋ฌธ์„ ๊ตฌ์ƒํ•˜๋Š” ์˜ค๋ฅ˜๋ฅผ ๋ฒ”ํ•˜์˜€๊ณ ,

2. ๋ฌด๋ถ„๋ณ„ํ•œ if๋ฌธ์˜ ๋…ธ์ถœ๋กœ ๋ณธ์ธ์˜ ์ฝ”๋“œ๋ฅผ ์ •ํ™•ํžˆ ํŒŒ์•…ํ•˜์ง€ ๋ชปํ•œ ๋‚˜์˜ ์ž์กฐ์  ๋ฌธ์ œ๊ฐ€ ์žˆ์—ˆ๋‹ค.

3. 1๋ฒˆ์งธ ์ฝ”๋“œ๋„ ํ†ต๊ณผ๋Š” ํ•˜์˜€์ง€๋งŒ, ํ•ด๋‹น ์ฝ”๋“œ๋ฅผ ๋ณด๋ฉด ํ•œ์ˆจ๋งŒ ๋‚˜์™€์„œ ๋‹ค์‹œ ํ’€์–ด๋ณด๋‹ˆ, ๋ฌธ์ œ๋ฅผ ์–•๋ณด์ง€ ์•Š๊ณ  ์ •๋ฆฌํ•˜๋ฉด์„œ ์ฝ”๋“œ๋ฅผ ๋งŒ๋“œ๋Š”๊ฒŒ ์ค‘์š”ํ•จ์„ ๋‹ค์‹œํ•œ๋ฒˆ ๋А๋‚€๋‹ค.