[ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค] ๊ฐ€์žฅ ๋จผ ๋…ธ๋“œ / ํŒŒ์ด์ฌ
Problem Solving ๐Ÿ”ฅ/ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค

[ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค] ๊ฐ€์žฅ ๋จผ ๋…ธ๋“œ / ํŒŒ์ด์ฌ

๋ฌธ์ œ ์„ค๋ช…

๊ฐ€์žฅ ๋จผ ๋…ธ๋“œ

n๊ฐœ์˜ ๋…ธ๋“œ๊ฐ€ ์žˆ๋Š” ๊ทธ๋ž˜ํ”„๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ฐ ๋…ธ๋“œ๋Š” 1๋ถ€ํ„ฐ n๊นŒ์ง€ ๋ฒˆํ˜ธ๊ฐ€ ์ ํ˜€์žˆ์Šต๋‹ˆ๋‹ค. 1๋ฒˆ ๋…ธ๋“œ์—์„œ ๊ฐ€์žฅ ๋ฉ€๋ฆฌ ๋–จ์–ด์ง„ ๋…ธ๋“œ์˜ ๊ฐฏ์ˆ˜๋ฅผ ๊ตฌํ•˜๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ๊ฐ€์žฅ ๋ฉ€๋ฆฌ ๋–จ์–ด์ง„ ๋…ธ๋“œ๋ž€ ์ตœ๋‹จ๊ฒฝ๋กœ๋กœ ์ด๋™ํ–ˆ์„ ๋•Œ ๊ฐ„์„ ์˜ ๊ฐœ์ˆ˜๊ฐ€ ๊ฐ€์žฅ ๋งŽ์€ ๋…ธ๋“œ๋“ค์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

๋…ธ๋“œ์˜ ๊ฐœ์ˆ˜ n, ๊ฐ„์„ ์— ๋Œ€ํ•œ ์ •๋ณด๊ฐ€ ๋‹ด๊ธด 2์ฐจ์› ๋ฐฐ์—ด vertex๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, 1๋ฒˆ ๋…ธ๋“œ๋กœ๋ถ€ํ„ฐ ๊ฐ€์žฅ ๋ฉ€๋ฆฌ ๋–จ์–ด์ง„ ๋…ธ๋“œ๊ฐ€ ๋ช‡ ๊ฐœ์ธ์ง€๋ฅผ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์ž‘์„ฑํ•ด์ฃผ์„ธ์š”.

์ œํ•œ์‚ฌํ•ญ

  • ๋…ธ๋“œ์˜ ๊ฐœ์ˆ˜ n์€ 2 ์ด์ƒ 20,000 ์ดํ•˜์ž…๋‹ˆ๋‹ค.
  • ๊ฐ„์„ ์€ ์–‘๋ฐฉํ–ฅ์ด๋ฉฐ ์ด 1๊ฐœ ์ด์ƒ 50,000๊ฐœ ์ดํ•˜์˜ ๊ฐ„์„ ์ด ์žˆ์Šต๋‹ˆ๋‹ค.
  • vertex ๋ฐฐ์—ด ๊ฐ ํ–‰ [a, b]๋Š” a๋ฒˆ ๋…ธ๋“œ์™€ b๋ฒˆ ๋…ธ๋“œ ์‚ฌ์ด์— ๊ฐ„์„ ์ด ์žˆ๋‹ค๋Š” ์˜๋ฏธ์ž…๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ

nvertexreturn

6[[3, 6], [4, 3], [3, 2], [1, 3], [1, 2], [2, 4], [5, 2]]3

์ž…์ถœ๋ ฅ ์˜ˆ ์„ค๋ช…

์˜ˆ์ œ์˜ ๊ทธ๋ž˜ํ”„๋ฅผ ํ‘œํ˜„ํ•˜๋ฉด ์•„๋ž˜ ๊ทธ๋ฆผ๊ณผ ๊ฐ™๊ณ , 1๋ฒˆ ๋…ธ๋“œ์—์„œ ๊ฐ€์žฅ ๋ฉ€๋ฆฌ ๋–จ์–ด์ง„ ๋…ธ๋“œ๋Š” 4,5,6๋ฒˆ ๋…ธ๋“œ์ž…๋‹ˆ๋‹ค.

ํ’€์ด

Weight๊ฐ€ ์žˆ์—ˆ๋‹ค๋ฉด ๋‹ค์ต์ŠคํŠธ๋ผ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ์ด์ง€๋งŒ, ์—†์œผ๋ฏ€๋กœ bfs ๋ฌธ์ œ์ด๋‹ค.
1์—์„œ ๋ถ€ํ„ฐ, ๊ฐ€์žฅ ๊ฐ€๊นŒ์šด ๋…ธ๋“œ์˜ ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ„์‚ฐํ•ด์ฃผ๊ณ ,
ํ•ด๋‹น ๋…ธ๋“œ์™€ ์—ฐ๊ฒฐ๋˜์–ด์žˆ๋Š” edge์„ ์ถ”๊ฐ€ํ•ด์ค€๋‹ค.
์ด๋ฅผ ๋ฐ˜๋ณตํ•˜๋ฉฐ ๋ชจ๋“  ์„ ๋ถ„์„ ๋‹ค ์ ๊ฒ€ํ• ๋•Œ๊นŒ์ง€ ๊ณ„์†ํ•ด์„œ ๊ฑฐ๋ฆฌ๋ฅผ ์—…๋ฐ์ดํŠธ ํ•ด์ฃผ๋ฉด ๋œ๋‹ค.

from collections import deque

def solution(n, edge):
    answer = 0

    dist = [ -1 for _ in range(n + 1)]
    dist[1] = 0

    adj = [ [] for _ in range(n + 1)]
    for [f, to] in edge:
        adj[f].append(to)
        adj[to].append(f)

    edges = deque([])
    for v in adj[1]:
        edges.append((1, v))

    while edges:
        top = edges.popleft()
        f, to = top[0], top[1]
        if dist[to] == -1:
            dist[to] = dist[f] + 1
            for v in adj[to]:
                edges.append((to, v))

    return dist.count(max(dist))