问题描述
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。
算法思路
问题实际上是一个最小生成树问题,对于最小生成树问题可以采用kruskal算法和prim算法。
采用kruskal算法,在判断是否形成回路时,采用并查算法。具体的算法过程可以参考https://www.cnblogs.com/liuzhen1995/p/6519646.html。
示例代码
1、采用插入排序,只有80分。
import java.util.Scanner;
public class Main {
static class Edge{
public int start;
public int stop;
public int value;
public Edge(int start, int stop, int value){
this.start = start;
this.stop = stop;
this.value = value;
}
}
public static int[] values;
public static Edge[] edges;
// kruskal最小生成树算法
public static void getMinTree(){
int sum = 0;
int[] id = new int[values.length];
for(int i = 0; i < values.length; i ++){
id[i] = -1;
}
edgeSort(edges);
for(int i = 0; i < edges.length; i ++){
int st = edges[i].start;
int sp = edges[i].stop;
int idst = find(id, st);
int idsp = find(id, sp);
if(idst != idsp){
sum += edges[i].value;
union(id, idst, idsp);
}
}
int minValue = values[0];
for(int i = 0; i < values.length; i ++){
if(minValue > values[i]){
minValue = values[i];
}
}
sum += minValue;
System.out.println(sum);
}
// 插入排序
public static void edgeSort(Edge[] edges){
int i, j;
for(i = 1; i < edges.length ; i ++){
if(edges[i].value < edges[i - 1].value){
Edge e = edges[i];
for(j = i - 1; j >= 0 && edges[j].value > e.value; j --){
edges[j + 1] = edges[j];
}
edges[j + 1] = e;
}
}
}
//获取节点a的根节点编号
public static int find(int[] id, int a) {
int i, root, k;
root = a;
while(id[root] >= 0)
root = id[root]; //此处,若id[root] >= 0,说明此时的a不是根节点,因为唯有根节点的值小于0
k = a;
while(k != root) { //将a节点所在树的所有节点,都变成root的直接子节点
i = id[k];
id[k] = root;
k = i;
}
return root;
}
//判断顶点a和顶点b的根节点大小,根节点值越小,代表其对应树的节点越多,将节点少的树的根节点作为节点多的树的根节点的直接子节点
public static void union(int[] id, int a, int b) {
int ida = find(id, a); //得到顶点a的根节点
int idb = find(id, b); //得到顶点b的根节点
int num = id[ida] + id[idb]; //由于根节点值必定小于0,此处num值必定小于零
if(id[ida] < id[idb]) {
id[idb] = ida; //将顶点b的根节点作为顶点a根节点的直接子节点
id[ida] = num; //更新根节点的id值
} else {
id[ida] = idb; //将顶点a的根节点作为顶点b根节点的直接子节点
id[idb] = num; //更新根节点的id值
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// n表示顶点数
int n = scanner.nextInt();
// p表示边数
int p = scanner.nextInt();
// values数组表示每个顶点的值
values = new int[n];
// 构建values数组
for(int i = 0; i < n; i ++){
values[i] = scanner.nextInt();
}
// edges数组表示多条边
edges = new Edge[p];
// 构建edges数组
for(int i = 0; i < p; i ++){
int start = scanner.nextInt() - 1;
int stop = scanner.nextInt() - 1;
int value = scanner.nextInt() * 2 + values[start] + values[stop];
edges[i] = new Edge(start, stop, value);
}
getMinTree();
scanner.close();
}
}
2、采用归并排序,由于归并排序时间复杂度较插入排序少,改进后的代码达到100分。
import java.util.Scanner;
public class Main {
static class Edge{
public int start;
public int stop;
public int value;
public Edge(int start, int stop, int value){
this.start = start;
this.stop = stop;
this.value = value;
}
}
public static int[] values;
public static Edge[] edges;
// kruskal最小生成树算法
public static void getMinTree(){
int sum = 0;
int[] id = new int[values.length];
for(int i = 0; i < values.length; i ++){
id[i] = -1;
}
edgeSort(edges);
for(int i = 0; i < edges.length; i ++){
int st = edges[i].start;
int sp = edges[i].stop;
int idst = find(id, st);
int idsp = find(id, sp);
if(idst != idsp){
sum += edges[i].value;
union(id, idst, idsp);
}
}
int minValue = values[0];
for(int i = 0; i < values.length; i ++){
if(minValue > values[i]){
minValue = values[i];
}
}
sum += minValue;
System.out.println(sum);
}
// 归并排序
public static void edgeSort(Edge[] A){
if(A.length > 1) {
Edge[] leftA = getHalfEdge(A, 0);
Edge[] rightA = getHalfEdge(A, 1);
edgeSort(leftA);
edgeSort(rightA);
mergeEdgeArray(A, leftA, rightA);
}
}
//judge = 0返回数组A的左半边元素,否则返回右半边元素
public static Edge[] getHalfEdge(Edge[] A, int judge) {
Edge[] half;
if(judge == 0) {
half = new Edge[A.length / 2];
for(int i = 0;i < A.length / 2;i++)
half[i] = A[i];
} else {
half = new Edge[A.length - A.length / 2];
for(int i = 0;i < A.length - A.length / 2;i++)
half[i] = A[A.length / 2 + i];
}
return half;
}
//合并leftA和rightA,并按照从小到大顺序排列
public static void mergeEdgeArray(Edge[] A, Edge[] leftA, Edge[] rightA) {
int i = 0;
int j = 0;
int len = 0;
while(i < leftA.length && j < rightA.length) {
if(leftA[i].value < rightA[j].value) {
A[len++] = leftA[i++];
} else {
A[len++] = rightA[j++];
}
}
while(i < leftA.length) A[len++] = leftA[i++];
while(j < rightA.length) A[len++] = rightA[j++];
}
//获取节点a的根节点编号
public static int find(int[] id, int a) {
int i, root, k;
root = a;
while(id[root] >= 0)
root = id[root]; //此处,若id[root] >= 0,说明此时的a不是根节点,因为唯有根节点的值小于0
k = a;
while(k != root) { //将a节点所在树的所有节点,都变成root的直接子节点
i = id[k];
id[k] = root;
k = i;
}
return root;
}
//判断顶点a和顶点b的根节点大小,根节点值越小,代表其对应树的节点越多,将节点少的树的根节点作为节点多的树的根节点的直接子节点
public static void union(int[] id, int a, int b) {
int ida = find(id, a); //得到顶点a的根节点
int idb = find(id, b); //得到顶点b的根节点
int num = id[ida] + id[idb]; //由于根节点值必定小于0,此处num值必定小于零
if(id[ida] < id[idb]) {
id[idb] = ida; //将顶点b的根节点作为顶点a根节点的直接子节点
id[ida] = num; //更新根节点的id值
} else {
id[ida] = idb; //将顶点a的根节点作为顶点b根节点的直接子节点
id[idb] = num; //更新根节点的id值
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// n表示顶点数
int n = scanner.nextInt();
// p表示边数
int p = scanner.nextInt();
// values数组表示每个顶点的值
values = new int[n];
// 构建values数组
for(int i = 0; i < n; i ++){
values[i] = scanner.nextInt();
}
// edges数组表示多条边
edges = new Edge[p];
// 构建edges数组
for(int i = 0; i < p; i ++){
int start = scanner.nextInt() - 1;
int stop = scanner.nextInt() - 1;
int value = scanner.nextInt() * 2 + values[start] + values[stop];
edges[i] = new Edge(start, stop, value);
}
getMinTree();
scanner.close();
}
}