songining

์ตœ์†Œ ์ŠคํŒจ๋‹ ํŠธ๋ฆฌ๋ž€ ์ŠคํŒจ๋‹ ํŠธ๋ฆฌ์ค‘ ๋ชจ๋“  ๊ฐ€์ค‘์น˜์˜ ํ•ฉ์ด ์ตœ์†Œ์ธ ํŠธ๋ฆฌ์ด๋‹ค. (ํ”„๋ฆผ, ํฌ๋ฃจ์Šค์นผ) 

 

1. ํฌ๋ฃจ์Šค์นผ ์•Œ๊ณ ๋ฆฌ์ฆ˜ 

- ๊ฐ€์ค‘์น˜๊ฐ€ ์ตœ์†Œ์ธ ๊ฐ„์„ ์„ ํ•˜๋‚˜์”ฉ ์„ ํƒํ•ด ๋‚˜๊ฐ€๋Š” ๊ฐ„์„  ๊ธฐ๋ฐ˜ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด๋‹ค.  ์‚ฌ์ดํด์ด ๋ฐœ์ƒํ•˜๋Š” ๊ฒฝ์šฐ์— ๋Œ€ํ•ด์„œ๋Š” ์˜ˆ์™ธ ์ฒ˜๋ฆฌ๊ฐ€ ํ•„์š”ํ•˜๋‹ค. 

def find_parent(a): # ๋ถ€๋ชจ์ฐพ๊ธฐ
    if parent[a] == a:
        return a
    else:
        parent[a] = find_parent(parent[a])
        return parent[a]


def merge(a, b):
    x = find_parent(a)
    y = find_parent(b)
    if x != y:
        parent[x] = y
        return True
    return False


v, e = map(int, input().split())
parent = defaultdict(int)
for i in range(1, v + 1):
    parent[i] = i

graph = []
for _ in range(e):
    graph.append(list(map(int, input().split())))
graph.sort(key=lambda x: x[2])
total = 0
for u, v, w in graph:
    if merge(u, v):
        total += w
print(total)

2. ํ”„๋ฆผ ์•Œ๊ณ ๋ฆฌ์ฆ˜ 

-์ •์ ์„ ํ•˜๋‚˜ ์„ ํƒํ•œ ํ›„, ์ •์ ์— ์—ฐ๊ฒฐ๋œ ๊ฐ„์„ ์ค‘ ๊ฐ€์žฅ ๊ฐ€์ค‘์น ๊ฐ€ ์ž‘์€ ๊ฐ„์„ ์„ ์„ ํƒํ•ด์„œ ์—ฐ๊ฒฐํ•ด ๋‚˜๊ฐ€๋Š” ์ •์  ๊ธฐ๋ฐ˜ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด๋‹ค. 

 ์ •์ ์„ ํ•˜๋‚˜์”ฉ ์„ ํƒํ•ด๋‚˜๊ฐ€๊ธฐ ๋•Œ๋ฌธ์— ์‚ฌ์ดํด์€ ์ž๋™์œผ๋กœ ๊ณ ๋ ค๊ฐ€ ๋œ๋‹ค. (visit) 

def prim(tree,start):
    queue = []
    visit = defaultdict(lambda : False)
    heapq.heappush(queue,(0,start)) # ๋น„์šฉ, ๋…ธ๋“œ 
    sum = 0 

    while queue:
        weight, node = heapq.heappop(queue)
        if visit[node]: #ํ์— ๊ฐ™์€ ๋…ธ๋“œ๊ฐ€ ์—ฌ๋Ÿฌ๋ฒˆ ๋“ค์–ด๊ฐ€์žˆ์„ ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ ํ•œ๋ฒˆ ๋” ์ฒดํฌ ํ•„์ˆ˜
            continue
        else :
            visit[node] = True
            sum += weight
        
        for nextV in tree[node]: # ๋‹ค์Œ๋…ธ๋“œ, ๋น„์šฉ 
            if not visit[nextV[0]]:
                heapq.heappush(queue,(nextV[1],nextV[0]))
    return sum 

 

3. ๋‹ค์ต์ŠคํŠธ๋ผ ์•Œ๊ณ ๋ฆฌ์ฆ˜ (์ตœ๋‹จ ๊ฒฝ๋กœ ์•Œ๊ณ ๋ฆฌ์ฆ˜)

-ํ•˜๋‚˜์˜ ์ •์ ์—์„œ ๋‹ค๋ฅธ ๋ชจ๋“  ์ •์ ์œผ๋กœ ๊ฐ€๋Š” ์ตœ๋‹จ ๊ฒฝ๋กœ๋ฅผ ์•Œ๋ ค์ฃผ๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด๋‹ค. 

def dijkstra(edges,K):
    queue = []
    distance = defaultdict(lambda :INF)
    found = defaultdict(lambda : False)
    heapq.heappush(queue,(0,K))
    distance[K]= 0

    while queue:
        v = heapq.heappop(queue)
        found[v[1]] = True
        for nextV in edges[v[1]]:
            node = nextV[0]
            cost = nextV[1]
            if distance[v[1]]+cost < distance[node] and not found[node]:
                distance[node]= distance[v[1]] + cost
                heapq.heappush(queue,(distance[node],node))
    return distance

ํ”„๋ฆผ๊ณผ ๋‹ค์ต์ŠคํŠธ๋ผ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ด ์ฒ˜์Œ์—” ํ—ท๊ฐˆ๋ ธ์—ˆ๋Š”๋ฐ ๊ฐ€์žฅ ํฐ ์ฐจ์ด๋ผ๊ณ  ํ•˜๋ฉด ๋‹ค์ต์ŠคํŠธ๋ผ๋Š” ๋ชจ๋“  ์ •์ ๊ณผ ์ •์ ์ด ์ตœ์†Œ ๊ฐ€์ค‘์น˜๋กœ ์—ฐ๊ฒฐ์ด ๋˜์–ด์žˆ์ง€๋งŒ ํ”„๋ฆผ์€ ์•„๋‹ ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์ด๋‹ค. ๋˜ํ•œ ํ”„๋ฆผ์€ ๋ฌด๋ฐฉํ–ฅ ๊ทธ๋ž˜ํ”„์—์„œ๋งŒ ์‚ฌ์šฉ์ด ๊ฐ€๋Šฅํ•˜๋‹ค. ๋‹ค์ต์ŠคํŠธ๋ผ๋Š” ๋ชจ๋“  ์ •์ ์„ ํƒ์ƒ‰ํ•  ํ•„์š”๊ฐ€ ์—†๋‹ค.