๐ ๋ฌธ์ ํ์ํ๊ธฐ
- ๋ฏธ๋ก์ ํฌ๊ธฐ๋ 1xN (1 ≤ N ≤ 1,000)
- ๊ฐ ์นธ์๋ ์ ์ A(i) (0 ≤ A(i) ≤ 100)๊ฐ ์ฐ์ฌ์์
- ๊ฐ ์นธ์ ์ฐ์ธ ์ ์ดํ๋งํผ ์ค๋ฅธ์ชฝ์ผ๋ก ๋จ์ด์ง ์นธ์ผ๋ก ํ๋ฒ์ ์ ํ ๊ฐ๋ฅ
- ์ฌํ์ด๊ฐ ๋ฏธ๋ก์ ๊ฐ์ฅ ์ผ์ชฝ ๋์์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋์ผ๋ก ๊ฐ๋ ค๊ณ ํ ๋, ์ต์ ๋ช ๋ฒ ์ ํํด์ผ ๊ฐ ์ ์๋์ง ๊ตฌํ๊ธฐ
- ๊ฐ ์ ์๋ ๊ฒฝ์ฐ -1 ์ถ๋ ฅ
์ด ๋ฌธ์ ๋ ์ฃผ์ด์ง ์ ๋ณด๋ฅผ ๊ทธ๋ํ๋ก ํํํ ์ ์๊ณ , ์ต์ ํ์๋ก ๋๋ฌํ๋ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ ๊ฒ์ด๋ฏ๋ก BFS๊ฐ ์ ํฉํ๋ค. ์ฌ๊ธฐ์ ๋ฏธ๋ก์ ๊ฐ ์นธ๋ค์ ์ ์ ์ผ๋ก ๋ณผ ์ ์๊ณ , ๊ฐ ์นธ์์ ์ ํ ๊ฐ๋ฅํ ์นธ๋ค๋ก ์ด๋ํ๋ ๊ฒ์ ๊ฐ์ ์ผ๋ก ํด์ํ ์ ์๋ค. BFS๋ ํ์ ๊ณผ์ ์์ ๊ฑฐ๋ฆฌ๊ฐ ์งง์ ๋ ธ๋๋ถํฐ ๋ฐฉ๋ฌธํ๋ฏ๋ก, ์ฒ์์ผ๋ก ๋ชฉํ ์ง์ ์ ๋๋ฌํ ์๊ฐ์ด ์ต๋จ ๊ฑฐ๋ฆฌ๋ผ๋ ๊ฒ์ ๋ณด์ฅํ๋ค. ์ด๋ฅผ ์ด์ฉํด ์นธ์ ํ๋์ฉ ๋ฐฉ๋ฌธํ์ฌ ์ ํ๋ฅผ ์๋ํ๊ณ , ์ต์ ํ์๋ฅผ ์ฐพ์ผ๋ฉด ๋๋ค.
์์์ ์์ ์ ํํ ์ ์๋ ๋ชจ๋ ์นธ์ ํ์ธํ๋ฉด์ ์ต๋จ ๊ฑฐ๋ฆฌ๋ก ๋ ์ง์ ์ ๋๋ฌํ๋ ์๊ฐ์ ์ฐพ๋ ๊ฒ์ด๋ฏ๋ก, BFS ํ์ ์ ๊ฐ ์นธ์ ์ต๋ ํ ๋ฒ์ฉ ๋ฐฉ๋ฌธํ๋ค. ๋ฐ๋ผ์ BFS ํ์์ ๋ฏธ๋ก์ ๊ธธ์ด N์ ๋น๋กํ๋ O(N)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๊ฒ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๊ฐ ํ์ ํ์ฐจ๋ง๋ค ํ์ฌ ์นธ์์ ์ด๋ํ ์ ์๋ ์นธ์ ์ต๋ ์นธ์ ์ฐ์ธ ์๋งํผ์ด์ง๋ง, ์ ํ๋ ๊ฐ์ ์ ๋ชจ๋ ํ์ํด๋ ์์ ์๊ฐ์ ํด๋นํ๋ค. ๋ฐ๋ผ์ ์ด ๋ฌธ์ ๋ฅผ BFS๋ก ํ์ด ํ์ ๊ฒฝ์ฐ์ ์ต์ข ์๊ฐ ๋ณต์ก๋๋ O(N)์ด๋ค.
๐ ์ฝ๋ ์ค๊ณํ๊ธฐ
- ๋ฏธ๋ก์ ํฌ๊ธฐ N๊ณผ ๋ฏธ๋ก์ ๊ฐ ์นธ์ ์ฐ์ธ ์ซ์ ์ ๋ณด A ๋ฆฌ์คํธ๋ก ์ ๋ ฅ๋ฐ๊ธฐ
- ๋ฏธ๋ก์ ํฌ๊ธฐ๊ฐ 1์ธ ๊ฒฝ์ฐ ํ์ ํ์์์ด ์ต์ ํ์ 0 ์ถ๋ ฅ
- ํ๋ฅผ ์์ฑํ๊ณ , ํ์ ์์์์น์ ์ธ๋ฑ์ค์ ํ์ฌ ์ ํ ํ์(0,0) ๋ฃ๊ธฐ
- ๋ฐฉ๋ฌธ ์ฒดํฌ์ฉ ๋ฆฌ์คํธ visited๋ฅผ False๋ก ์ด๊ธฐํ
- ๊ฐ ์นธ์์ ์ ํํ ์ ์๋ ์ต๋ ๋ฒ์๋ฅผ ์ํํ๋ฉฐ ํ์ ๋ค์ ์นธ ์ถ๊ฐ
- ์๋ก์ด ์นธ์ ๋๋ฌํ ๋๋ง๋ค ๋ฐฉ๋ฌธ ์ฒดํฌ ํ ์ ํ ํ์ 1 ์ฆ๊ฐํ์ฌ ํ์ ์ถ๊ฐ
- ๋ชฉํ ์ง์ ์ ๋๋ฌํ ๊ฒฝ์ฐ ์ ํ ํ์ ์ถ๋ ฅ
๐ ์ ๋ต ์ฝ๋
from collections import deque
def min_jumps(N, A):
if N == 1:
return 0
q = deque([(0, 0)])
visited = [False] * N
visited[0] = True
while q:
idx, jumps = q.popleft()
# A[idx]์ ๋ฒ์ ๋ด์์ ๊ฐ๋ฅํ ์ ํ๋ฅผ ํ์ธ
for i in range(1, A[idx] + 1):
next_idx = idx + i
if next_idx >= N - 1:
return jumps + 1
if not visited[next_idx]:
visited[next_idx] = True
q.append((next_idx, jumps + 1))
return -1
N = int(input())
A = list(map(int, input().split()))
print(min_jumps(N,A))