D - Constructing Roads

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

 

思路：

这还是一道最小生成树的问题，我们可以用kruskal算法来写，即运用并查集的思想解决，我们先将所有的边存入结构体数组中，要存入起始点终点和权重，然后我们将结构体按权重从小到大排序，遍历所有边，如果这条边的两点的父节点不同，则合并成一个点，并把权重加入和中，否则则已合并成一个点，跳过。遍历完所有的边后，输出和即可。

这道题主要是题目输入方面比较难理解，理解了输入用kruskal算法来做就比较简单了

代码

#include <iostream>

#include <cstdio>

#include <fstream>

#include <algorithm>

#include <cmath>

#include <deque>

#include <vector>

#include <queue>

#include <string>

#include <cstring>

#include <map>

#include <stack>

#include <set>

using namespace std;

int father[100001];

struct node{//创建结构体

       int u,v, c;

}x[100005];

bool cmp(node a,node b)//重构排序方法

{

       return a.c<b.c;//以权重从小到大排序

}

int fin(int t)//查集

{

    if(father[t]!=t)

    father[t]=fin(father[t]);

    return father[t];

}

void unionn(int r1,int r2)//并集

{

    father[r2]=r1;

}

int main()

{

       int n;

       scanf("%d\n",&n);

       memset(father,0,sizeof(father));

       int m=1;

       for(int i=1;i<=n;i++)//输入

       {

              for(int j=1;j<=n;j++)

              {

                     int t;

                     cin>>t;

                     if(t!=0)

                     {

                            x[m].u=i;

                            x[m].v=j;

                            x[m].c=t;

                            m++;

                     }

              }

       }

       m--;

       sort(x+1,x+m+1,cmp);//把边排序

       for(int i=1;i<=n;i++)

       {

              father[i]=i;//初始化父节点

       }

       int ans=0;//用于记录和

       int q;

       cin>>q;

       for(int i=1;i<=q;i++)

       {

              int k,p;

              cin>>k>>p;

              int a=fin(k);

              int b=fin(p);

              if(a!=b)//判断是否已经联通

              {

                     unionn(a,b);//并集

              }

       }

       for(int i=1;i<=m;i++)

       {

              int a=fin(x[i].u);

              int b=fin(x[i].v);

              if(a!=b)//判断是否已经联通

              {

                     ans+=x[i].c;//加上

                     unionn(a,b);//并集

              }

       }

       cout<<ans<<endl;//输出

}