POJ 1751 Highways

题意：在一张图上有n个点，已知每个点的坐标，部分点已经连接，求将图上所有点连通需要的最短的距离

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

思路：最小生成树，并查集将已经存在路径的节点进行缩点，在对其他的部分求最小树

注意点：无

以下为AC代码：

Run ID	User	Problem	Result	Memory	Time	Language	Code Length	Submit Time
14176887	luminous11	1751	Accepted	8976K	719MS	C++	4309B	2015-05-09 10:38:42

/* 
***********************************************
*# @Author  : Luminous11 (573728051@qq.com)
*# @Date    : 2015-04-20 23:10:07
*# @Link    : http://blog.youkuaiyun.com/luminous11                          
*********************************************** 
*/

#include <algorithm>
#include <iostream>
#include <climits>
#include <iomanip>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <deque>
#include <list>
#include <map>
#include <set>
//#include <unordered_map>
//#include <unordered_set>
#define pb push_back
#define ll long long
#define ull unsigned long long
#define all(x) (x).begin(), (x).end()
#define READ(f) freopen(f, "r", stdin)
#define WRITE(f) freopen(f, "w", stdout)
#define clr(a, v) memset( a , v , sizeof(a) )
#define RS(s) scanf ( "%s", s )
#define RDI(a) scanf ( "%d", &a )
#define RDII(a, b) scanf ( "%d%d", &a, &b )
#define RDIII(a, b, c) scanf ( "%d%d%d", &a, &b, &c )
#define PL() printf ( "\n" )
#define PI(a) printf ( "%d", a )
#define PIL(a) printf ( "%d\n", a )
#define PSL(s) printf ( "%s\n", s )
#define PII(a,b) printf ( "%d %d", a, b )
#define PIIL(a,b) printf ( "%d %d\n", a, b )
#define PIII(a,b,c) printf ( "%d %d %d", a, b, c )
#define PIIIL(a,b,c) printf ( "%d %d %d\n", a, b, c )
#define rep(i,m,n) for ( int i = m; i <  n; i ++ )
#define REP(i,m,n) for ( int i = m; i <= n; i ++ )
#define dep(i,m,n) for ( int i = m; i >  n; i -- )
#define DEP(i,m,n) for ( int i = m; i >= n; i -- )
#define repi(i,m,n,k) for ( int i = m; i <  n; i += k )
#define REPI(i,m,n,k) for ( int i = m; i <= n; i += k )
#define depi(i,m,n,k) for ( int i = m; i >  n; i += k )
#define DEPI(i,m,n,k) for ( int i = m; i >= n; i -= k )
#pragma comment ( linker, "/STACK:10000000,10000000" )
using namespace std;
template <class T>
inline bool RD ( T &ret )
{
    char c;
    int sgn;
    if ( c = getchar(), c ==EOF )return 0; //EOF
    while ( c != '-' && ( c < '0' || c > '9' ) ) c = getchar();
    sgn = ( c == '-' ) ? -1 : 1;
    ret = ( c == '-' ) ? 0 : ( c - '0' );
    while ( c = getchar() , c >= '0' && c <= '9' ) ret = ret * 10 + ( c - '0' );
    ret *= sgn;
    return 1;
}
inline void PD ( int x )
{
    if ( x > 9 ) PD ( x / 10 );
    putchar ( x % 10 + '0' );
}
const double eps = 1e-10;
// const double pi = acos(-1.0);
const int dir[4][2] = { 1,0, -1,0, 0,1, 0,-1 };
struct node{
    int x, y, cnt;
    node(){}
    node( int _x, int _y ) : x(_x), y(_y) {}
    node( int _x, int _y, int _cnt ) : x(_x), y(_y), cnt(_cnt) {}
};
struct edge{
    int u, v;
    double w;
    edge(){}
    edge( int _u, int _v, double _w ) : u(_u), v(_v), w(_w) {}
};
int m, n;
int cnt;
node num[751];
edge g[562501];
int fa[751];
bool operator< ( const edge &a, const edge &b )
{
    return a.w < b.w;
}
inline edge calc ( int i, int j )
{
    int x = num[i].x - num[j].x;
    int y = num[i].y - num[j].y;
    double dis = sqrt ( (double)(x * x + y * y) );
    return edge ( i, j, dis );
}
int find ( int x )
{
    if ( x == fa[x] ){
        return x;
    }
    else{
        fa[x] = find ( fa[x] );
        return fa[x];
    }
}
bool merge ( int u, int v )
{
    int x = find ( u );
    int y = find ( v );
    if ( x != y ){
        if ( rand() & 1 )
            fa[x] = y;
        else
            fa[y] = x;
        return true;
    }
    return false;
}
void init()
{
    cnt = 0;
    rep ( i, 0, 751 ) fa[i] = i;
    clr ( g, 0 );
    clr ( num, 0 );
}
int main()
{
    srand((unsigned)time(NULL));
    int x, y;
    int a, b;
    while ( RDI ( m ) != EOF ){
        init();
        REP ( i, 1, m ){
            RDII ( x, y );
            num[i] = node ( x, y );
        }
        REP ( i, 1, m ){
            REP ( j, i + 1, m ){
                g[cnt++] = calc ( i, j );
            }
        }
        sort ( g, g + cnt );
        RDI ( n );
        rep ( i, 0, n ){
            RDII ( a, b );
            merge ( a, b );
        }
        rep ( i, 0, cnt ){
            if ( merge ( g[i].u, g[i].v ) ){
                PIIL ( g[i].u, g[i].v );
            }
        }
    }
    return 0;
}