Problem
๋ฌธ์
์๋น์ด๋ ๋์๊ณผ ์จ๋ฐ๊ผญ์ง์ ํ๊ณ ์๋ค. ์๋น์ด๋ ํ์ฌ ์ N(0 โค N โค 100,000)์ ์๊ณ , ๋์์ ์ K(0 โค K โค 100,000)์ ์๋ค. ์๋น์ด๋ ๊ฑท๊ฑฐ๋ ์๊ฐ์ด๋์ ํ ์ ์๋ค. ๋ง์ฝ, ์๋น์ด์ ์์น๊ฐ X์ผ ๋ ๊ฑท๋๋ค๋ฉด 1์ด ํ์ X-1 ๋๋ X+1๋ก ์ด๋ํ๊ฒ ๋๋ค. ์๊ฐ์ด๋์ ํ๋ ๊ฒฝ์ฐ์๋ 1์ด ํ์ 2*X์ ์์น๋ก ์ด๋ํ๊ฒ ๋๋ค.
์๋น์ด์ ๋์์ ์์น๊ฐ ์ฃผ์ด์ก์ ๋, ์๋น์ด๊ฐ ๋์์ ์ฐพ์ ์ ์๋ ๊ฐ์ฅ ๋น ๋ฅธ ์๊ฐ์ด ๋ช ์ด ํ์ธ์ง ๊ทธ๋ฆฌ๊ณ , ๊ฐ์ฅ ๋น ๋ฅธ ์๊ฐ์ผ๋ก ์ฐพ๋ ๋ฐฉ๋ฒ์ด ๋ช ๊ฐ์ง ์ธ์งย ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ์๋น์ด๊ฐ ์๋ ์์น N๊ณผ ๋์์ด ์๋ ์์น K๊ฐ ์ฃผ์ด์ง๋ค.ย N๊ณผ K๋ ์ ์์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์๋น์ด๊ฐ ๋์์ ์ฐพ๋ ๊ฐ์ฅ ๋น ๋ฅธ ์๊ฐ์ ์ถ๋ ฅํ๋ค.
๋์งธ ์ค์๋ ๊ฐ์ฅ ๋น ๋ฅธ ์๊ฐ์ผ๋ก ์๋น์ด๊ฐ ๋์์ ์ฐพ๋ ๋ฐฉ๋ฒ์ ์๋ฅผ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1
5 17
Plain Text
๋ณต์ฌ
์์ ์ถ๋ ฅ 1
4
2
Plain Text
๋ณต์ฌ
Code
ย #1
Idea
์ผ๋ฐ์ ์ธ bfs ๊ณผ์
1.
ํ์์ ๋
ธ๋ ํ๋ pop
2.
popํ ๋
ธ๋์ ์ธ์ ๋
ธ๋(์์๋
ธ๋)๋ฅผ ํ์
3.
์ธ์ ๋
ธ๋ ์ค ๋ฏธ๋ฐฉ๋ฌธ๋
ธ๋๋ง ๋ฐฉ๋ฌธ์ฒ๋ฆฌ ํ, ํ์ ์ถ๊ฐ
์ด๋ฌํ ์ผ๋ฐ์ ์ธ bfs ๋ก ๊ตฌํ์ ํ๋ฉด, ํ ๋ฒ ๋ฐฉ๋ฌธํ ๋
ธ๋๋ ๋ค์ ํ์ ์ถ๊ฐ๋์ง ์๋๋ค.
๊ทธ๋ฐ๋ฐ ์ด ๋ฌธ์ ์์๋ ์ด๋ฏธ ๋ฐฉ๋ฌธํ ๊ฐ์ ๋
ธ๋๋๋ผ๋, ์นด์ดํ
์ ํด์ค์ผ ํ๋ค.
17๋ฒ ๋
ธ๋๊น์ง ์ต๋จ๊ฑฐ๋ฆฌ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ณ์ฐํ ๋, 4โ8โ16โ17 ๊ฒฝ๋ก์์ 17๋ฒ ๋
ธ๋๋ฅผ ๋ฐฉ๋ฌธ์ฒดํฌ ํ์ผ๋ฏ๋ก, 10โ9โ18 ๊ฒฝ๋ก์์ 17๋ฒ ๋
ธ๋๊ฐ ์ด๋ฏธ ์์์ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ๋์ผ๋ฏ๋ก, 17๋ฒ ๋
ธ๋๋ ๊ฑธ๋ฌ์ง๊ฒ ๋๋ค. ๋ฐ๋ผ์ ์นด์ดํ
์ด ์ ๋๋ค.
๊ทธ๋ผ ํ์ฌ๋
ธ๋์ ์ธ์ ๋
ธ๋(์์๋
ธ๋)๋ฅผ ํ์ํ ๋, ์ฐ๋ฆฌ๊ฐ ์ฐพ๋ ๋
ธ๋(ex.17๋ฒ๋
ธ๋)๋ง ์กฐ๊ฑด๋ฌธ์ผ๋ก ์์ธ์ฒ๋ฆฌ๋ฅผ ํด์ ์นด์ดํ
์ ํ๋ฉด ๋๊ฒ ์ง ์ถ์ด์ ํ๋๋ฐ ๊ฒฐ๊ณผ์ ์ผ๋ก๋ ํ๋ฆฌ๋ค.
์์ฒ๋ผ ๊ฐ์ ๋ถ๋ชจ๋ฅผ ์ฌ๋ฌ ๋ฒ ๊ฒน์น๊ฒ ๋๋ ๊ฒฝ์ฐ๊ฐ ๋ฐ๋ก์ด๋ค. 1๋ฒ ๋
ธ๋ ์
์ฅ์์๋ ์ฐ๋ฆฌ๊ฐ ์ฐพ๋ ๋
ธ๋์ธ 6๋ฒ ๋
ธ๋๋ ์ ๋ณด์ด๊ณ ๋ฟ๋ง์๋๋ผ 3๋ฒ๋
ธ๋๋ ๋ชจ๋ฅด๋ ์ํ์ด๋ค.
๋ฃจํธ๋
ธ๋์ธ 1๋ฒ ๋
ธ๋๋ฅผ popํ๊ฒ ๋๋ฉด, 0๋ฒ,2๋ฒ ๋
ธ๋๋ง ๋ด๊ธฐ๊ฒ ๋๋ค.
๋ง์ง๋ง 2๋ฒ ๋
ธ๋๊ฐ ์ ๋ด๊ธฐ๋ฏ๋ก ์ฌ๊ธฐ์๋ถํฐ ํ๋ ค์ง๊ฒ ๋๋ ๊ฒ์ด๋ค.
๋ฐ๋ผ์ ํ์ฌ ๋ ๋ฒจ์ ๊ฐ์ ๋
ธ๋๊ฐ ์๋์ง๋ฅผ ํญ์ ์ฒดํฌํด์ค์ผ ํ๋ค.
๋ฌผ๋ก ์ผ๋ฐ์ ์ธ bfs๋ฐฉ์์์ ํ์ฌ ๋ ๋ฒจ์์ ๋์ผํ ๋
ธ๋๋ ํ์ ๋ด๊ธฐ์ง๋ ์๋๋ค. (์ด๋ฏธ ๋ฐฉ๋ฌธ์ ํ์ผ๋ฏ๋ก)
์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๋ฃจํธ ๋
ธ๋๋ถํฐ ํ์ฌ๋
ธ๋ ๊น์ง์ ์ต๋จ๊ฑฐ๋ฆฌ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ธฐ๋กํ๋ ๋ฆฌ์คํธ๊ฐ ํ์ํ๋ค.
๊ธฐ์กด์ ๋ฐฉ๋ฌธํ ๋
ธ๋๋ฅผ ๊ฐ์ ๋ ๋ฒจ์์ ๋ง๋๋ฉด ์ด๋ฏธ ๋ฐฉ๋ฌธํ ๋
ธ๋์ด๋ฏ๋ก ํ์ ๋ด์ง๋ ์์ง๋ง, ๊ฒฝ์ฐ์ ์๋ง ์ถ๊ฐ์์ผ์ฃผ๋ฉด ๋๋ค.
ย Code
import sys
from collections import deque
read = sys.stdin.readline
n, k = map(int, read().split())
dist = [-1] * 100001 # ์์๋
ธ๋๋ถํฐ์ ๊ฑฐ๋ฆฌ(์๊ฐ) ( bfs ๋ ๋ฒจ)
cnt = [0] * 100001 # ๊ฒฝ์ฐ์ ์
def bfs(v):
deq = deque([v])
dist[v] = 0 # ์์๋
ธ๋ ์๊ธฐ์์ ์ ๊ฑฐ๋ฆฌ 0
cnt[v] = 1 # ์์๋
ธ๋ ์๊ธฐ์์ ๊ฒฝ์ฐ์์ 1 ๊ธฐ๋ณธ์ธํ
flag = 0
while deq:
for _ in range(len(deq)):
x = deq.popleft()
# ์ด๋ฒ ๋ ๋ฒจ์ ์ฐพ๋ ๋
ธ๋๊ฐ ์์ผ๋ฏ๋ก ์ด๋ฒ ๋ ๋ฒจ ํ์๋๋๋ฉด ํ์ถ
# ์ด๋ฒ ๋ ๋ฒจ์ ๋์ผ ๋
ธ๋ ์์ ์ ์์ผ๋ฏ๋ก ๋ฐ๋ก ํ์ถํ๋ฉด์ ์ ๋จ => flag ์ค์ if x == k:
flag = 1
for nxt in (x - 1, x + 1, x * 2):
if 0 <= nxt < 100001: # ๋ฒ์ ์ค์ ์ํ๋ฉด ๋ฐ๋ก ์๊น
if dist[nxt] == -1: # ๋ฐฉ๋ฌธํ์ง ์์ ๋
ธ๋
# ์์๋
ธ๋๋ก๋ถํฐ ํ์ฌ๋
ธ๋์ ๊ฑฐ๋ฆฌ = ๋ถ๋ชจ๋
ธ๋์ ๊ฑฐ๋ฆฌ + 1
dist[nxt] = dist[x] + 1
# ๊ฒฝ์ฐ์ ์๋ ๋ถ๋ชจ์๊ฒ์ ๊ทธ๋๋ก ๋ฌผ๋ ค๋ฐ์
cnt[nxt] = cnt[x]
# ํ์ ์ถ๊ฐ
deq.append(nxt)
# ๋ฐฉ๋ฌธํ ๋
ธ๋์ด๊ณ , ๊ฐ์ ๋ ๋ฒจ์ ์กด์ฌํ๋ ๋
ธ๋๋ผ๋ฉด
elif dist[nxt] == dist[x] + 1:
# ๋ง์ฐฌ๊ฐ์ง๋ก ๋ถ๋ชจ์ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ํด์ค
cnt[nxt] += cnt[x]
if flag == 1:
print(dist[k])
print(cnt[k])
break
bfs(n)
Python
๋ณต์ฌ
Solution
ํ์ด๋ผ์ดํ
๋ถ๋ถ์ด ํต์ฌ๋ก์ง์ด๋ค.
โข
๋ฐฉ๋ฌธํ ๋
ธ๋์ด์ง๋ง, ๊ฐ์ ๋ ๋ฒจ์ ์กด์ฌํ๋ ๋
ธ๋์ผ ๋ ์นด์ดํ
์ ํด์คฌ์ด์ผ ํ๋๋ฐ ์ด ๋ถ๋ถ ์ฒ๋ฆฌ๊ฐ ์ด๋ ค์ ๋ค.
์์ if ์กฐ๊ฑด๋ฌธ์์ ์ฒซ ๋ฐฉ๋ฌธ๋
ธ๋์ dist[nxt] = dist[x] + 1 ๋ฅผ ๋ฃ์ด์คฌ์ผ๋ฏ๋ก dist[nxt] == dist[x] + 1 ์ด๋ฉด ๊ฐ์ ๋ ๋ฒจ์ ์กด์ฌํ๋ ๊ธฐ๋ฐฉ๋ฌธ ๋
ธ๋์ด๋ค.
โข
cnt[nxt] += cnt[x]
์๊ธฐ ์์ ์ ๋ถ๋ชจ๋
ธ๋์ ๊ฒฝ์ฐ์ ์๋ฅผ ๋์ ์ผ๋ก ๋ํด์ค๋ค. ์ฝ๊ฐ dp ๋ฌธ์ ๋๋๋ ๋๋ค.
Commentary
dist ๋ฆฌ์คํธ์ cnt ๋ฆฌ์คํธ ๋ฅผ ๋ฐ๋ก ๋จ์ง๋ง ๊ทธ๋ฅ ์ด์ฐจ์๋ฐฐ์ด๋ก ์ ์ธํด์ dist[n][0] ๊ฐ n๋ฒ๋
ธ๋์ ๊ฑฐ๋ฆฌ, dist[n][1] ๊ฐ n๋ฒ๋
ธ๋์ ๊ฒฝ์ฐ์ ์(cnt) ๋ก ํ๋ ๋ฐฉ์๋ ์๋ค. ํ์ง๋ง ๊ฐ์ธ์ ์ผ๋ก ์ฝ๋ ๊ฐ๋
์ฑ์ด ์ฉ ์ข์ ๊ฒ ๊ฐ์ง๋ ์์์ dist[] ์ cnt[] ๋ก ๋ถ๋ฆฌํ๋ค.
#2. ํ์์ pop์ ํ ๋ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ
Idea
์ผ๋ฐ์ ์ธ bfs ๋ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ๋ฅผ ๋ง์ง๋ง ๋ถ๋ถ์์ ํ์ ์ถ๊ฐ(append)ํ ๋ ํด์ค๋ค. ๊ทธ๋์ ๋ค์ ๋
ธ๋๋ค์ ์ธ์ ๋
ธ๋(์์๋
ธ๋)์์ ๋ฑ์ฅํ๋๋ผ๋ ๋ฐฉ๋ฌธํ ๋
ธ๋๋ก ์ฒ๋ฆฌ๋๊ธฐ ๋๋ฌธ์ ํ์ ์ถ๊ฐ๊ฐ ์ ๋๋ค.
ํ์ง๋ง ๋ฐฉ๋ฌธ์ฒ๋ฆฌ๋ฅผ ํ์์ pop์ ํ ๋ ํด์ฃผ๋ฉด, ํ์ฌ ๋ ๋ฒจ์์ ์ฒ์ ๋ฑ์ฅํ ์์๋
ธ๋๋ค์ด ์ฆ์ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ๊ฐ ์๋๊ธฐ ๋๋ฌธ์ ์ค๋ณตํด์ ํ์ ๋ด๊ธธ ์ ์๋ค
์์ ๋ ๋ฒจ์์ ๋ฐฉ๋ฌธํ ๋
ธ๋๋ค์ ๊ฑธ๋ฌ์ง๊ฒ ๋๊ณ , ํ์ฌ ๋ ๋ฒจ์์ ์ฒ์์ผ๋ก ๋ฑ์ฅํ ์ค๋ณต ๋
ธ๋๊ฐ ํ์ ์ค๋ณตํด์ ๋ด๊ธฐ๊ฒ ๋๋ ๋ก์ง์ด๋ค.
์ฆ, ๋ฐฉ๋ฌธ์ฒ๋ฆฌ๋ฅผ ์ผ๋ฐ์ ์ธ bfs๋ณด๋ค ํ ํ
ํฌ(ํ ๋ ๋ฒจ) ๋๋ฆฌ๊ฒ ํ๋ ๋ฐฉ์์ด๋ค.
ย Code
import sys
from collections import deque
read = sys.stdin.readline
n, k = map(int, read().split())
visited = [0] * 100001
def bfs(v):
deq = deque([(v, 0)]) # (node๋ฒํธ, ๋ฃจํธ๋
ธ๋๋ถํฐ์ ๊ฑฐ๋ฆฌ)
cnt = 0
flag = 0
while deq:
for _ in range(len(deq)): # ๋ ๋ฒจ ๋จ์ ์คํ์ ์ํ for๋ฌธ
x, dist = deq.popleft()
visited[x] = 1 # ์ฌ๊ธฐ์ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ๋ฅผ ํจ! ์ ์์ ์ธ bfs ๋ณด๋ค ๋ฆ๊ฒ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ๋ฅผ ํจ.
if x == k: # ์ํ๋ ๋
ธ๋๋ฅผ ๋ฐ๊ฒฌํ์ง๋ง ์ด๋ฒ ๋ ๋ฒจ ๋๊น์ง ๋์์ผํ๋ฏ๋ก ๋ฐ๋ก ๋๋ด์ง๋ ์๋๋ค.
flag = 1 # ์ด๋ฒ ๋ ๋ฒจ ๋๋๊ณ ํ์ถํ๊ธฐ ์ํด์
cnt += 1 # ๊ฐ์ ์ฆ๊ฐ
for nxt in (x - 1, x + 1, x * 2):
if 0 <= nxt < 100001: # ๋ฒ์ ์ค์ ์ํ๋ฉด ๋ฐ๋ก ์๊น
if visited[nxt] == 0: # ๋ฐฉ๋ฌธํ์ง ์์ ๋
ธ๋์ด๋ฉด
deq.append((nxt, dist + 1)) # ๊ฑฐ๋ฆฌ์ฆ๊ฐ์์ผ์ ํ์ ์ถ๊ฐ
# ํ์ถ
if flag == 1:
print(dist)
print(cnt)
break
bfs(n)
Python
๋ณต์ฌ
Solution
visited ๋ฅผ ํ ๋ฐ์ ๋๋ฆฌ๊ฒ ํ๋ฏ๋ก, ํด๋น ๋ ๋ฒจ์์ ์ฒ์ ๋ฐฉ๋ฌธํ ๋
ธ๋๊ฐ ์ฌ๋ฑ์ฅํ๋ฉด ๊ทธ ๋
ธ๋๋ ํ์ ๋ด๊ธฐ๊ฒ ๋๋ค.
ํ์ ๋ด์ ๋ (node๋ฒํธ, ๊ฑฐ๋ฆฌ) ํํ์ ๋ด์์, ๊ฑฐ๋ฆฌ๊ณ์ฐ์ ํธํ๊ฒ ํ๋ค.
Commentary
์์ด๋์ด๊ฐ ๋งค์ฐ ์ข๋ค.
ํ์ง๋ง, ํ์ฌ ๋ ๋ฒจ์์ ์ด๋ฏธ ๋ฐฉ๋ฌธํ ๋
ธ๋๋ค์ ํ์ ์ค๋ณต์ผ๋ก append ํ๊ณ , ๊ทธ ๋
ธ๋์ ๋ํด์ ๋ ์ธ์ ๋
ธ๋๋ฅผ ํ์ํ๊ธฐ ๋๋ฌธ์ 1๋ฒ ํ์ด๋ณด๋ค ์๊ฐ์๋ชจ๊ฐ ์ข ์๋ค.