nyoj 38 布线问题 （prime、kruskal算法）

布线问题

时间限制： 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

/*prime:用一个vis数组保存已经加入生成树的点，
用lowcost数组保存红点集与蓝点集之间的连线们的最小值，
举个例子：假如第一个点是1，那么把邻接矩阵的从1出去的那些边都存到lowcost里，
作为最小值。然后算完一遍之后发现1-2的连线权值最小，所以把2再加入红点集。
此时更新lowcost。由数据结构知，这时我们应该从所有和1,2相连且不是1-2边的所有边中找一个最小的，
把这条边中在蓝点集的那个点加入。但此时如果把这些边都比较一遍找一个最小的未免太麻烦了，
所以就将可能有的新的边和lowcost原来的边相比，比如：1-3边权值为5，即lowcost[3] = 5,2-3边为2，
这时2-3边和lowcost[3]一比，发现2-3权值更小，就把lowcost[3]改为2.此时lowcost中存的就是红点集中的点
依次与外界所有点的最小的连线。*/
（下边这个题不是布线问题，是公路村村通，大同小异）
<pre name="code" class="cpp">#include <stdio.h>
#include <string.h>
#define INF 999999
int n, m, a[1005][1005], vis[1005], lowcost[1005];
int prime(int choose)
{
	int i, j, k, min, ans = 0;
	vis[choose] = 1;
	for(i = 1 ; i <= n ; i++)
	{
		lowcost[i] = a[choose][i];
		
	} 
	for(i = 0 ; i < n-1 ; i++)//要寻找n-1个点，所以循环n-1次
	{
		min = INF;
		for(j = 1 ; j <= n ; j++)//找出下一个加入红点集的点 
		{
			if(vis[j] == 0 && min > lowcost[j])
			{
			    min = lowcost[j];
			    k = j;
			}
		}
		if(min == INF)//如果还没有找完这n-1个点，就发现已经没有可以加入的点了，说明不连通，此时直接返回-1
		{
			ans = -1;
		    break;
		}
		ans += min;
		vis[k] = 1;
		for(j = 1 ; j <= n ; j++)
		{
			if(vis[j] == 0 && lowcost[j] > a[k][j])
			{
				lowcost[j] = a[k][j];
			}
		}
	}
	return ans;
} 
int main()
{
	int i, j, x, y, w;
	scanf("%d %d", &n, &m);
	for(i = 1 ; i <= n ; i++)
	    for(j = 1 ; j <= n ; j++)
	        a[i][j] = INF;
	for(i = 0 ; i < m ; i++)
	{
		scanf("%d %d %d", &x, &y, &w);
		a[x][y] = a[y][x] = w;
	}
	printf("%d\n", prime(1));
	return 0;
}

/*kruskal:这个用笔和纸模拟起来比prime更方便些。先把权值从小到大排序，然后逐条边加入，
成环的时候不加入，直到所有边的总条数为v-1时为止。
写成算法的时候，用到了并查集的思想。就是考察这条边加入后成不成环的时候。
这时候就是相当于通畅工程中“两点已经连通，修的这条路多余了”。
所以开始的时候把每个点的上级设为自己，join的时候，如果上级不同，就把一个点的上级改为另一个点；
如果上级相同，得，就是成环了。
这里保存边集的时候可以用结构体数组+sort排序，也可以直接用优先级队列，来处理开始时权值大小的排序。*/
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <queue>
#define INF 0xfffffff
using namespace std;
typedef struct node
{
    int a, b, cost;
    friend bool operator < (node a, node b)
    {
        return a.cost > b.cost;//cost小的优先。
    }
}node;
priority_queue<node> q;
int v, e, father[510];
int getfather(int x)
{
    return x == father[x] ? x : getfather(father[x]);
}
int join(int a, int b)
{
    int fa = getfather(a);
    int fb = getfather(b);
    if(fa == fb)
        return 0;
    father[fa] = fb;
    return 1;
}
int kruskal()
{
    node u;
    int ans = 0, k = 0;
    while(!q.empty())
    {
        u = q.top();
        q.pop();
        if(join(u.a, u.b))
        {
            ans += u.cost;
            k++;
        }
        if(k == v-1)
            break;
    }
    return ans;
}
int main()
{
    int n, min, i, c;
    node u;
    scanf("%d", &n);
    while(n--)
    {
        while(!q.empty())
            q.pop();
        scanf("%d %d\n", &v, &e);
        for(i = 1 ; i <= v ; i++)
            father[i] = i;
        for(i = 0 ; i < e ; i++)
        {
            scanf("%d %d %d", &u.a, &u.b, &u.cost);
            q.push(u);
        }
        for(i = 0 ; i < v ; i++)
        {
            scanf("%d", &c);
            if(min > c)
                min = c;
        }
        printf("%d\n", kruskal()+min);
    }
    return 0;
}