poj1751 highways 最小生成树记录路径

题目链接：http://poj.org/problem?id=1751

题目大意：给出一些点，代表一个地方的坐标，还有给出一些已经修好的路，问还要修那几条，使得修的路的和长度最小。

分析：这道题，很明显最小生成树啊，可是有的地方已经修了，那也是最小生成树，那就在初始化完成后，让这两个地方距离为0就可以了，然后还需要记录路径。我开始是用kruskal做的，原因嘛，因为这个算法是加边的嘛，而prim是加点，但是呢，很明显这是一个稠密图，经验上来说，用prime更加贴切以一些。于是我就试了两种方法：

1，kruskal

这个添加的边是显然的，但要注意以下几点：
1，不必真正算出距离用sqrt，只需要相对距离es.cost=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
2,注意并查集的写法，我以前写的并查集没有路径压缩，多亏了ZJ学姐指点：
int find(int x){

    return par[x]==x?par[x]:par[x]=find(par[x]);

}

3，打印路径时可以在添加边时进行，不必开数组记录使用的边，等添加完后再打印。
4,另外，这个c++会TLE,g++400ms+,T到怀疑人生，如果有人知道为啥万望请一定告知！
code:

#include<cstdio>

#include<algorithm>

using namespace std;

const int MAX_V=800;

const int INF=99999999;

int V,par[MAX_V],x[MAX_V],y[MAX_V],visit[MAX_V],rank[MAX_V];

struct edge{int u,v,cost;}es[MAX_V*MAX_V];

/*double dis(double x1,double y1,double x2,double y2){

    return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));

}*/

bool cmp(edge x,edge y){

    return x.cost<y.cost;

}

int find(int x){

    return par[x]==x?par[x]:par[x]=find(par[x]);

}

int main(void){

    scanf("%d",&V);

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

        scanf("%d%d",x+i,y+i);

    int E=0;

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

        for(int j=1;j<i;++j){

            es[E].u=i;es[E].v=j;

            es[E++].cost=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);

            }

    int N;scanf("%d",&N);

    for(int i=0;i<N;++i){

        int a,b;scanf("%d%d",&a,&b);

            es[E].u=a;es[E].v=b;

            es[E++].cost=0;

    }

    for(int i=0;i<=V;++i)

        par[i]=i,rank[i]=0;

    sort(es,es+E,cmp);

    for(int i=0;i<E;++i){

        edge e=es[i];

        int x=find(e.u),y=find(e.v);

        if(x!=y){

            if(rank[x]<rank[y])par[x]=y;

            else {

                par[y]=x;

                if(rank[x]==rank[y])++rank[x];

            }

            if(e.cost)printf("%d %d\n",e.u,e.v);

        }

    }

    //print

    //printf("res:\n");

   /* for(int i=0;i<res;++i)

        if(es[visit[i]].cost)printf("%d %d\n",es[visit[i]].u,es[visit[i]].v);*/

}

prim

这个算法的思想是添加点，因此需要一个pre数组来记录，上一个点，稠密图用prim明显比较快。另外考虑到路径是双向的，故a[i][j]=a[j][i]=distance,另外如果有重边还要加判断，而kruskal就没这样的顾虑，因为它是按边的长短确定添加顺序的。

code:

#include<cstdio>

#define min(a,b) (a<b?a:b)

using namespace std;

const int MAXV=800,INF=99999999;

int cost[MAXV][MAXV],mincost[MAXV],prev[MAXV],V;

int x[MAXV],y[MAXV];

bool used[MAXV];

void prim(){

    for(int i=1;i<=V;++i){

        used[i]=false;

        mincost[i]=INF;

        prev[i]=1;

    }

    mincost[1]=0;

    int res=0;

    while(true){

        int v=-1;

        for(int u=1;u<=V;++u)

            if(!used[u]&&(v==-1||mincost[u]<mincost[v]))v=u;

        if(v==-1)break;

        used[v]=true;//这一个点，prev数组记录另一个点

        if(cost[v][prev[v]])printf("%d %d\n",v,prev[v]);

        for(int u=1;u<=V;++u)

           if(mincost[u]>cost[v][u]){

            mincost[u]=cost[v][u];

            prev[u]=v;//u是通过v更新的，因此prev[u]=v

           }

    }

}

int main(void){

     scanf("%d",&V);

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

        scanf("%d%d",x+i,y+i);

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

        for(int j=1;j<=i;++j){

           cost[i][j]=cost[j][i]=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);

    }

    int N;scanf("%d",&N);

    for(int i=0;i<N;++i){

        int a,b;scanf("%d%d",&a,&b);

           cost[a][b]=cost[b][a]=0;

    }

    prim();

}