杭电1102Constructing Roads（kruskal）（最小生成树）

Constructing Roads

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 18273    Accepted Submission(s): 6979

Problem Description

There are N villages, which are numbered from 1 to N, and you should build some roads such that every two villages can connect to each other. We say two village A and B are connected, if and only if there is a road between A and B, or there exists a village C such that there is a road between A and C, and C and B are connected. 

We know that there are already some roads between some villages and your job is the build some roads such that all the villages are connect and the length of all the roads built is minimum.

 

Input

The first line is an integer N (3 <= N <= 100), which is the number of villages. Then come N lines, the i-th of which contains N integers, and the j-th of these N integers is the distance (the distance should be an integer within [1, 1000]) between village i and village j.

Then there is an integer Q (0 <= Q <= N * (N + 1) / 2). Then come Q lines, each line contains two integers a and b (1 <= a < b <= N), which means the road between village a and village b has been built.

 

Output

You should output a line contains an integer, which is the length of all the roads to be built such that all the villages are connected, and this value is minimum. 

 

Sample Input

  
  

   
   3
0 990 692
990 0 179
692 179 0
1
1 2
  
  

 

Sample Output

  
  

   
   179
  
  

 

题目大意：

给出n个村子.

按照样例说明：

3个村子1 2 3 三个村庄

1 到1的距离是0 1到2的距离是990 0到3的距离是692

2到1的距离是990 依次类推~

然后给出q条已经连通的路（不用计算距离了）

所谓最小生成树的kruskal算法就是结构体排序加上并查集的应用（也可以理解为贪心并查集）

要按照两点距离的长短进行排序（当然是越小越好）

然后按照排序后的顺序 判断如果两个点已经连通了就继续 否则连通两个点并且加上连通的距离就可以了

这里贴上ac代码和详解

#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
int f[121212];
struct asdf
{
    int x,y,dis;
}a[121212];
int n,q;
int cmp(asdf a,asdf b)//结构体排序
{
    return a.dis<b.dis;
}
void init(int n)//并查集数组初始化
{
    for(int i=0;i<n;i++)
    {
        f[i]=i;
    }
}
int find(int a)//find操作
{
    int r=a;
    while(f[r]!=r)
    r=f[r];
    return r;
}
void merge(int a,int b)//连通操作
{
    int A,B;
    A=find(a);
    B=find(b);
    if(A!=B)
    f[B]=A;
}
int main()
{
    while(~scanf("%d",&n))
    {
        int cont=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                int k;
                scanf("%d",&k);
                a[cont].x=i;
                a[cont].y=j;
                a[cont].dis=k;
                cont++;
            }
        }
        init(n);
        int q;
        scanf("%d",&q);
        for(int i=0;i<q;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            x--;
            y--;
            int a=find(x);
            int b=find(y);
            f[a]=b;
        }
        int output=0;
        sort(a,a+cont,cmp);
        /*for(int i=0;i<cont;i++)
        {
            printf("%d %d %d\n",a[i].x,a[i].y,a[i].dis);
        }*/
        for(int i=0;i<cont;i++)
        {
            if(find(a[i].x)!=find(a[i].y))//如果两个点没有连通
            {
                merge(a[i].x,a[i].y);//连通并且加上耗费的距离
                output+=a[i].dis;
            }
        }
        printf("%d\n",output);
    }
}