๐ก ์กฐ๊ฑด
- ํธ๋ฆฌ์์ ๋ฆฌํ ๋
ธ๋๋, ์์์ ๊ฐ์๊ฐ 0์ธ ๋
ธ๋๋ฅผ ๋งํ๋ค.
- ํธ๋ฆฌ๊ฐ ์ฃผ์ด์ก์ ๋, ๋
ธ๋ ํ๋๋ฅผ ์ง์ธ ๊ฒ์ด๋ค. ๊ทธ ๋, ๋จ์ ํธ๋ฆฌ์์ ๋ฆฌํ ๋
ธ๋์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ .
๋
ธ๋๋ฅผ ์ง์ฐ๋ฉด ๊ทธ ๋
ธ๋์ ๋
ธ๋์ ๋ชจ๋ ์์์ด ํธ๋ฆฌ์์ ์ ๊ฑฐ๋๋ค.
- ๋ค์๊ณผ ๊ฐ์ ํธ๋ฆฌ๊ฐ ์๋ค๊ณ ํ์.
- ํ์ฌ ๋ฆฌํ ๋
ธ๋์ ๊ฐ์๋ 3๊ฐ์ด๋ค. (์ด๋ก์ ์์น ๋ ๋
ธ๋) ์ด๋, 1๋ฒ์ ์ง์ฐ๋ฉด, ๋ค์๊ณผ ๊ฐ์ด ๋ณํ๋ค.
๊ฒ์ ์์ผ๋ก ์์น ๋ ๋
ธ๋๊ฐ ํธ๋ฆฌ์์ ์ ๊ฑฐ๋ ๋
ธ๋์ด๋ค.
์ด์ ๋ฆฌํ ๋
ธ๋์ ๊ฐ์๋ 1๊ฐ์ด๋ค.
- ์ฒซ์งธ ์ค์ ํธ๋ฆฌ์ ๋
ธ๋์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. N์ 50๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค.
๋์งธ ์ค์๋ 0๋ฒ ๋
ธ๋๋ถํฐ N-1๋ฒ ๋
ธ๋๊น์ง, ๊ฐ ๋
ธ๋์ ๋ถ๋ชจ๊ฐ ์ฃผ์ด์ง๋ค.
๋ง์ฝ ๋ถ๋ชจ๊ฐ ์๋ค๋ฉด (๋ฃจํธ) -1์ด ์ฃผ์ด์ง๋ค. ์
์งธ ์ค์๋ ์ง์ธ ๋
ธ๋์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค.
- BFS, ๊ทธ๋ํํ์ ์ ํ์ ๋ฌธ์
๐ฅ ์์ค ์ฝ๋
import sys
n = int(sys.stdin.readline())
stack = list(map(int, sys.stdin.readline().split()))
edge = [[-1] for _ in range(n)]
k = int(sys.stdin.readline())
root = []
for i in range(n):
if stack[i] >= 0 and i != k:
edge[stack[i]].append(i)
elif stack[i] == -1 and i != k:
root.append(i)
edge[k] = [-1]
ans = 0
visited = [0]*n
while root:
n = root.pop()
if visited[n] == 0:
visited[n] = 1
if len(edge[n]) == 1:
ans += 1
else:
sub = edge[n]
sub.pop(0)
for i in sub:
root.append(i)
print(ans)
๐ ์์ ๋ฐ ์คํ๊ฒฐ๊ณผ
์์
5
-1 0 0 1 1
2
์คํ๊ฒฐ๊ณผ
2
โจ๏ธ ๋ฌธ์ ํ์ด
- n๊ฐ์ ๋
ธ๋๋ฅผ ๊ฐ์ง edge ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด -1 ๋ก ์ด๊ธฐํํด ๋ถ๋ชจ๋
ธ๋๊ฐ ์๋ ์ํ๋ก ์ด๊ธฐํ ํ๋ค.
- 0๋ถํฐ n๊น์ง ์ํํ๋ฉด์(i), 0๋ฒ ๋
ธ๋๋ถํฐ N-1๋ฒ ๋
ธ๋๊น์ง ๊ฐ ๋
ธ๋์ ๋ถ๋ชจ์ ๊ฐ์ด 0๋ณด๋ค ๊ฐ๊ฑฐ๋ ํฌ๊ณ , ์ญ์ ํ ๋
ธ๋์ ๋ฒํธ์ ๊ฐ์ง ์๋ค๋ฉด
๊ทธ๋ํ์ i๋ฅผ ์ถ๊ฐํ๋ค.
- ๋ง์ฝ (2)๋ฒ ์กฐ๊ฑด์ ํด๋นํ์ง ์๋๋ค๋ฉด root ๋ฆฌ์คํธ์ i๋ฅผ ์ถ๊ฐํ๋ค.
๊ทธ ํ, edge[k]๋ฅผ -1 ๋ก ๋ณ๊ฒฝํด ์ญ์ ์ฒ๋ฆฌ๋ฅผ ํด์ค๋ค.
- root ๋ฆฌ์คํธ๊ฐ ๋น ๋๊น์ง while ๋ฌธ์ ๋ฐ๋ณตํ๋ค.
- root ์์ pop() ํ ๋
ธ๋๋ฒํธ๋ฅผ ๋ฐฉ๋ฌธํ ์ ์ด ์๋ค๋ฉด ๋ฐฉ๋ฌธ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ๊ณ , edge[n]์ ๊ธธ์ด๊ฐ 1์ผ ๊ฒฝ์ฐ ans += 1 ํด์ค๋ค.
- (5)๋ฒ ์กฐ๊ฑด์ ํด๋นํ์ง ์๋๋ค๋ฉด sub = edge[n]์ด๋ฉฐ, sub์ ๊ฐ์ฅ ์ผ์ชฝ์์ ๋ฐ์ดํฐ๋ฅผ pop ํ ๋ค, sub ๋ฅผ ์ํํ๋ฉด์ root์ i ๋ฅผ ์ถ๊ฐํ๋ค.