POJ 2253 Frogger



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

问题描述：这道题的意思其实就是给你一系列的坐标，然后让你求出从第一个坐标到达第二个坐标的路径中（该路径包含若干坐标点），邻接的坐标点之间距离的最大值（即Frog Distance）。很明显，该问题并非求两点之间的最短路径。

题解报告：这道题其实最简单的方式就是用prim算法，不断地添加节点，直到将目标节点也添加进去为止。其实在添加节点的过程中，Frog Distance是在不断变大的（当然也可能不变）。这其实是整道题最值得深入思考的地方。开始当从网上得知要用prim算法的时候我感到非常的不解。因为我无法判断当前形成的树中邻接节点的最大值是否在源节点和目标节点相连的路径上。下面用反证法证明这个结论：假设Frog Distance不在源节点和目标节点的路径上，则源节点和目标节点和任意边的长度都小于Frog Distance。这与prim算法不断添加最小边的原则矛盾。所以最小生成树的Frog Distance一定在源节点和目标节点的路径上。

其实整个算法的过程是这样的：开始的时候我们可以认为各点的Frog Distance都是各点到源节点的距离。然后我们选出一个最小的Frog Distance的节点添加到已找到Frog Distance的节点集合v中。此时有必要刷新一下其余节点到集合v 的距离，因为它们可能可以通过新增加的节点来减小自己的Frog Distance。接下来，我们继续将距离集合v最小的节点添加到v当中。此时新增加的边的大小完全可以小过当前的Frog Distance，但到达源节点的路径上必定会通过Frog Distance所在的边，证明在开始解释了。当新增加的边大于当前的Frog Distance的时候自然要跟新Frog Distance。然后不断重复此过程，直到找到要找到节点。显然，在不断增加边的过程中Frog Distance是不断变大的。所以不能在生成所有节点的最小生成树之后才输出Frog Distance，因为此时明显较正确答案要大。

可能是我的表达能力有点差，总感觉说不清楚自己的想法。对于prim，Dijkstra这些算法来说，操作还是比较简单的。但是如果要深入地去思考证明还是有点搞脑子的。不多说了，还是直接上源代码吧，相信程序猿还是对代码更容易理解

    #include <iostream>  
    #include <cstdio>  
    #include <cstring>  
    #include <cmath>  
    using namespace std;  
    const int MAX=205;  
    const int inf=100000000;  
    struct p  
    {  
        int x;  
        int y;  
    }P[MAX];  
      
    double Dis[MAX][MAX],Low[MAX];  
    int Vis[MAX],N;  
      
    double Solve(int src,int end)  
    {  
        double Ans=0;  
        memset(Vis,0,sizeof(Vis));  
        for(int i=1;i<N;i++)  
        Low[i]=Dis[0][i];  
        Low[src]=0;  
        for(int i=1;i<N;i++)  
        {  
            double Min=(double)inf;  
            int temp;  
            for(int j=1;j<N;j++)  
            if(!Vis[j]&&Min>Low[j])  
            {  
                temp=j;  
                Min=Low[j];  
            }  
            Ans=Ans>Min?Ans:Min;  
            if(temp==end) return Ans;  
            Vis[temp]=1;  
            for(int j=1;j<N;j++)  
            if(!Vis[j]&&Dis[temp][j]<Low[j])  
            Low[j]=Dis[temp][j];  
        }  
    }  
      
    int main()  
    {  
       //freopen("input.txt","r",stdin);  
        int Case=1;  
        while(scanf("%d",&N),N)  
        {  
            if(!N) break;  
            for(int i=0;i<N;i++)  
            scanf("%d%d",&P[i].x,&P[i].y);  
            for(int i=0;i<N;i++)  
            for(int j=0;j<N;j++)  
            Dis[i][j]=sqrt((double)((P[i].x-P[j].x)*(P[i].x-P[j].x)+(P[i].y-P[j].y)*(P[i].y-P[j].y)));  
            double ans=Solve(0,1);  
            printf("Scenario #%d\nFrog Distance = %.3lf\n\n",Case++,ans);  
      
        }  
        return 0;  
    }