最小生成树算法

1.wormhole

#include<iostream>
#include<cstdio>
#include<queue>
#include<stack>
#include<cstring>
#include<algorithm>

using namespace std;
#define INF 99999999
#define N 501
int g[N][N];
int d[N];
int n,m,w;

bool BELLMAN_FORD()
{
    for (int i=0;i<n;i++)
        d[i]=INF;
    d[0]=0;
    for (int k=0;k<n-1;k++)
        for (int i=0;i<n;i++)
            for (int j=0;j<n;j++)
                if ((g[i][j]!=INF)&&(d[j]>d[i]+g[i][j]))
                    d[j]=d[i]+g[i][j];
    for (int i=0;i<n;i++)
        for (int j=0;j<n;j++)
            if ((g[i][j]!=INF)&&(d[j]>d[i]+g[i][j])) return false;
    return true;
}
int main()
{
    int _count;
    scanf("%d",&_count);
    for (int q=0;q<_count;q++)
    {
        scanf("%d%d%d",&n,&m,&w);
        for (int i=0;i<n;i++)
            for (int j=0;j<n;j++)
                g[i][j]=INF;
        int u,v,t;
        for (int i=0;i<m;i++)
        {
            scanf("%d%d%d",&u,&v,&t);
            if (g[u-1][v-1]>t) g[u-1][v-1]=t;
            if (g[v-1][u-1]>t) g[v-1][u-1]=t;
        }
        for (int i=0;i<w;i++)
        {
            scanf("%d%d%d",&u,&v,&t);
            g[u-1][v-1]=-t;
        }
        if (BELLMAN_FORD()) printf("NO
");
        else printf("YES
");
    }
    return 0;
}

 2.Truck History

#include<iostream>
#include<cstdio>

using namespace std;

#define N 2005
#define INF 99999999

int g[N][N];
char s[N][7];
int n,count,result;
int inq[N];

void prim()
{
    result=0;
    int u,v,w;
    /*for (int i=0;i<n;i++) inq[i]=0;
    inq[0]=1;
    count=n-1;
    while (count--){
        w=INF;
        for (int i=0;i<n;i++)
        {
            if (inq[i]==1)
                for (int j=0;j<n;j++)
                    if ((inq[j]==0)&&(g[i][j]<w))
                    {
                        v=j;
                        w=g[i][j];
                    }
        }
        inq[v]=1;
        result+=w;
    }*/
//关于如何优化朴素prim：如果想用邻接矩阵加数组，则上面的算法在每一次循环时要对队列里所有点的邻接边求最小值，会产生大量重复计算，只需要在每次加入节点时求其邻接边的最小值再判断是否替换即可
    for (int i=1;i<n;i++) inq[i]=g[0][i];
    inq[0]=0;
    for (int i=1;i<n;i++)
    {
        int min = INF;
        v = 0;
        for (int j=1;j<n;j++)
            if ((inq[j]<min)&&(inq[j]!=0))
            {
                min=inq[j];
                v=j;
            }
        result+=min;
        inq[v]=0;
        for (int j=1;j<n;j++)
            if (g[v][j]<inq[j]) inq[j]=g[v][j];
    }

}    


int main()
{
    while (scanf("%d",&n)&&n)
    {
        for (int i=0;i<n;i++)
            for (int j=0;j<n;j++)
                g[i][j]=INF;
        for (int i=0;i<n;i++)
        {
            scanf("%s",&s[i]);
            for (int j=0;j<i;j++)
            {
                count=0;
                for (int k=0;k<7;k++)
                    if (s[j][k]!=s[i][k]) count++;
                g[i][j]=g[j][i]=count;
            }
        }
        prim();
        printf("The highest possible quality is 1/%d.
",result);
    }
    return 0;
}

 3.POJ 3723 Conscription

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>

using namespace std;

#define N 10005
#define E 50005
#define INF 99999999

struct Edge{
    int u,v;
    int w;
    //friend bool operator< (Edge e1,Edge e2)
    //    return e1.w > e2.w;
}edge[E];
int n,m,r,result;
int pi[2*N];
bool _cmp(Edge e1,Edge e2)
{
    return e1.w > e2.w;
}

void MAKE_SET()
{
    for (int i=0;i<(m+n);i++)
        pi[i]=i;
}

int FIND(int u)
{
    if (pi[u]==u) return u;
    else return (FIND(pi[u]));
}

void UNION(int u,int v)
{
    int _min = pi[u]>pi[v]?pi[v]:pi[u];
    pi[u]=pi[v]=_min;
}


void kruskal()
{
    sort(edge,edge+r,_cmp);
    MAKE_SET();
    for (int i=0;i<r;i++)
    {
        int u=edge[i].u,v=edge[i].v,w=edge[i].w;
/**************/
        u=FIND(u);
        v=FIND(v);
        if (u!=v)
/**************/
//if (FIND(u)!=FIND(v))
//注意：UNION不只是对点的操作，是要合并两棵树
//如果按注释掉的方法写，则下面应该UNION(FIND(u),FIND(v));
        {
            UNION(u,v);
            result-=w;
        }
    }
}

int main()
{
    int count;
    scanf("%d",&count);
    while (count--)
    {
        scanf("%d%d%d",&n,&m,&r);
        for (int i=0;i<r;i++)
        {
            int v;
            scanf("%d%d%d",&edge[i].u,&v,&edge[i].w);
            edge[i].v=v+n;
        }
        result = 10000*(n+m);
        kruskal();
        printf("%d
",result);
    }
    return 0;
}

 4.POJ 2031 Building a space station

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>

using namespace std;

#define N 2000
#define INF 99999999.0
struct Node{
    double x,y,z,r;
}node[N];
double g[N][N],result,low[N],vis[N];
int n;

void prim()
{
    for (int i=1;i<n;i++)
        low[i]=g[0][i];
    low[0]=-1;
    for (int i=1;i<n;i++)
    {
        double min=INF;
        int v=0;
        for (int j=1;j<n;j++)
        {
            if ((low[j]<min)&&(low[j]!=-1))
            {
                min=low[j];
                v=j;
            }
        }
        result+=min;
        low[v]=-1;
        for (int j=1;j<n;j++)
            if (g[v][j]<low[j]) low[j]=g[v][j];
    }
}
int main()
{
    while (scanf("%d",&n)&&n)
    {
        for (int i=0;i<n;i++)
        {
            low[i]=INF;
            for (int j=0;j<n;j++)
                g[i][j]=INF;
        }
        double x1,y1,z1,r1,x2,y2,z2,r2;
        for (int i=0;i<n;i++)
            scanf("%lf%lf%lf%lf",&node[i].x,&node[i].y,&node[i].z,&node[i].r);
        for (int i=0;i<n;i++)
            for (int j=0;j<n;j++)
            {
                x1=node[i].x;
                x2=node[j].x;
                y1=node[i].y;
                y2=node[j].y;
                z1=node[i].z;
                z2=node[j].z;
                r1=node[i].r;
                r2=node[j].r;
                double temp = sqrt(pow(x1-x2,2)+pow(y1-y2,2)+pow(z1-z2,2))-(r1+r2);
                if (temp > pow(10.0,-6)) g[i][j]=g[j][i]=temp;
                else g[i][j]=g[j][i]=0;
            }
        result = 0;
        prim();
        printf("%.3lf
",result);
    }
    return 0;
}