COJ 1036小镇网（最小生成树prim和kruscal）

【数据结构】小镇网

Time Limit: 1000 ms Memory Limit: 65536 KB

Total Submit: 133 Accepted: 67

Description
农民约翰被选为他们镇的镇长！他其中一个竞选承诺就是在镇上建立起互联网，并连接到所有的农场。当然，他需要你的帮助。约翰已经给他的农场安排了一条高速的网络线路，他想把这条线路共享给其他农场。为了使花费最少，他想铺设最短的光纤去连接所有的农场。你将得到一份各农场之间连接费用的列表，你必须找出能连接所有农场并所用光纤最短的方案。每两个农场间的距离不会超过100000

Input
第一行： 农场的个数，N（3<=N<=100）。

第二行..结尾: 后来的行包含了一个N*N的矩阵,表示每个农场之间的距离。理论上，他们是N行，每行由N个用空格分隔的数组成，实际上，他们限制在80个字符，因此，某些行会紧接着另一些行。当然，对角线将会是0，因为不会有线路从第i个农场到它本身。

Output
只有一个输出，其中包含连接到每个农场的光纤的最小长度。

Sample Input
4

0 4 9 21

4 0 8 17

9 8 0 16

21 17 16 0

Sample Output
28

Hint
最小生成树

思路：就这两个算法，已经做过几道题，kruscal用两种方法去做，见如下：
Prim：

#include<iostream>
using namespace std;
int n,sum;
int map[101][101],d[101];
int min(int a,int b)
{
    return a<b?a:b;
}
void prim()
{
    int i,j,now,min1,min2;
    now=0;
    sum=0;
    for(i=1; i<n; i++)
    {
        d[now]=-1;
        min1=100000000;
        for(j=0; j<n; j++)
            if(now!=j&&d[j]>=0)
            {
                d[j]=min(d[j],map[now][j]);
                if(d[j]<min1)
                {
                    min1=d[j];
                    min2=j;
                }
            }
        now=min2;
        sum+= min1;
    }
    cout<<sum<<endl;
}
/*
int Prim()
{
    int i, j;
    int sum = 0;
    memset(dist,0,sizeof(dist));
    memset(used,0,sizeof(used));
    //以v0为起点
    for (i = 0; i < n; i++)
        dist[i] = map[0][i];
    used[0] = 1;
    for (j = 1; j <= n - 1; j++)//重复n-1次
    {
        int index = -1;
        int min_d = 0x0fffffff;//INT_MAX
        for (i = 0; i < n; i++)
            if (!used[i] && dist[i] < min_d)
            {
                min_d = dist[i];
                index = i;
            }
        if (index != -1)
        {
            used[index] = 1;
            sum += min_d;
            for (i = 0; i < n; i++)
                if (!used[i] && map[index][i] < dist[i])
                {
                    dist[i] = map[index][i];
                }
        }
    }
    return sum;
}
*/
int main()
{
    int i,j,m;
    while(cin>>n&&n)
    {
        for(i=0; i<n; i++)
        {
            d[i]=100000000;
            for(j=0; j<n; j++)
                map[i][j]=100000000;
        }
        for(i=0; i<n; i++)
            for(j=0; j<n; j++)
                cin>>map[i][j];
        prim();
    }
    return 0;
}

kruskal:

#include<iostream>
#include <algorithm>
using namespace std;
struct a
{
    int x,y;
    int w;
}e[10005];
int rank[101],father[101],sum;
bool cmp(a p,a q)
{
     return p.w<q.w;
}
int find(int x)
{
    return father[x]==x?x:find(father[x]);
}
void un(int x,int y,int w)
{
    if(x==y) return;
    if(rank[x]>rank[y]) father[y]=x;
    else
    {
        if(rank[x]==rank[y]) rank[y]++;
        father[x]=y;
    }
    sum+=w;
}
int main()
{
    int i,j,k,m,t;
    while(cin>>m&&m)
    {
        for(i=0;i<m;i++)
        {
            father[i]=i;
            rank[i]=0;
        }
        k=0;
        for(i=0;i<m;i++)
            for(j=0;j<m;j++)
            {
                cin>>e[k].w;
                e[k].x=i;
                e[k].y=j;
                k++;
            }
        sort(e,e+k,cmp);
        sum=0;
        for(i=0;i<k;i++) un(find(e[i].x),find(e[i].y),e[i].w);
        cout<<sum<<endl;
    }
    return 0;
}

第二种不用秩的做法……其实原理都一样，因为find函数确实强大到不需要用秩确定父子关系了……
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
#include<cmath>
#include<set>
#include<queue>
#include<vector>
#include<stack>
#include<ctime>
#include<cstdlib>
#define mem(a,b) memset(a,b,sizeof(a))
typedef long long ll;
using namespace std;
int f[102];
struct abc
{
    int u,v;
    int len;
} e[10002];
bool cmp(abc a, abc b)
{
    return a.len<b.len;
}
int find(int k)
{
    return f[k]==k?k:f[k]=find(f[k]);
}
int main()
{
    int n,a,i,j,k=0,sum=0;
    cin>>n;
    for(i=0;i<n;i++)
    {
        f[i]=i;
        for(j=0;j<n;j++)
        {
            cin>>a;
            if(i!=j)
            {
                e[k].u=i;
                e[k].v=j;
                e[k++].len=a;
            }
        }
    }
    sort(e,e+k,cmp);
    for(i=0,j=0;i<k&&j<n-1;i++)
    {
        int a1=find(e[i].u);
        int b1=find(e[i].v);
        if(a1==b1) continue;
        f[a1]=b1;
        sum+=e[i].len;
        j++;
    }
    cout<<sum<<endl;
    return 0;

}