[PS] 99ํด๋ฝ ์ฝํ ์คํฐ๋ 35์ผ์ฐจ TIL (๊ฒ์ ๋งต ์ต๋จ๊ฑฐ๋ฆฌ)
ํ๊ทธ: 99ํด๋ฝ, BFS/DFS, PS, TIL, ์ฝ๋ฉํ ์คํธ์ค๋น, ํญํด99
์นดํ ๊ณ ๋ฆฌ: PS
๋ฌธ์
์ค๋ช
์ฅ์ ๋ฌผ(์ ์ฌ์ง์์ ๊ฒ์ ์์ญ) ์ ํผํด ๊ทธ๋ํ ์ข์ธก ์ต์๋จ(0,0) ์์ ์ฐ์ธก ์ตํ๋จ(n, m) ๊น์ง ๊ฐ๋ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ ๋ฌธ์ .
ํ์ด
์ต๋จ ๊ฒฝ๋ก ํ์์ ์ํด bfs ๋ก ํ์๋ค. ๋ฌธ์ ์์ ์ ๋ ฅ์ผ๋ก ๊ทธ๋ํ 2์ฐจ์ ๋ฐฐ์ด์ด ์ฃผ์ด์ง๋ค. bfs ํจ์ ์์๋ ๋ค์๊ณผ ๊ฐ์ ์์ ์ ํด์ผ ํ๋ค.
- ํ์ฌ ์ขํ ๋ฐฉ๋ฌธ ์ฒ๋ฆฌ
- ๊ฒฝ๊ณ ์กฐ๊ฑด ์ฒ๋ฆฌ(
isInRange
) - ๊ฐ ์ ์๋ ์ขํ๋ก ์ด๋ ์ ์นด์ดํธ ์ฆ๊ฐ (depth + 1)
- ์ข
๋ฃ ์กฐ๊ฑด:
- ๋ฌธ์ ์์ ์ฐ์ธก ์ตํ๋จ(n, m) ์ ๋๋ฌํ๋ ๊ฒฝ์ฐ
- ๊ทธ ์ต๋จ๊ฒฝ๋ก๋ฅผ ์๊ตฌํ๊ณ ์์ผ๋ฏ๋ก ํด๋น ์ขํ๊ฐ์ ๋๋ฌํ๋ฉด ์ขํ ์ด๋ ๊ฐ ๋์ ๋ depth ๊ฐ์ ๋ฐํํด ์ค๋ค.
์ฐธ๊ณ ๋ก, ๋งค๋ฒ ์๋์ ๊ฐ์ ๊ฒฝ๊ณ ํ์ธ ๋ก์ง์ ๋ฐ๋ณต์ ์ผ๋ก ์์ฑํ๊ธฐ ๊ท์ฐฎ๋ค๋ฉด Boundary Padding ๋ฐฉ๋ฒ์ ์ธ ์ ์๋ค.
1
2
3
private static boolean isInRange(int x, int y) {
return x >= 0 && x < graph.length && y >= 0 && y < graph[0].length;
}
์ด๋ฐ ๋ฌธ์ ๋ฅผ ํ ๋, ๊ทธ๋ํ ์ขํ ๊ฐ ์ธํ ์ ๊ฒฝ๊ณ์ ๋ถ๋ชํ ๊ฒ์ ๋ฏธ๋ฆฌ ๊ณ ๋ คํด index 1 ๋ถํฐ ๊ฐ์ ์ธํ ํ๊ณ , ๋ ์ธ๋ฑ์ค๋ ๋๋ํ๊ฒ 1์ด์ ๋ ํฌ๊ฒ ์ ์ธํ๋ค. ์๋ฅผ ๋ค์ด ๋ค์๊ณผ ๊ฐ์ ๋ฐฉ์์ผ๋ก graph ๋ฅผ ์ ์ธํ๊ณ , ์ธํ ํด ์ค ์ ์๋ค.
1
2
3
4
5
6
7
8
9
10
// graph ํฌ๊ธฐ๋ฅผ ์ ์ด์ ๋๋ํ๊ฒ ์ก๋๋ค.
graph = new int[n + 2][n + 2];
// index 1 ๋ถํฐ ๋ฃ์ด์ค๋ค.
for (int i = 1; i <= N; i++) {
String[] split = br.readLine().split("");
for (int j = 1; j <= M; j++) {
graph[i][j] = Integer.parseInt(split[j - 1]);
}
}
์ต๋ ์
๋ ฅ์ผ๋ก ๋ค์ด์ค๋ ๊ธธ์ด๊ฐ 1000 ์ดํ๋ฉด ๊ทธ๋ฅ 1000 + 10 ์ ๋๋ก ์ ์ธํด๋ ํฌ๊ฒ ๋ฌธ์ ์๋ค.
๋จ, ์
๋ ฅ์ผ๋ก ๋ค์ด์ค๋ ๊ธธ์ด๊ฐ 1000 ์ด์์ ํจ์ฌ ๋์ด๊ฐ๋ค๋ฉด int[][]
๊ฐ์ 2์ฐจ์ ๋ฐฐ์ด ๋ณด๋จ ArrayList<Integer>[]
๋ก ์ ์ธํด์ผ ํ๋ค.
์ด๋ ๊ฒ ์ ์ธํ๋ฉด ์ํ์ข์ฐ ํ์ ์ ๊ฒฝ๊ณ๋ฅผ ๋ฒ์ด๋๋ ๊ฒฝ์ฐ๋ ์์ ์ ์์ผ๋ฏ๋ก isInRange
๊ฐ์ ์กฐ๊ฑด์ ๋งค๋ฒ ํ์ธํ ํ์๊ฐ ์๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class Solution {
static int[][] graph;
static boolean[][] visited;
static int[] dx = {-1, 1, 0, 0};
static int[] dy = {0, 0, -1, 1};
public int solution(int[][] maps) {
graph = maps;
visited = new boolean[graph.length][graph[0].length];
return bfs();
}
private int bfs() {
Queue<int[]> queue = new LinkedList<>();
queue.add(new int[] {0, 0, 1});
visited[0][0] = true;
while (!queue.isEmpty()) {
int[] current = queue.poll();
int x = current[0];
int y = current[1];
int depth = current[2];
if (x == graph.length - 1 && y == graph[0].length - 1) {
return depth;
}
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (isInRange(nx, ny) && !visited[nx][ny] && graph[nx][ny] != 0) {
queue.add(new int[] {nx, ny, depth + 1});
visited[nx][ny] = true;
}
}
}
return -1;
}
private static boolean isInRange(int x, int y) {
return x >= 0 && x < graph.length && y >= 0 && y < graph[0].length;
}
}
๋๊ธ๋จ๊ธฐ๊ธฐ