蓝桥杯练习系统算法训练 安慰奶牛

问题描述

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

输入格式

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

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

接下来P行，每行包含三个整数S_j, E_j和L_j。

输出格式

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

样例输入（官网上的数据是错误的，特此更改）

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

样例输出

178

数据规模与约定

5 <= N <= 10000，N-1 <= P <= 100000，0 <= L_j <= 1000，1 <= C_i <= 1,000。

package 算法训练;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

class Reader6 {
	static BufferedReader reader;
	static StringTokenizer tokenizer;

	static void init(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	static String next() throws IOException {
		while (!tokenizer.hasMoreElements()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

	static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
}

class KruskalDui1 {
	int a, b, l;
}

public class  安慰奶牛 {
	
	static int father[] = new int[100000];
	static ArrayList<KruskalDui1> path = new ArrayList<KruskalDui1>();//ArrayList集合 path

	public static int getfather(int x) {//找x节点的父节点的函数，return他的父节点
		if (x != father[x]) {
			father[x] = getfather(father[x]);
		}
		return father[x];
	}

	public static void _qst_w(int l, int r) {//在排序，对权值进行排序
		int i = l, j = r, mw = path.get((i + j) / 2).l;
		while (i <= j) {
			while (path.get(i).l < mw)
				i++;
			while (path.get(j).l > mw)
				j--;
			if (i <= j) {
				Collections.swap(path, i, j);//swap函数表示在指定列表的指定位置处交换元素
				i++;
				j--;
			}
		}
		if (l < j)
			_qst_w(l, j);
		if (i < r)
			_qst_w(i, r);
	}
	public static void sort(ArrayList<KruskalDui1> path,int p)
	{
		for(int i=0;i<p-1;i++)
		{
			for(int j=0;j<p-1-i;j++)
			{
				if(path.get(j).l>path.get(j+1).l) Collections.swap(path, j, j+1);
			}
		}
	}
	
	public static void main(String[] args) throws IOException {
		Reader6.init(System.in);
		int n = Reader6.nextInt();//n个牧场
		int p = Reader6.nextInt();//p条道路
		int d[] = new int[n + 1];//每个牧场谈心的时间d[i];
		int minD = Integer.MAX_VALUE;
		for (int i = 1; i < n + 1; i++) {
			d[i] = Reader6.nextInt();//给d[]赋值
			father[i] = i;//每个牧场的父节点都是他们本身，单个的节点
			if (d[i] < minD) {
				minD = d[i];//找到想要停留过夜的那个牧场，找d[]中最小的那个牧场
			}
		}
		for (int i = 0; i < p; i++) {
			KruskalDui1 k = new KruskalDui1();//新建一个kruskaldui的对象，包含a,b,l
			k.a = Reader6.nextInt();
			k.b = Reader6.nextInt();
			k.l = Reader6.nextInt();
			k.l = k.l * 2 + d[k.a] + d[k.b];//每条边的权值等于2倍的边权值+a牧场的权值+b牧场的权值
			path.add(k);//把牧场的信息加入到集合path中
		}
		
		//_qst_w(0, p - 1);//按照边的权值来进行排序
		sort(path,p);
		
		int fx, fy, result = minD, count = 0, k = 0;
		while (count < n - 1) {//排序完成之后开始来将最小值的边加入我们的结果中，其中在加入的时候需要注意不能够成回路，所以就用getfather()函数来实现
			fx = getfather(path.get(k).a);
			fy = getfather(path.get(k).b);
			if (fx != fy) {
				father[fx] = fy;
				result += path.get(k).l;
				count++;
			}
			k++;
		}
		System.out.println(result);
	}
}