蓝桥杯 ALGO-6 安慰奶牛

问题描述

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（数据有误，应该是178）

数据规模与约定

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

题意：这道题其实本身不是特别难，主要就是题意难以理解，主要是计算安慰所有的牛最短的时间，所有的牧场中的牛要安慰一次，但是题意指出起始点的牛要安慰两次。根据题意构造一颗最小生成树即解决总的安慰时间最短，但是树中的节点也存在权值，所以不能按照常规的套路来做，看了网上的许多老铁做的方法，把2*边的权值+边连接两点的安慰时长作为边的新的权值，然后在使用最小生成树的方法。蓝桥杯的官网的锦囊也说了这个方法。

思路：用结构体保存两点以及两点之间新的权值，然后加入优先级队列中，对<进行重载后，按照权值从小到大的顺序排列，然后使用克鲁斯卡尔算法解决总的时长。此算法中使用了并查集来解决问题，对于一颗最小生成树，只有集合，对优先级队列中的元素中包含的两点依次判断，判断是否属于一个集合中，不属于一个集合要进行合并，此处合并对于小树贴到大树上的优点不明显，和任意贴时间差不多，但是路径压缩还是需要的，树一直长高会导致查找效率变低，所以要进行路径压缩。

我在最后就是发现在蓝桥杯的OJ上不能使用system("pause");来使运行框暂停，会报错一个测试点都通不过。所以一定不要手残加了！！！

代码1：小树贴到大树上

#include <iostream>
#include<queue> 
#include<algorithm>
#define N 10010
using namespace std;
struct node {
	int u, v, dis;
	node(int u, int v, int d) :u(u), v(v), dis(d) {}
	friend bool operator < (const node &a, const node &b) {//重载小于运算负，使用优先级队列 
		return a.dis > b.dis;
	}
};
priority_queue<node> q;
int cost[N],s[N];
int find(int x) {//寻找父节点,并且进行路径压缩 
	if (s[x] < 0)return x;
	else {
		return s[x] = find(s[x]);
	}
}
void Union(int u, int v) {//合并两个节点 
	int rootU = find(u), rootV = find(v);
	if (rootU != rootV) {//操作的是对于根节点而而言的，
		if (s[rootU] < s[rootV]) {//值表示根节点的规模，将小的树挂在大的树上面 
			s[rootU] += s[rootV];
			s[rootV] = rootU;
		}
		else {
			s[rootV] += s[rootU];
			s[rootU] = rootV;
		}
	}
}
int kruskal() {//使用克鲁斯卡尔算法计算最小生成树，对于一颗最小生成树而言，其任意两点的父节点是相等的 
	int sumDis = 0;
	while (!q.empty()) {
		node tem = q.top();
		q.pop();
		int root1 = find(tem.u), root2 = find(tem.v);
		if (root1 != root2) {
			sumDis += tem.dis;
			Union(root1,root2);//将两个点的合并成一个集合 
		}
	}
	return sumDis;
}
int main(int argc, char** argv) {
	fill(s, s + N, -1);//初始化所有节点的父节点 
	int n, p, a, b, c;
	cin >> n >> p;
	for (int i = 1; i <= n; i++) {//输入所有节点的权值 
		scanf("%d", &cost[i]);
	}
	for (int i = 0; i < p; i++) {//输入所有的节点以及所有的路径 
		scanf("%d%d%d", &a, &b, &c);
		q.push(node{ a,b,(2 * c + cost[a] + cost[b]) }); //把路径的两倍+路径上两个节点的和作为边的新权值 
	}
	int sumCost = kruskal();
	sumCost += *min_element(cost+1,cost+n);//min_element函数主要求出的是给定数组长度的最小值
	cout << sumCost << endl;
	return 0;
}

代码2：第一个点贴在第二个点上

#include <iostream>
#include<queue> 
#include<algorithm>
#define N 10010
using namespace std;
struct node {
	int u, v, dis;
	node(int u, int v, int d) :u(u), v(v), dis(d) {}
	friend bool operator < (const node &a, const node &b) {//重载小于运算负，使用优先级队列 
		return a.dis > b.dis;
	}
};
priority_queue<node> q;
int cost[N], mindis, s[N];
int find(int x) {//寻找父节点,并且进行路径压缩 
	if (s[x] < 0)return x;
	else {
		return s[x] = find(s[x]);
	}
}
int kruskal() {//使用克鲁斯卡尔算法计算最小生成树，对于一颗最小生成树而言，其任意两点的父节点是相等的 
	int sumDis = 0;
	while (!q.empty()) {
		node tem = q.top();
		q.pop();
		int root1 = find(tem.u), root2 = find(tem.v);
		if (root1 != root2) {
			sumDis += tem.dis;
			s[root1] = root2;
		}
	}
	return sumDis;
}
int main(int argc, char** argv) {
	fill(s, s + N, -1);//初始化所有节点的父节点 
	int n, p, a, b, c;
	cin >> n >> p;
	for (int i = 1; i <= n; i++) {//输入所有节点的权值 
		scanf("%d", &cost[i]);
	}
	for (int i = 0; i < p; i++) {//输入所有的节点以及所有的路径 
		scanf("%d%d%d", &a, &b, &c);
		q.push(node{ a,b,(2 * c + cost[a] + cost[b]) }); //把路径的两倍+路径上两个节点的和作为边的新权值 
	}
	int sumCost = kruskal();
	sumCost += *min_element(cost+1,cost+n);
	cout << sumCost << endl;
	return 0;
}