ALGO-6 安慰奶牛

ALGO-6 安慰奶牛

题目

资源限制

时间限制：1.0s 内存限制：256.0MB

问题描述

Farmer John 变得非常懒，他不想再继续维护供奶牛之间供通行的道路。道路被用来连接 N 个牧场，牧场被连续地编号为 1 到 N。每一个牧场都是一个奶牛的家。FJ 计划除去 P 条道路中尽可能多的道路，但是还要保持牧场之间 的连通性。你首先要决定那些道路是需要保留的 N-1 条道路。第 j 条双向道路连接了牧场 Sj 和 Ej(1 <= Sj <= N; 1 <= Ej <= N; Sj != Ej)，而且走完它需要 Lj 的时间。没有两个牧场是被一条以上的道路所连接。奶牛们非常伤心，因为她们的交通系统被削减了。你需要到每一个奶牛的住处去安慰她们。每次你到达第 i 个牧场的时候(即使你已经到过)，你必须花去 Ci 的时间和奶牛交谈。你每个晚上都会在同一个牧场(这是供你选择的)过夜，直到奶牛们都从悲伤中缓过神来。在早上 起来和晚上回去睡觉的时候，你都需要和在你睡觉的牧场的奶牛交谈一次。这样你才能完成你的 交谈任务。假设 Farmer John 采纳了你的建议，请计算出使所有奶牛都被安慰的最少时间。

输入格式

第 1 行包含两个整数 N 和 P。

接下来 N 行，每行包含一个整数 Ci。

接下来 P 行，每行包含三个整数 Sj, Ej 和 Lj。

输出格式

输出一个整数, 所需要的总时间(包含和在你所在的牧场的奶牛的两次谈话时间)。

样例输入

5 6
10
10
20
6
30
1 2 5
2 3 5
2 4 12
3 4 17
2 5 15
3 5 6

样例输出

176

数据规模与约定

5 <= N <= 10000，N-1 <= P <= 100000，0 <= Lj <= 1000，1 <= Ci <= 1,000。

题解

import java.util.Scanner;

public class ALGO_6 {
    static class UnionFind {
        /**
        * 数组，表示并查集所有元素
        */
        private int[] id;

        /**
         * 并查集的元素个数
         */
        int size;

        /**
         * 构造一个新的并查集
         *
         * @param size 初始大小
         */
        public UnionFind(int size) {
            //初始化个数
            this.size = size;
            //初始化数组，每个并查集都指向自己
            id = new int[size];
            for (int i = 0; i < size; i++) {
                id[i] = i;
            }
        }

        /**
         * 查看元素所属于哪个集合
         *
         * @param element 要查看的元素
         * @return element元素所在的集合
         */
        int find(int element) {
            return id[element];
        }

        /**
        * 判断两个元素是否同属于一个集合
        *
        * @param firstElement  第一个元素
        * @param secondElement 第二个元素
        * @return <code>boolean</code> 如果是则返回true。
        */
        public boolean isConnected(int firstElement, int secondElement) {
            return find(firstElement) == find(secondElement);
        }

        /**
         * 合并两个元素所在的集合，也就是连接两个元素
         *
         * @param firstElement  第一个元素
         * @param secondElement 第二个元素
         */
        public void unionElements(int firstElement, int secondElement) {
            //找出firstElement所在的集合
            int firstUnion = find(firstElement);
            //找出secondElement所在的集合
            int secondUnion = find(secondElement);

            //如果这两个不是同一个集合，那么合并。
            if (firstUnion != secondUnion) {
                //遍历数组，使原来的firstUnion、secondUnion合并为secondUnion
                for (int i = 0; i < this.size; i++) {
                    if (id[i] == firstUnion) {
                        id[i] = secondUnion;
                    }
                }
            }
        }
    }

    static class Edge {
        int start;
        int end;
        int weight;

        Edge(int start, int end, int weight) {
            this.start = start;
            this.end = end;
            this.weight = weight;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int P = sc.nextInt();
        int min = 1000;
        int[] conformTime = new int[N];
        Edge[] edge = new Edge[P];
        for (int i = 0; i < N; i++) {
            conformTime[i] = sc.nextInt();
            if (conformTime[i] < min)
                min = conformTime[i];
        }
        for (int i = 0; i < P; i++) {
            int start = sc.nextInt() - 1;
            int end = sc.nextInt() - 1;
            int length = sc.nextInt();
            edge[i] = new Edge(start, end, 2 * length + conformTime[start] + conformTime[end]);
        }
        sc.close();
        for (int i = 0; i < conformTime.length; i++)
            if (conformTime[i] < min)
                min = conformTime[i];

        Edge[] tree = Kruskal(edge, N);
        System.out.println(count(tree) + min);
    }

    public static int count(Edge[] tree) {
        int sum = 0;
        for (int i = 0; i < tree.length; i++) {
            sum += tree[i].weight;
        }
        return sum;
    }

    public static Edge[] Kruskal(Edge[] edges, int size) {
        Edge[] tree = new Edge[size - 1];
        int index = 0;
        UnionFind uf = new UnionFind(size);
        edges = sort(edges);
        for (int i = 0; index < size - 1; i++) {
            int start = edges[i].start, end = edges[i].end;
            if (uf.find(start) != uf.find(end)) {
                uf.unionElements(start, end);
                tree[index++] = edges[i];
            }
        }
        return tree;
    }

    public static Edge[] sort(Edge[] edge) {
        Edge temp;
        for (int k = edge.length / 2; k > 0; k /= 2) {
            for (int i = k; i < edge.length; i++) {
                for (int j = i; j >= k; j -= k) {
                    if (edge[j - k].weight > edge[j].weight) {
                        temp = edge[j - k];
                        edge[j - k] = edge[j];
                        edge[j] = temp;
                    }
                }
            }
        }
        return edge;
    }

}