POJ 2253 最小生成树的变形

Frogger
Time Limit: 1000MS

Memory Limit: 65536K
Total Submissions: 50439

Accepted: 16019
Description
Freddy Frog is sitting on a stone in the middle of a lake. Suddenly he notices Fiona Frog who is sitting on another stone. He plans to visit her, but since the water is dirty and full of tourists' sunscreen, he wants to avoid swimming and instead reach her by jumping. 
Unfortunately Fiona's stone is out of his jump range. Therefore Freddy considers to use other stones as intermediate stops and reach her by a sequence of several small jumps. 
To execute a given sequence of jumps, a frog's jump range obviously must be at least as long as the longest jump occuring in the sequence. 
The frog distance (humans also call it minimax distance) between two stones therefore is defined as the minimum necessary jump range over all possible paths between the two stones. 

You are given the coordinates of Freddy's stone, Fiona's stone and all other stones in the lake. Your job is to compute the frog distance between Freddy's and Fiona's stone. 
Input
The input will contain one or more test cases. The first line of each test case will contain the number of stones n (2<=n<=200). The next n lines each contain two integers xi,yi (0 <= xi,yi <= 1000) representing the coordinates of stone #i. Stone #1 is Freddy's stone, stone #2 is Fiona's stone, the other n-2 stones are unoccupied. There's a blank line following each test case. Input is terminated by a value of zero (0) for n. 
Output
For each test case, print a line saying "Scenario #x" and a line saying "Frog Distance = y" where x is replaced by the test case number (they are numbered from 1) and y is replaced by the appropriate real number, printed to three decimals. Put a blank line after each test case, even after the last one. 
Sample Input
2
0 0
3 4

3
17 4
19 4
18 5

0
Sample Output
Scenario #1
Frog Distance = 5.000

Scenario #2
Frog Distance = 1.414
Source
Ulm Local 1997



这题题目什么意思呢？反正我看了好久都没搞懂，看了各位大佬的题解才明白了！这只该死的青蛙，让我混了两个小时！！！讲一只男青蛙看到远处有个女青蛙，便想去拜♂访，然而毕竟去约会嘛，他又不想游泳，怕弄脏衣服，于是打算跳过去。路上有很多石头，这只青蛙可以跳到任意一个石头，如果足够强的话，可以直接蹦到女青蛙那儿。但现在要求的是：
青蛙每一条路都会有最大的一步，求所有路径中最大一步的最小值。
很明显Kruskal 算法比较合适，因为最后加入的那一条边就是最大边。
下面证明Kruscal 算法的可行性：
    我从小到大的顺序加入边，并不断搜索，第一个点和第二个点是否连通，如果没连通，很明显，不会出现我们想求的值。当加入某一条边l 时，恰好第一个点和第二个点连通，那么这条边就是我们想求的。因为如果后续再加入边，肯定会比之前刚好连通时的那条边l 大，不符合题意，所以我们求的边就是l.
以下是Kruskal 算法：
    #include<cstdio>
#include<algorithm>
#include<math.h>
#include<cstring>
#define MAX 205
#define MAXN 40005
struct routes{
    int a;
    int b;
    int dis;
};
int n;
int pre[MAX];
routes road[MAXN];
int x[MAX],y[MAX]; //分别存第i个结点的坐标 
int find(int root)
{
    int son,temp;
    son=root;
    while(root!=pre[root])
        root=pre[root];
    while(son!=root)
    {
        temp=pre[son];
        pre[son]=root;
        son=temp;
    }
    return root;
}
bool cmp(const routes a,const routes b)
{
    return a.dis <b.dis ;
}
int kruskal(int rootnum)
{
    std::sort(road,road+rootnum,cmp);
    int i=0;
    int ans=0;
    for(i=0;i<rootnum;i++)
    {
        int roota=find(road[i].a );
        int rootb=find(road[i].b );
        if(roota!=rootb)
        {
            pre[rootb]=roota;
            if(find(1)==find(2))
            {
                ans=road[i].dis ;
                return ans; 
            }
        }
    }
}
int main()
{
    int i,j;
    int ans;
    int cases=1;
    while(scanf("%d",&n)!=EOF){
        if(n==0)
            break;
        for(i=1;i<=n;i++)
            {
                scanf("%d%d",x+i,y+i);
                pre[i]=i;
            }
        int index=0;
        for(i=1;i<=n;i++)
            for(j=i+1;j<=n;j++)
            {
                road[index].a =i;
                road[index].b =j; //任意一条边 
                road[index++].dis =(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]);
            }
        ans=kruskal(index);
        printf("Scenario #%d\n",cases++);
        printf("Frog Distance = %.3f\n\n",(double)sqrt((double)ans));
        memset(road,0,sizeof(road));//还原路径 
    }
    return 0;
}