POJ 1861-Network（最小生成树-Kruskal）

Network

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 16043		Accepted: 6360		Special Judge

Description

Andrew is working as system administrator and is planning to establish a new network in his company. There will be N hubs in the company, they can be connected to each other using cables. Since each worker of the company must have access to the whole network,
each hub must be accessible by cables from any other hub (with possibly some intermediate hubs). 

Since cables of different types are available and shorter ones are cheaper, it is necessary to make such a plan of hub connection, that the maximum length of a single cable is minimal. There is another problem — not each hub can be connected to any other one
because of compatibility problems and building geometry limitations. Of course, Andrew will provide you all necessary information about possible hub connections. 

You are to help Andrew to find the way to connect hubs so that all above conditions are satisfied. 

Input

The first line of the input contains two integer numbers: N - the number of hubs in the network (2 <= N <= 1000) and M - the number of possible hub connections (1 <= M <= 15000). All hubs are numbered from 1 to N. The following M lines contain information about
possible connections - the numbers of two hubs, which can be connected and the cable length required to connect them. Length is a positive integer number that does not exceed 106. There will be no more than one way to connect two hubs. A hub cannot
be connected to itself. There will always be at least one way to connect all hubs.
Output

Output first the maximum length of a single cable in your hub connection plan (the value you should minimize). Then output your plan: first output P - the number of cables used, then output P pairs of integer numbers - numbers of hubs connected by the corresponding
cable. Separate numbers by spaces and/or line breaks.
Sample Input

4 6
1 2 1
1 3 1
1 4 2
2 3 1
3 4 1
2 4 1

Sample Output

1
4
1 2
1 3
2 3
3 4

Source

Northeastern Europe 2001, Northern Subregion

题目意思：

公司要搭建一个网络，给出N个集线器，集线器之间通过M条线连接起来。由于要通过集线器访问网络，所以每个集线器都要能通过网线访问到其他的集线器（可以通过其它集线器来连接）。网线越短越便宜，求一个设计方案，使得最长的单根网线是所有方案中最校的。

解题思路：

最小生成树-Kruskal。

给定N个点，M条边，将N个点连接起来构成无向图。

求最小生成树中的最长边、最小生成树中的边的数目和这些边对应的两个端点。

不得不说呀喂！什么叫Special Judge?就是问题有多个答案，而你只需要输出其中一种正确答案就行。

示例答案是错的，是错的，错的。。（阿阿阿...摔！）

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>
#define MAXN 1010
#define INF 0xfffffff//0X代表16进制，后面是数字，十进制是4294967295
using namespace std;
int cost[MAXN][MAXN],dis[MAXN],pre[MAXN],n,m,cnt,cnd,c;
int x[MAXN],y[MAXN];
bool used[MAXN];//标识是否使用过

struct edge
{
int u,v,cost;
};
bool cmp(const edge &e1,const edge &e2)
{
return e1.cost<e2.cost;
}
edge es[MAXN];
int V,E;//顶点数和边数

int set_find(int x)
{
while(x!=pre[x])
x=pre[x];
return x;
}
bool unite(int p,int q)
{
p=set_find(p);
q=set_find(q);
if(p!=q)
{
pre[p]=q;
return true;
}
return false;
}
bool same(int x,int y)
{
return set_find(x)==set_find(y);
}
void init_union_find(int n)
{
for(int i=0; i<=n; i++)
pre[i]=i;
}
void kruskal()
{
sort(es,es+m,cmp);//按照edge.cost的顺序升序排列
init_union_find(V);//并查集初始化
//int res=0;
int Max=-1;
for(int i=0; i<m; ++i)
{
edge e=es[i];
if(!same(e.u,e.v))//不是圈
{
unite(e.u,e.v);
//res+=e.cost;
x[c]=e.u,y[c++]=e.v;
Max=max(Max,e.cost);
}
}
cout<<Max<<endl;
cout<<c<<endl;
for(int i=0; i<c; ++i)
cout<<x[i]<<" "<<y[i]<<endl;
}

int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
while(cin>>n>>m)
{
memset(x,0,sizeof(x));
memset(y,0,sizeof(y));
memset(dis,0,sizeof(dis));
memset(es,0,sizeof(edge)*MAXN);//注意初始化清空
for(int i=0; i<m; i++)
cin>>es[i].u>>es[i].v>>es[i].cost;
c=0;
V=n;
E=n*n;
kruskal();
}
return 0;
}
/*
5 8
1 2 5
1 4 2
1 5 1
2 3 6
2 4 3
3 4 5
3 5 4
4 5 6

4 6
1 2 1
1 3 1
1 4 2
2 3 1
3 4 1
2 4 1*/