Frogger Dijkstra

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

题目有毒，，，读了半天题，直到出动了百度翻译，我才明白要求的是什么。。。

青蛙从1号石头跳到2号石头上，有很多路径，所求的是在一条路径中，青蛙一次跳的最大距离，这个最大的距离在所有路径中的最大距离最小。。。其实还是最短路径问题，只不过是在最短路径中两个石头之间的最大距离，所以就要出动Dijkstra（其实我只会迪杰和弗洛伊德QAQ），在网上看到有用Floyd做的，但是我没看懂QAQ，还是专注迪杰吧。我们都知道迪杰里面有个距离数组d[]，里面存的是起点到每一点的最小距离，所以我们就对它下手，改变一下它的含义，让它存从起点到每一点，这其间两点的最大距离，最后的结果就是d[2]

#include <iostream>
#include <algorithm>
#include <cstdio>  
#include <cstring>  
#include <cmath>  

using namespace std;

const int N = 210;
const double INF = 1.0e10;

double g[N][N], d[N];
int x[N], y[N];   //石头的坐标
bool vis[N];
int n, m;

void Dijkstra()
{
    for(int i = 1; i <= n; i++) //初始化
    {
        d[i] = g[1][i];
        vis[i]  = 0;
    }
    vis[1] = 1;    //第一块石头已访问
    for(int i = 1; i <= n; i++)
    {
        int u = -1;
        double MIN = INF;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j] && d[j] < MIN)
            {
                u = j;
                MIN = d[j];
            }
        }
        if(u == -1) return;
        vis[u] = 1;
        for(int v = 1; v <= n; v++)
        {
            if(!vis[v] && max(d[u], g[u][v]) < d[v])  
                d[v] = max(d[u], g[u][v]);     //选取最短路径中石头的最大距离
        }
    }
}
int main()
{  
    for(int k = 1;; k++)
    {
        scanf("%d", &n);
        if(n == 0) break;
        for(int i = 1; i <= n; i++)
            scanf("%d%d", &x[i], &y[i]);
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
            {
                g[i][j] = g[j][i] = sqrt(1.0*(x[i]-x[j])*(x[i]-x[j]) + (y[i]-y[j])*(y[i]-y[j]));
            }
        Dijkstra();
        printf("Scenario #%d\n", k);
        printf("Frog Distance = %.3lf\n\n", d[2]);
    }
    return 0;  
}