19-dohyeondol1

[dohyeondol1]

🔗 문제 링크

최소 스패닝 트리

✔️ 소요된 시간

40m

✨ 수도 코드

수도코드

함수 prim(정점 수 V, 인접 리스트 adj):
    visited 배열을 V 크기만큼 false로 초기화
    최소 힙 pq를 선언 (가중치 기준 정렬)

    totalWeight를 0으로 초기화
    pq에 (0, 0) 추가  // 시작 정점은 0번, 가중치 0

    while pq가 비어있지 않으면:
        (weight, u)를 pq에서 꺼냄

        만약 u가 이미 방문된 정점이면:
            계속 진행

        u를 방문 처리
        totalWeight에 weight를 더함

        for adj[u]의 모든 (w, v)에 대해:
            만약 v가 방문되지 않았다면:
                pq에 (w, v)를 추가

    totalWeight 반환


메인 함수:
    입력 최적화를 설정

    정점 수 V, 간선 수 E 입력
    V 크기의 인접 리스트 adj 초기화

    E개의 간선을 입력으로 받음:
        각 간선의 A, B, C를 입력받고
        A와 B를 0부터 시작하도록 조정
        adj[A]에 (C, B) 추가
        adj[B]에 (C, A) 추가  // 무방향 그래프

    prim(V, adj)를 호출하여 MST 가중치를 구함
    결과 출력

이 문제는 문제 이름대로 MST(Minimum Spanning Tree, 최소 스패닝 트리)를 구하는 문제입니다.

최소 스패닝 트리는, 주어진 그래프의 모든 정점들을 연결하는 부분 그래프 중에서 그 가중치의 합이 최소인 트리를 말한다.

MST를 구하는 알고리즘에는 대표적으로 잘 알려진 두가지 방법이 있습니다.

프림 알고리즘

프림 알고리즘은 제가 다익스트라 알고리즘하고 거의 똑같다고 느낀 알고리즘입니다.

기본적으로 다음과 같은 순서를 따릅니다.

1. 임의의 정점을 선택하여 하나의 정점을 갖는 최초의 트리를 구성한다.
2. 트리에 포함된 정점과 트리에 포함되지 않은 정점 간의 간선 중 가장 작은 가중치를 가지는 간선을 선택하여 트리에 추가한다.
3. 모든 정점이 트리에 포함될 때까지 2를 반복한다.

이 알고리즘은 다익스트라와 마찬가지로 우선순위 큐를 사용해서 구현할 수 있습니다.

프림 알고리즘 구현

#include <vector>
#include <queue>
#include <utility>
#include <limits>

using namespace std;

using Graph = vector<vector<pair<int, int>>>; // (neighbor, weight)
using pii = pair<int, int>; // (weight, vertex)

vector<int> prim(const Graph& graph, int start = 0) {
    int n = graph.size();
    vector<bool> visited(n, false);
    vector<int> parent(n, -1); // MST를 구성하는 트리 정보
    vector<int> minWeight(n, numeric_limits<int>::max());

    priority_queue<pii, vector<pii>, greater<>> pq;
    minWeight[start] = 0;
    pq.emplace(0, start);

    while (!pq.empty()) {
        auto [weight, u] = pq.top();
        pq.pop();

        if (visited[u]) continue;
        visited[u] = true;

        for (auto [v, w] : graph[u]) {
            if (!visited[v] && w < minWeight[v]) {
                minWeight[v] = w;
                parent[v] = u;
                pq.emplace(w, v);
            }
        }
    }

    return parent; // MST의 각 노드의 부모를 나타냄
}

크루스칼 알고리즘

어쩌면 프림보다 더 쉬운 알고리즘입니다.

다음과 같은 순서를 따릅니다.

• 그래프의 모든 간선의 집합 E을 만든다.
• E가 비어있지 않을 때까지
  • E의 간선들 중 가중치가 최소인 간선을 지운다.
  • 삭제된 간선이 가리키는 정점 x, y를 연결하여도 사이클이 발생하지 않는다면 연결한다.

이를 서로소 집합, Union Find 로 구현할 수 있습니다.

크루스칼 알고리즘 구현

#include <vector>
#include <tuple>
#include <algorithm>

using namespace std;

using Edge = tuple<int, int, int>; // (weight, u, v)

struct DisjointSet {
    vector<int> parent, rank;

    DisjointSet(int n) : parent(n), rank(n, 1) {
        for (int i = 0; i < n; ++i) parent[i] = i;
    }

    int find(int u) {
        return parent[u] == u ? u : parent[u] = find(parent[u]);
    }

    bool unite(int u, int v) {
        u = find(u);
        v = find(v);
        if (u == v) return false;

        if (rank[u] < rank[v]) swap(u, v);
        parent[v] = u;
        if (rank[u] == rank[v]) rank[u]++;
        return true;
    }
};

vector<Edge> kruskal(int n, vector<Edge>& edges) {
    sort(edges.begin(), edges.end()); // weight 기준 정렬
    DisjointSet ds(n);
    vector<Edge> mst;

    for (const auto& [w, u, v] : edges) {
        if (ds.unite(u, v)) {
            mst.emplace_back(w, u, v);
        }
    }

    return mst; // MST에 포함된 간선 리스트 반환
}

저는 프림 알고리즘을 사용해서 이 문제를 해결하였습니다.
안풀던 그래프 문제를 좀 풀어보려다 보니 MST 문제를 가져오게 되었습니다..

제 코드에서 더 깔끔하게 만들 수 있겠다 싶은 부분이 있다면 마구마구 알려주세용~~ 감사합니다

📚 새롭게 알게된 내용

[froglike6]

최소 스패닝 트리와, 저번에 알게 된 서로소 집합을 알고 있어서 크루스칼 알고리즘을 통해 빠르게 해결해볼 수 있었습니다.
서로소 집합을 알고 있다면 크루스칼이 더 간단하게 구현할 수 있는 방법인 것 같습니다.

import sys
input = sys.stdin.readline

def find(x):
    while parent[x] != x:
        parent[x] = parent[parent[x]]
        x = parent[x]
    return x

def union(a, b):
    ra = find(a)
    rb = find(b)
    if ra != rb:
        parent[rb] = ra

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

edge = []
for _ in range(e):
    a, b, c = map(int, input().split())
    edge.append((c, a, b))
edge.sort()

ans = 0
for w, u, v in edge:
    if find(u) != find(v):
        union(u, v)
        ans += w
print(ans)

[dohyeondol1]

칼리뷰 ㄷㄷ

[Fnhid]

자료구조 시간에 보았던 MST를 여기서 보니 반갑네요.

크루스칼 알고리즘은 간선을 정렬한 다음 최소 비용 간선부터 사이클이 발생하는지 체크하는 로직이기 때문에, 간선을 정렬하는 데 시간을 가장 많이 소모하는 것으로 알고 있습니다. ( $$O(E log E)$$ )

반면 프림 알고리즘은 인접 배열로 Greedy하게 접근하는 방법과 도현님이 말씀하신 우선순위 큐로 접근하는 방법이 있는데,

인접 배열을 사용하면 $$O(V^2)$$의, 우선순위 큐를 사용하면 $$O(ElogV)$$의 시간복잡도를 가지는 것으로 알고 있습니다.

따라서 간선의 수가 적은 그래프일 경우 크루스칼 알고리즘이 더 효율적이고,
간선의 수가 많으면 프림 알고리즘이 더 효율적인 것으로 알고 있습니다.

PS에서는 어차피 테스트 케이스가 다양하게 나와서 별로 중요하진 않은데
그냥 알아두면 나중에 쓸 곳이 있지 않을까요 🫠

[Fnhid]

그나저나 c++ stl에 priority_queue도 있군요.. 없는 것이 없네요 ㄷㄷ

[dohyeondol1]

그나저나 c++ stl에 priority_queue도 있군요.. 없는 것이 없네요 ㄷㄷ

C++은 잘 만들어진 STL이 많은 것 같아요 ㅎㅎ

[hadongun]

자료구조 때 배웠던 거라 그런지 기억이 생생하지 않네요 ㅎㅎ
그래도 기억이 남아 있어 조금 공부 한 후 풀 수 있었어용

파이썬에 재귀 횟수 제한이 있다는 것도 처음 알았네요..!
가능한 재귀 제한을 늘려서 해결했습니다.

데이타 스트럭쳐

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)


V, E = map(int, input().split())

edges = []
for _ in range(E):
    u, v, w = map(int, input().split())
    edges.append((w, u, v))

edges.sort()

parent = [i for i in range(V+1)]

def find(x):
    if parent[x] != x:
        parent[x] = find(parent[x])
    return parent[x]

def union(a, b):
    a = find(a)
    b = find(b)
    if a != b:
        parent[b] = a
        return True
    return False

result = 0
count = 0
for w, u, v in edges:
    if union(u, v):
        result += w
        count += 1
        if count == V-1:
            break

print(result)