HDOJ 1102

题目大意：

输入N表示现存在的村庄数目，接下来输入N*N规模的邻接矩阵来表示村庄间道路的信息，之后输入Q表示目前已存在的道路数目，随着输入Q条已存在的道路。求出使得所有村庄畅通的最.小代价。

算法思想：

1.新建一个邻接矩阵存储图的信息。

2.接着，将已经存在的道路的代价置为0，因为这样使得在最小生成树中对已存在的道路不产生代价。

3.用一个Edge的结构体数组存储所有的边。

4.将所有的边按权值非递减的顺序排序。

5.更具克鲁斯卡尔算法产生最小生成树计算最小的花费代价。

代码如下：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN=5500;
int G[105][105];//存储图的邻接矩阵
/*边结构*/
typedef struct {
    int start;
    int end;
    int value;
}Edge;
Edge road[MAXN];
/*排序时用的比较函数*/
bool cmp(Edge a,Edge b){
    if(a.value<b.value) return true;
    return false;
}
/*顶点表*/
int node[110];
/*并查集函数*/
int Find_set(int n){
    if(node[n]==-1) return n;
    return node[n]=Find_set(node[n]);
}
/*合并两棵树*/
bool Merge(int a,int b){
    int r1=Find_set(a);
    int r2=Find_set(b);
    if(r1==r2) return false;
    if(r1<r2) node[r2]=r1;
    if(r2<r1) node[r1]=r2;
    return true;
}
int Kruskal(int N,int M,int cost){
    int num=0;
    for(int i=0;i<M;i++){
        if(Merge(road[i].start,road[i].end)){
              num++;
              cost+=road[i].value;
        }
        if(num==N-1) break;
    }
   return cost;
}
int main(){
    int N,Q,k;//乡村数 已修道路数 总的道路数
    int a,b;//标记已建道路的两个端点
    long cost;//记录最小花费代价
    while(cin>>N){
        cost=0;
        k=0;
        memset(node,-1,sizeof(node));
        for(int i=1;i<=N;i++)//输入邻接矩阵
            for(int j=1;j<=N;j++)
                cin>>G[i][j];

        cin>>Q;
        for(int i=1;i<=Q;i++){//输入已经建好的道路信息
            cin>>a>>b;
            G[a][b]=0;//将修路代价置为0
            G[b][a]=0;
        }
        for(int i=1;i<=N;i++)//读取所有的道路信息
            for(int j=1;j<i;j++){
                road[k].start=i;
                road[k].end=j;
                road[k].value=G[i][j];
                k++;
            }
        sort(road,road+k,cmp);//对道路按边的权值进行排序
        cost=Kruskal(N,k,cost);//生成最小生成树
        cout<<cost<<endl;
    }
    return 0;
}