[BOJ/GoldIV] 1197. 최소 스패닝 트리 - JAVA 자바

1197번: 최소 스패닝 트리

최소 신장 트리(Minimum Spanning Tree)를 구하는 문제로 크루스칼 알고리즘과 프림 알고리즘으로 구현해보았다.

크루스칼 알고리즘 : 최소 신장 트리(MST)를 찾는 알고리즘

프림 알고리즘 : 최소 신장 트리(MST)를 찾는 알고리즘

크루스칼

• 568ms

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

public class Main {

    static int v, e;
    static int[] parent;
    static long result;
    static List<Edge> graph = new ArrayList<>();

    static class Edge implements Comparable<Edge> {
        int v;
        int w;
        int cost;

        public Edge(int v, int w, int cost) {
            this.v = v;
            this.w = w;
            this.cost = cost;
        }

        @Override
        public int compareTo(Edge o) {
            if (this.cost < o.cost)
                return -1;
            return 1;
        }
    }

    static int find(int x) {
        if (parent[x] == x)
            return x;
        return parent[x] = find(parent[x]);

    }

    static void union(int a, int b) {
        a = find(a);
        b = find(b);

        if (a < b)
            parent[b] = parent[a];
        else
            parent[a] = parent[b];
    }

    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());

        parent = new int[v + 1];
        for (int i = 1; i <= v; i++) 
            parent[i] = i;


        for (int i = 0; i < e; i++) {
            st = new StringTokenizer(br.readLine());
            int v = Integer.parseInt(st.nextToken());
            int w = Integer.parseInt(st.nextToken());
            int c = Integer.parseInt(st.nextToken());

            graph.add(new Edge(v, w, c));
        }

        Collections.sort(graph);

        for (int i = 0; i < graph.size(); i++) {
            Edge e = graph.get(i);

            if(find(e.v) != find(e.w)) {
                union(e.v, e.w);
                result += e.cost;
            }
        }
        System.out.println(result);
    }

}

프림

• 612ms

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

public class Main {

    static int v, e;
    static long  result;
    static List<ArrayList<Edge>> graph = new ArrayList<>();
    static boolean[] visited;

    static class Edge implements Comparable<Edge> {
        int v;
        int cost;

        public Edge(int v, int cost) {
            this.v = v;
            this.cost = cost;
        }

        @Override
        public int compareTo(Edge o) {
            if (this.cost < o.cost)
                return -1;
            return 1;
        }
    }

    static void Prim() {
        PriorityQueue<Edge> pq = new PriorityQueue<>();
        pq.offer(new Edge(1, 0));
        while (!pq.isEmpty()) {
            Edge edge = pq.poll();

            if (visited[edge.v])
                continue;
            visited[edge.v] = true;
            result += edge.cost;

            for (Edge e : graph.get(edge.v))
                if (!visited[e.v])
                    pq.offer(e);
        }

    }

    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());

        visited = new boolean[v + 1];
        for (int i = 0; i <= v; i++)
            graph.add(new ArrayList<>());

        for (int i = 0; i < e; i++) {
            st = new StringTokenizer(br.readLine());
            int v = Integer.parseInt(st.nextToken());
            int w = Integer.parseInt(st.nextToken());
            int c = Integer.parseInt(st.nextToken());

            graph.get(v).add(new Edge(w, c));
            graph.get(w).add(new Edge(v, c));
        }

        Prim();
        System.out.println(result);
    }

}