did_story
[ํ๋ก๊ทธ๋๋จธ์ค / ์๋ฐ] ๊ณต์์ฐ์ฑ ๋ณธ๋ฌธ
[ํ๋ก๊ทธ๋๋จธ์ค / ์๋ฐ] ๊ณต์์ฐ์ฑ
์ด์ ์์ 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๋ฒ์งธ ์ฝ๋๋ ํต๊ณผ๋ ํ์์ง๋ง, ํด๋น ์ฝ๋๋ฅผ ๋ณด๋ฉด ํ์จ๋ง ๋์์ ๋ค์ ํ์ด๋ณด๋, ๋ฌธ์ ๋ฅผ ์๋ณด์ง ์๊ณ ์ ๋ฆฌํ๋ฉด์ ์ฝ๋๋ฅผ ๋ง๋๋๊ฒ ์ค์ํจ์ ๋ค์ํ๋ฒ ๋๋๋ค.
'Algorithm๐ > ํ๋ก๊ทธ๋๋จธ์ค(Programmers)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [ํ๋ก๊ทธ๋๋จธ์ค / JAVA] ๋๋๊ณผ ๋ง๋ ๊ทธ๋ํ. (0) | 2025.09.30 |
|---|---|
| [ํ๋ก๊ทธ๋๋จธ์ค / Java] ๊ฑฐ๋ฆฌ๋๊ธฐ ํ์ธํ๊ธฐ (0) | 2025.09.29 |
| [ํ๋ก๊ทธ๋๋จธ์ค / JAVA] JadenCase ๋ฌธ์์ด ๋ง๋ค๊ธฐ (3) | 2025.07.10 |
| [ํ๋ก๊ทธ๋๋จธ์ค / JAVA ] ์คํจ์จ (2) | 2025.07.09 |
| [ํ๋ก๊ทธ๋๋จธ์ค / JAVA] ๋์ถฉ ๋ง๋ ์ํ (3) | 2025.07.07 |