HDU 2988.Dark roads-最小生成树(Kruskal)

最小生成树:

中文名 最小生成树

外文名 Minimum Spanning Tree,MST

一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。

最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。

最小生成树其实是最小权重生成树的简称。

 

应用: 生成树和最小生成树有许多重要的应用。

 

例如：要在n个城市之间铺设光缆，主要目标是要使这 n 个城市的任意两个之间都可以通信，但铺设光缆的费用很高，且各个城市之间铺设光缆的费用不同，因此另一个目标是要使铺设光缆的总费用最低。这就需要找到带权的最小生成树。

 

性质:设G=(V，E）是一个连通网络，U是顶点集V的一个非空真子集。若(u，v）是G中一条“一个端点在U中（例如：u∈U），另一个端点不在U中的边（例如：v∈V-U），且（u，v）具有最小权值，则一定存在G的一棵最小生成树包括此边（u，v）。

 

证明:为方便说明，先作以下约定：

①将集合U中的顶点看作是红色顶点，②而V-U中的顶点看作是蓝色顶点，③连接红点和蓝点的边看作是紫色边，④权最小的紫边称为轻边（即权重最"轻"的边）。

于是，MST性质中所述的边（u，v）  就可简称为轻边。

      

用反证法证明MST性质：

假设G中任何一棵MST都不含轻边（u，v）。则若T为G的任意一棵MST，那么它不含此轻边。

根据树的定义，则T中必有一条从红点u到蓝点v的路径P，且P上必有一条紫边（u'，v'）连接红点集和蓝点集，否则u和v不连通。

当把轻边（u，v）加入树T时，该轻边和P必构成了一个回路。

删去紫边  （u'，v'）后回路亦消除，由此可得另一生成树T'。

T'和T的差别仅在于T'用轻边（u，v）取代了T中权重可能更大的紫边（u'，v'）。因为w(u，v）≤w(u'，v'），所以

w(T')=w(T)+w(u，v)-w(u'，v'）≤w(T)

即T'是一棵比T更优的MST，所以T不是G的MST，这与假设矛盾。

所以，MST性质成立。

 

算法描述:

求MST的一般算法可描述为：针对图G，从空树T开始，往集合T中逐条选择并加入n-1条安全边（u，v），最终生成一棵含n-1条边的MST。

当一条边（u，v）加入T时，必须保证T∪{(u，v)}仍是MST的子集，我们将这样的边称为T的安全边。

 

Prim算法简述:(点)

时间复杂度:O(n^2)

 

1).输入：一个加权连通图，其中顶点集合为V，边集合为E；

2).初始化：V_new= {x}，其中x为集合V中的任一节点（起始点），E_new= {},为空；

3).重复下列操作，直到V_new= V：

a.在集合E中选取权值最小的边<u, v>，其中u为集合V_new中的元素，而v不在V_new集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

b.将v加入集合V_new中，将<u, v>边加入集合E_new中；

4).输出：使用集合V_new和E_new来描述所得到的最小生成树。

Kruskal算法简述:(边)

时间复杂度:(O(n*log(n))

 

假设 WN=(V,{E}) 是一个含有 n 个顶点的连通网，则按照克鲁斯卡尔算法构造最小生成树的过程为：先构造一个只含 n 个顶点，而边集为空的子图，若将该子图中各个顶点看成是各棵树上的根结点，则它是一个含有 n 棵树的一个森林。之后，从网的边集 E 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，也就是说，将这两个顶点分别所在的两棵树合成一棵树；反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直至森林中只有一棵树，也即子图中含有 n-1条边为止。

以上都来自百度百科，好多字，看着就烦。。。

 

n个节点  n-1条边  sigma（wi)==min；
图-->最小生成树

 

这样就简单好多

 

 

 

Dark roads

 

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1056    Accepted Submission(s): 463

Problem Description

Economic times these days are tough, even in Byteland. To reduce the operating costs, the government of Byteland has decided to optimize the road lighting. Till now every road was illuminated all night long, which costs 1 Bytelandian Dollar per meter and day. To save money, they decided to no longer illuminate every road, but to switch off the road lighting of some streets. To make sure that the inhabitants of Byteland still feel safe, they want to optimize the lighting in such a way, that after darkening some streets at night, there will still be at least one illuminated path from every junction in Byteland to every other junction.

What is the maximum daily amount of money the government of Byteland can save, without making their inhabitants feel unsafe?

 

Input

The input file contains several test cases. Each test case starts with two numbers m and n, the number of junctions in Byteland and the number of roads in Byteland, respectively. Input is terminated by m=n=0. Otherwise, 1 ≤ m ≤ 200000 and m-1 ≤ n ≤ 200000. Then follow n integer triples x, y, z specifying that there will be a bidirectional road between x and y with length z meters (0 ≤ x, y < m and x ≠ y). The graph specified by each test case is connected. The total length of all roads in each test case is less than 2³¹.

 

Output

For each test case print one line containing the maximum daily amount the government can save.

 

Sample Input

7 11

0 1 7

0 3 5

1 2 8

1 3 9

1 4 7

2 4 5

3 4 15

3 5 6

4 5 8

4 6 9

5 6 11

0 0

 

Sample Output

51

 

 

Kruskal.

代码:

#include<bits/stdc++.h>
using namespace std;
const int N=*1e5+;
int parent[N];
int ans;
int m,n;
struct node{
    int u,v,w;
}a[N];
bool cmp(node x,node y){
    return x.w<y.w;
}
void init(){
    for(int i=;i<=N;i++)parent[i]=i;
}
int find(int x){
    int r=x;
    while(parent[r]!=r)r=parent[r];
    int i=x;
    int j;
    while(i!=r){
        j=parent[i];
        parent[i]=r;
        i=j;
    }
    return r;
}
void Kruskal(){
    for(int i=;i<m;i++){
        int x=find(a[i].u);
        int y=find(a[i].v);
        if(x!=y){
            parent[x]=y;
            ans=ans+a[i].w;
        }
    }
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        init();
        if(m==&&n==)break;
        int sum=;
        ans=;
        for(int i=;i<m;i++){
            scanf("%d%d%d",&a[i].u,&a[i].v,&a[i].w);
            sum=sum+a[i].w;
        }
        sort(a,a+m,cmp);
        Kruskal();
        printf("%d\n",sum-ans);
    }
    return ;
}