H - Highways - poj 1751（prim）

某个地方政府想修建一些高速公路使他们每个乡镇都可以相同通达，不过以前已经修建过一些公路，现在要实现所有的联通，所花费的最小代价是多少？（也就是最小的修建长度），输出的是需要修的路，不过如果不需要修建就什么都不输出。

分析：构建一个完全图，使用krusal进行一些简单优化不知道可以不，试一下吧

已经T成狗了

下面是TLE的krusal代码

******************************************************************************

 

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#include<math.h>
#include<vector>
#include<algorithm>
using  namespace std;

#define maxn 1005

int f[maxn];
struct node{
     int u, v; double len;
    friend  bool  operator < (node a, node b){
         return a.len > b.len;
    }
};
struct point{ int x, y;}p[maxn], ans[maxn];
double Len(point a, point b){
     int x = a.x-b.x;
     int y = a.y-b.y;

     return sqrt(x*x+y*y);
}
int Find( int x)
{
     if(f[x] != x)
        f[x] = Find(f[x]);
     return f[x];
}
int Union( int x,  int y)
{
    x = Find(x);
    y = Find(y);

     if(x != y)
    {
        f[x] = y;
         return  1;
    }

     return  0;
}
bool cmp(point a, point b)
{
     if(a.x != b.x)
         return a.x < b.x;
     return a.y < b.y;
}
int main()
{
     int N;

    scanf( " %d ", &N);

     int M, u, v, t= 0, k= 0;
    node s;
    priority_queue<node> Q;

     for(s.u= 1; s.u<=N; s.u++)
    {
        f[s.u] = s.u;
        scanf( " %d%d ", &p[s.u].x, &p[s.u].y);
         for(s.v= 1; s.v<s.u; s.v++)
        {
            s.len = Len(p[s.u], p[s.v]);
            Q.push(s);
        }
    }

    scanf( " %d ", &M);

     while(M--)
    {
        scanf( " %d%d ", &u, &v);
        t += Union(u, v);
    }

     while(Q.size() && t < N)
    {
        s = Q.top();Q.pop();

         if(Union(s.u, s.v) ==  1)
        {
            t +=  1;
            ans[k].x = s.v;
            ans[k++].y = s.u;
        }
    }

     for( int i= 0; i<k; i++)
        printf( " %d %d\n ", ans[i].x, ans[i].y);

     return  0;
}

****************************************************************************

下面换成prim试一下吧

终于A掉了，使用优先队列会造成超内存

 

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#include<math.h>
#include<vector>
#include<algorithm>
using  namespace std;

#define maxn 1005
#define oo 0xfffffff

double G[maxn][maxn];
struct point{ int x, y;}p[maxn], ans[maxn];
struct node{ int v; double len;}dist[maxn];
double Len(point a, point b){
     int x = a.x-b.x;
     int y = a.y-b.y;

     return sqrt(x*x+y*y);
}

void prim( int N)
{
     int i, use[maxn] = { 0,  1};

     for(i= 1; i<=N; i++)
        dist[i].v =  1, dist[i].len = G[ 1][i];

     for(i= 1; i<N; i++)
    {
         int k= 0; double Min = oo;

         for( int j= 1; j<=N; j++)
        {
             if(!use[j] && Min > dist[j].len)
                Min = dist[j].len, k = j;
        }

        use[k] =  true;

         for( int j= 1; j<=N; j++)
        {
             if(!use[j] && k!=j && G[k][j] < dist[j].len)
                dist[j].len = G[k][j], dist[j].v = k;
        }
    }
}

int main()
{
     int i, j, N, M, u, v;

    scanf( " %d ", &N);

     for(i= 1; i<=N; i++)
        scanf( " %d%d ", &p[i].x, &p[i].y);

     for(i= 1; i<=N; i++)
     for(j= 1; j<i; j++)
    {
        G[j][i] = G[i][j] = Len(p[i], p[j]);
    }

    scanf( " %d ", &M);

     while(M--)
    {
        scanf( " %d%d ", &u, &v);
        G[u][v] = G[v][u] = - 1;
    }

    prim(N);

     for( int i= 2; i<=N; i++)
    {
         if(dist[i].len >  0)
            printf( " %d %d\n ", i, dist[i].v);
    }

     return  0;
}