ํ๋ก๊ทธ๋๋จธ์ค - ๊ฐ์ฅ ๋จผ ๋ ธ๋
DFS๋ก ํ๋ค๊ฐ ํ์ฐธ ํด๋งธ์ต๋๋ค... ์ฌ์ง์ด ์์ ์ ์ ์ฌ๋ฌธ์ ํ๋ฒ ํ์ด๋ดค๋ ๊ฒ ๊ฐ์๋ฐ...
์ด์จ๋ ์ด ๋ฌธ์ ์ ์์ ์ BFS๋ก level(depth)๋ฅผ ๊ตฌํ ์ ์๋๊ฐ ์๋๊ฐ ์
๋๋ค.
๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ๋ ธ๋์ ๊ฐ์ ์ด 2๊ฐ ์ด์์ธ ๊ฒฝ์ฐ์๋ DFS๋ก ๋ ธ๋์ level์ ๊ตฌํ๊ธฐ ๋งค์ฐ๋งค์ฐ๋งค์ฐ ์ด๋ ต๊ธฐ๋๋ฌธ์ BFS๋ก ๋ ๋ฒจ์ ๊ตฌํ๋ ํ์์ผ๋ก ์ ๊ทผํด์ผ ํฉ๋๋ค.
from collections import deque
import sys
์๊ฐ์ด๊ณผ ๋ฐฉ์ง์ฉ์ผ๋ก sysinput ๋ฐ์์
def solution(n, edge):
input = sys.stdin.readline
solution ํจ์ ๋ด์ ๋ฃ์ด์ค์๋ค.
def bfs(n):
level = 1
que.append(n)
visited[n] = 1
๋จผ์ BFS ํจ์๋ฅผ ์์ฑํ ๊ป๋๋ค. ์ด๊ธฐ ๋ ๋ฒจ 0์ ๋ฐ๋ก ์ง์ ํด์ค๊บผ๊ณ ๋ ๋ฒจ 1๋ถํฐ ์์ํฉ์๋ค.
์ง๊ธ ๋ง ๋ค์ด์จ ๋
ธ๋ 1์ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ ํด์ฃผ๊ณ que์ ๋ฃ์ด์ค์๋ค.
while que:
for i in range(len(que)):
a = que.popleft()
BFS level์ฒ๋ฆฌ์ ํต์ฌ์
๋๋ค. BFS๋ฅผ ๋ฑ que๊ฐ๋งํผ๋ง ๋๋ฆฌ๋ฉด ํด๋น level๊ฐ๋งํผ๋ง ๋
ธ๋๋ฅผ ํ์ํ ์์ด ๋๊ธฐ ๋๋ฌธ์ BFS์์ level์ ๊ตฌํ ์ ์์ต๋๋ค. ์์ธํ ๊ฑด ์ ์์ ํฌ์คํ
์ฒจ๋ถํ๊ฒ ์ต๋๋ค.
https://velog.io/@ghost_dog/%EA%B3%B5%EB%B6%80-2024.01.19-%EC%98%A4%EB%8A%98%EC%9D%98-%EB%B0%B1%EC%A4%80-%EB%AC%B8%EC%A0%9C%ED%92%80%EC%9D%B4
for i in range(len(graph[a])):
if not visited[graph[a][i]]:
visited[graph[a][i]] = 1
que.append(graph[a][i])
ํ์ฌ ํ์์ค์ธ ๋
ธ๋๋ฅผ ์ธ๋ฑ์ค ์ฐจ์์ผ๋ก ์ ๊ทผํ์ฌ graph[๋
ธ๋] = ์ฐ๊ฒฐ๋๋
ธ๋ ํ์์ผ๋ก ์งค๊ป๋๋ค.
๋ง์ฝ ํ์์ค์ธ ๋
ธ๋์ ์ฐ๊ฒฐ๋ ๋
ธ๋ ์ค ์์ง ํ์์ ์ํ ๋
ธ๋๊ฐ ์๋ค๋ฉด ๋ฐฉ๋ฌธ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ๊ณ que์ ์ถ๊ฐํ์ฌ ํ์ ์๋นํ๋ณด๋ก ์ง์ ํฉ์๋ค.
ans[graph[a][i]] = level
print(graph[a][i],level)
level += 1
ans๋ผ๋ ๋ฆฌ์คํธ์ ํด๋น ๋
ธ๋์ ์ ๊ทผํ๋ฉด level์ ํ์ํ๋๋ก ์ฝ๋ฉํด์ค์๋ค.
๊ทธ๋ฆฌ๊ณ que์ ํด๋นํ๋ ๊ฑธ ๋ค ๋์์ผ๋ฉด (ํ์ฌ level์ด ๋๋ฌ์ผ๋ฉด) level์ 1 ์ฌ๋ ค์ฃผ๋๋ก ํฉ์๋ค.
graph = [[] for _ in range(n+1)]
while edge:
[x,y] = edge.pop()
graph[x].append(y)
graph[y].append(x)
์๊ฐ์ด๊ณผ๋ฅผ ํผํ๋ ๋ถ๋ถ์
๋๋ค.
์๋ ์ ๋ ๊ทธ๋ํ๋ฅผ ์งค ๋ ์ต๊ด์ ์ผ๋ก
graph = [[0]*(n+1) for _ in range(n+1)] while edge: [x,y] = edge.pop() graph[x][y] = graph[y][x] = 1
๋ก ์์ฑํ์๋๋ฐ ์ด๋ฌ๋ฉด ์ ์์ ์ผ๋ก ์๋์ ํ๋ DFS๋ ๋ฌผ๋ก ์ด๊ณ BFS์์๊น์ง๋ [0]์ด ์ธ๋ฐ์๋ ๊ณต๊ฐ์ ์ก์๋จน์ด ์๊ฐ์ด๊ณผ๊ฐ ๋จ๊ณค ํ์ต๋๋ค. ๋ฐ๋ผ์ [0]์ผ๋ก ์ ์ธํ๊ธฐ๋ณด๋จ ์์ ๋น ๋ฆฌ์คํธ์ ์ธ๋ฑ์ค๋ง ์ง์ด๋ฃ์ ์ ์๋๋ก ๋ง๋ค์ด์ฃผ๊ณ ํด๋น ์ธ๋ฑ์ค์ ์ ๊ทผํ๋ฉด value ๊ฐ์ผ๋ก ๊ทธ์ ์ฐ๊ฒฐ๋ ๋ ธ๋๋ง ํ์ํ๊ฒ๋ ์ฝ๋ฉํ์๋๋ค.
visited = [0]*(n+1)
que = deque([])
ans = [0]*(n+1)
ans[1] = 0
bfs(1)
๋ฐฉ๋ฌธ๋ฐฐ์ด ์ด๊ธฐํ, que์ ์ธ, ans ์ ์ธ ๋ฑ์ ํด์ฃผ๊ณ ๋งจ ์ฒซ ๋ ธ๋์ธ 1์ level 0์ผ๋ก ์ค์ ํด์ค์๋ค. ๊ทธ๋ฆฌ๊ณ 1์ ์์์ผ๋ก bfs๋ฅผ ๋๋ฆฌ๋ฉด ๋ฉ๋๋ค.
return ans.count(max(ans))
๋ง์ง๋ง์ผ๋ก level์ด ๊ฐ์ฅ ํฐ ๋ ธ๋์ ๊ฐฏ์๋ฅผ ๊ตฌํ๋ผ ํ์ผ๋ฏ๋ก max(ans)๋ก ๊ฐ์ฅ ํฐ ๋ ๋ฒจ์ ๊ตฌํด ans์ ์ผ๋งํผ ์๋์ง countํด์ค์๋ค.
ํ๋ก๊ทธ๋๋จธ์ค - ์คํฌํธ๋ฆฌ
์๋ง 1,2๋ฒ์ ๊ตฌํ ๋ฌธ์ ๊ฐ ๋์จ๋ค๊ธธ๋ ๊ตฌํ ๋ฌธ์ ์ฐ์ต๊ฒธ ํ์ด๋ดค์ต๋๋ค.
์คํฌ๊ณผ ์คํฌํธ๋ฆฌ๋ผ๋ ๋ณ์๊ฐ ์ฃผ์ด์ง๋๋ค. ์ด ์คํฌ์ด๋ผ๋ ๋ฆฌ์คํธ์ A,B,C๊ฐ ์์ผ๋ฉด ์คํฌํธ๋ฆฌ๋ผ๋ ์์๊ฐ ์์๋ ๋ฌด์กฐ๊ฑด A๊ฐ ๋จผ์ , ๊ทธ๋ค์ B, ๊ทธ๋ค์ C๊ฐ ์์ผํฉ๋๋ค. ๋ญ๊ฐ ์ค๊ฐ์ ๊ปด์์ด๋ ํฌ๊ฒ ์๊ด์์ต๋๋ค.
์ด ๋ฌธ์ ์ ํต์ฌ์ ์คํฌ ๋ฆฌ์คํธ์ ๋น ์ง ์์๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ์ ๋๋ค. ์๋ฅผ ๋ค์ด A->K(์๋ฌด๊ฑฐ๋)->C๋ผ๋ฉด A๋ค์์ ์์ผ ํ B๊ฐ ๋น ์ ธ์์ผ๋ฏ๋ก ์คํฌํธ๋ฆฌ๊ฐ ๋ ์ ์์ต๋๋ค.
ans = 0
skill = list(skill)
์ผ๋จ ans๋ฅผ 0์ผ๋ก ์ ์ธํ๊ณ skill์ list๋ก์จ ํ์ฉํ๊ธฐ ์ฝ๊ฒ ๋ถ๋ฆฌํด์ฃผ๊ฒ ์ต๋๋ค.
for i in range(len(skill_trees)):
tmp = -1
boolean = False
์ด์ ์คํฌ ํธ๋ฆฌ๋ฅผ ํ์ํ์ฌ ์คํฌ ๋ฆฌ์คํธ์ ๋์กฐํด์ค ๊ฒ๋๋ค. tmp๊ฐ์ ๊ธฐ์ฌํ๊ฒ ์ง๋ง ํด๋น ์คํฌ ํธ๋ฆฌ ์ด๋ ์ธ๋ฑ์ค์ ์คํฌ์ด ์์นํ๋๊ฐ๋ฅผ ๊ธฐ์ฌํด์ค ๊ฒ๋๋ค. ๊ฐ์ ์์ผ๋ฉด~ ์ด๋ผ๋ ์กฐ๊ฑด์ผ๋ก ๋์กฐํ ๊ฑฐ๋ผ -1๋ก ์ด๊ธฐํํ์์ต๋๋ค.
for k in range(len(skill)):
if boolean == True:
break
์คํฌ ๋ฆฌ์คํธ์ ๋์กฐ๋ฅผ ์์ํ๊ฒ ์ต๋๋ค. boolean๊ฐ์ด true๋ฉด ์คํฌ ๋ฆฌ์คํธ ์์์ ๋ง์ง ์๋ค๊ณ ๊ฐ์ ํ์ฌ ๋ฃจํ๋ฅผ ๊นจ๊ฒ ์ต๋๋ค.
elif skill[k] not in skill_trees[i]:
tmp = 100
continue
์คํฌ ๋ฆฌ์คํธ๊ฐ A->B->C ๋ผ๊ณ ๊ฐ์ ํ๊ณ ์คํฌํธ๋ฆฌ๊ฐ A->K->C๋ผ๊ณ ๊ฐ์ ํด๋ด ์๋ค. A์กฐ์ฌ๋ ๋ฌด๋ํ ๋์ด๊ฐ๋๋ฐ ์คํฌํธ๋ฆฌ์ B๋ผ๋ ์คํฌ ๋ฆฌ์คํธ๊ฐ ์๋ ๊ฑธ ํ์ธํ ์ ์์ต๋๋ค. ์ด๋ ๊ฒ ๋๋ฒ๋ฆฌ๋ฉด B์ดํ์ ์ด๋ค ์คํฌ ๋ฆฌ์คํธ๋ ์คํฌํธ๋ฆฌ์ ์กด์ฌํด์๋ ์๋๋ฏ๋ก tmp์ 100์ด๋ผ๋ ๊ณ ๊ฐ์ ๋์ ํด ๋ฌด์จ ๊ฐ์ด๋ ํ๊ฒจ๋ฒ๋ฆฌ๋๋ก ํฉ์๋ค.
elif skill_trees[i].index(skill[k]) < tmp:
boolean = True
continue
๋ง์ฝ ํ์ฌ ์กฐ์ฌ์ค์ธ ์คํฌ ํธ๋ฆฌ ๋ด๋ถ์ ์คํฌ ๋ฆฌ์คํธ ์์น๊ฐ ์ด์ ์ ์กฐ์ฌํ ์คํฌ ํธ๋ฆฌ ๋ด๋ถ์ ์คํฌ ๋ฆฌ์คํธ ์์น๋ณด๋ค ์๋ค๋ฉด ์คํฌ ๋ฆฌ์คํธ ์์์ ๋ง์ง ์์ผ๋ฏ๋ก boolean = True๋ฅผ ์ ๋ํด์ ์ต์ข ๋ต์ ์ฌ๋ฆฌ์ง ๋ชปํ๋๋ก ํฉ์๋ค.
tmp = skill_trees[i].index(skill[k])
๋ค์ ์คํฌ ๋ฆฌ์คํธ์ ๋น๊ตํ๊ธฐ ์ํด์ tmp๋ฅผ ์ ์ฅํด์ค์๋ค.
if boolean == False:
ans += 1
return (ans)
์ ๊ณผ์ ์ ๊ฑธ์ณค์์๋ ๋ถ๊ตฌํ๊ณ boolean๊ฐ์ด False๊ฐ ๋์๋ค๋ฉด ์ต์ข ๋ต + 1์ ํด์ฃผ๊ณ return ํด์ค์๋ค.