[백준] 1197 최소 스패닝 트리 🎄 (Java)

문제 링크

https://www.acmicpc.net/problem/1197

문제 설명

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

입력

첫째 줄에 정점의 개수 V(1 ≤ V ≤ 10,000)와 간선의 개수 E(1 ≤ E ≤ 100,000)가 주어진다. 다음 E개의 줄에는 각 간선에 대한 정보를 나타내는 세 정수 A, B, C가 주어진다. 이는 A번 정점과 B번 정점이 가중치 C인 간선으로 연결되어 있다는 의미이다. C는 음수일 수도 있으며, 절댓값이 1,000,000을 넘지 않는다.

그래프의 정점은 1번부터 V번까지 번호가 매겨져 있고, 임의의 두 정점 사이에 경로가 있다. 최소 스패닝 트리의 가중치가 -2,147,483,648보다 크거나 같고, 2,147,483,647보다 작거나 같은 데이터만 입력으로 주어진다.

출력

첫째 줄에 최소 스패닝 트리의 가중치를 출력한다.

구조화

최소 스패닝 트리(MST) 중 크루스칼, 프림 활용
MST 학습할겸 매일 루틴으로 풀고있다. Like 영단어 외우기..ㅎ

소스 코드(크루스칼)

import java.io.*;
import java.util.*;

public class Main {
    static int V, E;
    static int[] parents;
    static class Node implements Comparable<Node>{
        int to, from, cost;
        public Node(int to, int from, int cost) {
            this.to = to;
            this.from = from;
            this.cost = cost;
        }

        @Override
        public int compareTo(Node o) {
            return this.cost - o.cost;
        }
    }
    static List<Node> list = new LinkedList<>();
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        V = Integer.parseInt(st.nextToken());
        E = Integer.parseInt(st.nextToken());

        parents = new int[V+1];
        for (int i = 1; i <= V; i++) {
            parents[i] = i;
        }

        for (int i = 0; i < E; i++) {
            st = new StringTokenizer(br.readLine());
            int to = Integer.parseInt(st.nextToken());
            int from = Integer.parseInt(st.nextToken());
            int cost = Integer.parseInt(st.nextToken());

            list.add(new Node(to, from, cost));
        }
        Collections.sort(list);

        int sum = 0;
        int cnt = 0;
        for (Node n : list) {
            if (union(n.to, n.from)) {
                sum += n.cost;
                cnt++;
            }
            if (cnt == E-1) {
                break;
            }
        }
        System.out.println(sum);
    }

    static boolean union(int to, int from) {
        int toRoot = find(to);
        int fromRoot = find(from);

        if (toRoot != fromRoot) {
            parents[toRoot] = fromRoot;
            return true;
        }
        return false;
    }

    static int find(int v) {
        if (parents[v] == v) return v;
        return parents[v] = find(parents[v]);
    }
}

소스 코드(프림)

import java.io.*;
import java.util.*;

public class Main {
    static class Node implements Comparable<Node> {
        int end; int dist;
        public Node(int end, int dist) {
            this.end = end;
            this.dist = dist;
        }

        @Override
        public int compareTo(Node o) {
            return this.dist - o.dist;
        }
    }
    static List<Node>[] list;
    static boolean[] v;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int V = Integer.parseInt(st.nextToken());
        int E = Integer.parseInt(st.nextToken());

        v = new boolean[V+1];
        list = new List[V+1];
        for (int i = 1; i <= V; i++) {
            list[i] = new LinkedList<>();
        }
        for (int i = 0; i < E; i++) {
            st = new StringTokenizer(br.readLine());
            int to = Integer.parseInt(st.nextToken());
            int from = Integer.parseInt(st.nextToken());
            int dist = Integer.parseInt(st.nextToken());

            list[to].add(new Node(from, dist));
            list[from].add(new Node(to, dist));
        }
        
        System.out.println(prim(1));
    }

    static int prim(int start) {
        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.offer(new Node(start, 0));
        int ans = 0;
        while (!pq.isEmpty()) {
            Node cur = pq.poll();

            if (v[cur.end]) continue;
            v[cur.end] = true;
            ans += cur.dist;

            for (Node next : list[cur.end]) {
                if (!v[next.end]) {
                    pq.offer(next);
                }
            }
        }

        return ans;
    }
}