布线问题 南阳理工 最小生成树

每日一看

Prime算法的核心步骤是：在带权连通图中V是包含所有顶点的集合， U已经在最小生成树中的节点，从图中任意某一顶点v开始，此时集合U={v}，重复执行下述操作：在所有u∈U,w∈V-U的边(u,w)∈E中找到一条权值最小的边，将(u,w)这条边加入到已找到边的集合，并且将点w加入到集合U中，当U=V时，就找到了这颗最小生成树。
       其实，算法的核心步骤就是：在所有u∈U,w∈V-U的边(u,w)∈E中找到一条权值最小的边。

      知道了普利姆算法的核心步骤，下面我就用图示法来演示一下工作流程，如图：

 

 

首先，确定起始顶点。我以顶点A作为起始点。根据查找法则，与点A相邻的点有点B和点H，比较AB与AH，我们选择点B，如下图。并将点B加入到U中。

 

继续下一步，此时集合U中有{A,B}两个点，再分别以这两点为起始点，根据查找法则，找到边BC（当有多条边权值相等时，可选任意一条），如下图。并将点C加入到U中。

 

继续，此时集合U中有{A,B,C}三个点，根据查找法则，我们找到了符合要求的边CI，如下图。并将点I加入到U中。

 

继续，此时集合U中有{A,B,C,I}四个点，根绝查找法则，找到符合要求的边CF，如下图。并将点F加入到集合U中。

 

继续，依照查找法则我们找到边FG,如下图。并将点G加入到U中。

 

继续，依照查找法则我们找到边GH,如下图。并将点H加入到U中。

 

继续，依照查找法则我们找到边CD,如下图。并将点D加入到U中。

 

继续，依照查找法则我们找到边DE,如下图。并将点E加入到U中。

 

此时，满足U = V，即找到了这颗最小生成树。

 

接下来看最小生成树的例子

 

 

布线问题

时间限制：1000 ms  |  内存限制：65535 KB

难度：4

描述

南阳理工学院要进行用电线路改造，现在校长要求设计师设计出一种布线方式，该布线方式需要满足以下条件：
1、把所有的楼都供上电。
2、所用电线花费最少

输入

第一行是一个整数n表示有n组测试数据。(n<5)
每组测试数据的第一行是两个整数v,e.
v表示学校里楼的总个数(v<=500)
随后的e行里，每行有三个整数a,b,c表示a与b之间如果建铺设线路花费为c(c<=100)。（哪两栋楼间如果没有指明花费，则表示这两栋楼直接连通需要费用太大或者不可能连通）
随后的1行里，有v个整数,其中第i个数表示从第i号楼接线到外界供电设施所需要的费用。( 0<e<v*(v-1)/2 )
（楼的编号从1开始），由于安全问题，只能选择一个楼连接到外界供电设备。
数据保证至少存在一种方案满足要求。

输出

每组测试数据输出一个正整数,表示铺设满足校长要求的线路的最小花费。

样例输入

1
4 6
1 2 10
2 3 10
3 1 10
1 4 1
2 4 1
3 4 1
1 3 5 6

样例输出

4

import java.util.Scanner;
/**
 * 最小生成树算法 任意找出一点 加入集合U中{开始U集合为空} v{包含所有顶点}
 * 
 * 1：找出u集合中与v集合中最小的边u-v0 2：将vo加入U中 吧v集合中去除vo 3:重复以上步骤 知道u集合包含所有顶点 v集合为空
 * 
 * @author Administrator
 * 
 */
public class Prim {
private static final int MAXN = 500;
private static final int INF = 1000000;
private static int[][] map = new int[MAXN][MAXN];
private static int[] lowcost = new int[MAXN];// 到新集合的最小权
private static int[] nearvex = new int[MAXN];// 判断顶点是否已经判断过
private static int n, m;
private static int[] out;
private static int temp=INF;
public static void main(String args[]) {
Scanner scan = new Scanner(System.in);
int x = scan.nextInt();
while (x > 0) {
temp=INF;
n = scan.nextInt();
m = scan.nextInt();
out=new int[n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) {
map[i][j] = 0;
} else {
map[i][j] = INF;
map[j][i] = INF;
}
}
}
for (int i = 0; i < n ; i++) {
out[i]=INF;
}
for (int i = 0; i < m; i++) {
int a1, b1, c1;
a1 = scan.nextInt();
b1 = scan.nextInt();
c1 = scan.nextInt();
map[a1 - 1][b1 - 1] = c1;
map[b1 - 1][a1 - 1] = c1;
}
for (int i = 0; i <n; i++) {
int z=scan.nextInt();
out[i]=z;
}
prim(0);
x--;
}
}
private static void prim(int u) {
// TODO Auto-generated method stub
int sum = 0;
int min = 0;
for (int i = 0; i < n; i++) {
lowcost[i] = map[0][i];
nearvex[i] = u;
}
nearvex[u] = -1;
for (int i = 0; i < n - 1; i++) {
int u0 = -1;
min = 1000000;
for (int j = 0; j < n; j++) {
if (lowcost[j] < min && nearvex[j] != -1) {
u0 = j;
min = lowcost[j];
}
}
if (u0 != -1) {
sum += lowcost[u0];
nearvex[u0] = -1;
// 重置
for (int k = 0; k < n; k++) {
// 这里是重点 第一判断新加入的点到其他顶点的最小边权和之前集合中的点到其他顶点的最小边权
if (nearvex[k] != -1 && map[u0][k] < lowcost[k]) {
lowcost[k] = map[u0][k];
nearvex[k] = u0;
}
}
}
}
for(int i=0;i<out.length;i++){
if(out[i]<temp){
temp=out[i];
}
}
System.out.println(sum+temp);
}
}