POJ 2253 - Frogger（dijkstra变形）

Frogger
Time Limit: 1000MS Memory Limit: 65536K
Total Submissions: 39545 Accepted: 12714
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

题意：
给出n个坐标，起点是第一个坐标，终点是最后一个坐标。
从起点到终点有若干条路径，frog distance是路径中最大的边。
求若干个frog distance中最小的那个。

解题思路：
相当于是使得路径上的边尽量的少，那么用dijkstra，对于每个源点，找离他最近的点（不是离起点最近的点），dis[i]维护的是起点到i中的最大的边的长度。
因为是使得边尽量的小，所以就用贪心的策略，从最小的边开始找，这样往下的边必然是递增的。

这里要注意，因为是用的double，所以交到poj的g++会出现精度上的问题，导致WA。

AC代码：

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<math.h>
using namespace std;
const double INF = 0x3f3f3f3;
const int maxn = 2e3+5;
double dis[maxn];
bool vis[maxn];
struct node{double x,y;}mp[maxn];
int n;
double dist(int a,int b)
{
    return sqrt((mp[a].x-mp[b].x)*(mp[a].x-mp[b].x)+(mp[a].y-mp[b].y)*(mp[a].y-mp[b].y));
}
void dijkstra()
{
    for(int i = 1;i <= n;i++)   dis[i] = INF,vis[i] = 0;
    dis[1] = 0;
    for(int i = 1;i <= n;i++)
    {
        double minn = INF;
        int index = -1;
        for(int j = 1;j <= n;j++)
            if(!vis[j] && dis[j] < minn) minn = dis[j],index = j;
        vis[index] = 1;
        if(index == 2|| index == -1)  break;
        for(int j = 1;j <= n;j++)
            if(!vis[j] && dis[j] > max(dis[index],dist(index,j)))
                dis[j] = max(dis[index],dist(index,j));
    }
}
int main()
{
    int flag = 1;
    while(cin>>n,n)
    {
        cin>>mp[1].x>>mp[1].y;
        cin>>mp[2].x>>mp[2].y;
        for(int i = 3;i <= n;i++)   cin>>mp[i].x>>mp[i].y;
        dijkstra();
        printf("Scenario #%d\n",flag++);
        printf("Frog Distance = %.3lf\n\n",dis[2]);
    }
    return 0;
}