๐ก ์กฐ๊ฑด ๋ฐ ํ์ด
- ๋
ธ๋์ ๊ฐ์
(1 โค n โค 10,000)
- ์ฒซ ๋ฒ์งธ ์ ์๋ ๊ฐ์ ์ด ์ฐ๊ฒฐํ๋ ๋ ๋
ธ๋ ์ค ๋ถ๋ชจ ๋
ธ๋์ ๋ฒํธ
๋ ๋ฒ์งธ ์ ์๋ ์์ ๋
ธ๋
์ธ ๋ฒ์งธ ์ ์๋ ๊ฐ์ ์ ๊ฐ์ค์น
- ๋ถ๋ชจ ๋
ธ๋์ ๋ฒํธ๊ฐ ์์ ๊ฒ์ด ๋จผ์ ์
๋ ฅ๋๊ณ ,
๋ถ๋ชจ ๋
ธ๋์ ๋ฒํธ๊ฐ ๊ฐ์ผ๋ฉด ์์ ๋
ธ๋์ ๋ฒํธ๊ฐ ์์ ๊ฒ์ด ๋จผ์ ์
๋ ฅ๋๋ค.
- BFS ์ ํ์ ๋ฌธ์
- ๋ฃจํธ ๋
ธ๋์ ๋ฒํธ๋ ํญ์
1
๊ฐ์ ์ ๊ฐ์ค์น๋ 100
๋ณด๋ค ํฌ์ง ์์ ์์ ์ ์
- ํธ๋ฆฌ์ ์กด์ฌํ๋ ๋ชจ๋ ๊ฒฝ๋ก๋ค ์ค, ๊ฐ์ฅ ๊ธด ๊ฒฝ๋ก๋ฅผ ์ถ๋ ฅํ๋ ๋ฌธ์ ์ด๋ค.
๐ฅ ์์ค ์ฝ๋
from sys import stdin
from collections import deque
n = int(stdin.readline())
tree = [[] for _ in range(n + 1)]
for _ in range(n - 1):
a, b, c = map(int, stdin.readline().split())
tree[a].append((b, c))
tree[b].append((a, c))
def bfs(i):
visited = set()
q = deque()
q.append((i, 0))
visited.add(i)
res = (0, 0)
while q:
now, cost = q.popleft()
for n, c in tree[now]:
if n not in visited:
visited.add(n)
t = c + cost
q.append((n, t))
if res[1] < t:
res = (n, t)
return res
a = bfs(1)
b = bfs(a[0])
print(b[1])
๐ ์์ ๋ฐ ์คํ๊ฒฐ๊ณผ
์์
12
1 2 3
1 3 2
2 4 5
3 5 11
3 6 9
4 7 1
4 8 7
5 9 15
5 10 4
6 11 6
6 12 10
์คํ๊ฒฐ๊ณผ
45
โจ๏ธ ๋ฌธ์ ํ์ด
BFS
๋ฌธ์ ์์ง๋ง, ํธ๋ฆฌ์ ๊ธธ์ด๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ๋ผ๊ณ ํ๊ธฐ์ ๋นํฉ์ ํ๋ค.
BFS
๋ฅผ ํตํด ๋ฃจํธ ๋
ธ๋์ธ 1 ๋ถํฐ ํ์์ ์์ํด์ ๊ฐ์ค์น๊ฐ ๊ฐ์ฅ ๋์ ๊ฒ์
๋ฐํ๋ฐ์ ๋ณ์์ ๋ด๋๋ค.
- ๋ณ์์๋
(node, cost)
ํ์์ผ๋ก ์๋๋ฐ, ์ด node ๋ฒํธ๋ฅผ ๋ค์ BFS์ ๋ฃ์ด ์ฒ๋ฆฌํ๋ค.
3๋ฒ
์ ํตํด์ ๋ฐํ ๋ (node, cost)
์์ cost๊ฐ ๋ต์ด ๋๋ค.
- ๋ค์ ์ค๋ช
ํ์๋ฉด,
2๋ฒ
์์ BFS ๋ก ๊ฐ์ฅ ๊ฐ์ค์น๊ฐ ๋ง์ด ์์ด๋ ๋
ธ๋๋ฅผ ํ์ํ๋ค. ์ด๋ฅผ A-node
๋ผ๊ณ ํ๊ณ ,
3๋ฒ
์์ A-node
์์๋ถํฐ ๊ฐ์ฅ ๊ฐ์ค์น๊ฐ ๋ง์ด ์์ด๋ ๊ณณ์ผ๋ก ์ํ๋ฅผ ํ์ฌ B-node
๋ผ๊ณ ํ๋ค.
๋ฌธ์ ์์ ์ค๋ช
ํ๋ฏ, ์ด ๋ ๋
ธ๋๊ฐ ๊ฐ์ฅ ๋์ ๊ฐ์ค์น๋ฅผ ๊ฐ์ง๊ณ ์๋ ๊ฒฝ๋ก ์ฆ, ์ง๋ฆ์ด ๋๋ค.
๐พ ๋๋์
- BFS๋ฅผ ์์ฉํ์ฌ ํธ๋ ๋ฌธ์ ์๋ค. ๋๋ฒ์ด๋ ๋๋ฆด ์๊ฐ์ ๋ชปํด์ ํค๋งธ๋ค.
- ๋ฌธ์ ๋ฅผ ํด์ํ๊ณ ์์ถํ๋ ๋ฅ๋ ฅ์ ๋ ํค์ฐ๊ณ , ์๊ฐ์ ์ ํ์ ํ๋ ์ต๊ด์ ๊ธธ๋ฌ์ผ๊ฒ ๋ค.