【ZOJ 1942】【POJ 2253】 Frogger

Description

有一只叫做Freddy的青蛙坐在湖中央的一块石头上，突然间他发现另一只青蛙（她的名字是Fiona）坐在另一颗石头上。他想要过去找她，但是因为湖水很脏，到处充满着游客的防晒油，所以他决定用跳的，而不要用游的。
不妙的是Fiona的石头离他的距离超出他所能跳的范围。因此Freddy考虑利用其它的一些石头当作中继站，因此他就可以跳比较小的距离（或许要跳许多次）去找Fiona。
要这样子连续的跳，很明显的Freddy一次能跳的距离必须至少和这一串石头间的距离最大的距离一样。因此，介于石头间的蛙跳距离（frog distance，人类也称之为minmax distance）定义为要从Freddy所在的石头要跳到Fiona所在的石头的路径中，最小必须要跳的距离。
给你Freddy所在的石头、Fiona所在的石头，以及湖中所有其它石头的坐标，你的任务是算出介于Freddy和Fiona所在石头间的蛙跳距离。

Input

输入含有多组测试数据。每组测试资料的第一列有1个整数n，代表石头的数目（2 <= n <= 200）。接下来的n列每列有2个整数xi，yi（0 <= xi，yi <= 1000）代表第i颗石头的坐标。其中第一颗为Freddy所在的石头，第二颗为Fiona所在的石头，其它的n-2颗石头上则是空的。
每组测试数据后有一空白列，当n=0时代表输入结束。请参考Sample Input。

Output

对每一组测试数据，输出一列这是第几组测试数据，以及一列蛙跳距离。
每组测试数据后亦输出一空白列。请参考Sample Output。

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

HINT

Source

1.dijkstra

思路：dijkstra的变形。由于每条边的权值必为正，故开始时就对连接Freddy点(源点)的所有边进行松弛，得出最小dict[]值的点s，其值便已确定，以后不会再改变(这点很重要，证明)。然后以s为源点，继续这样的操作，直至Freddy这点的dict[]值被确定。最坏情况下，每条边都访问一次，时间复杂度为0(n^2)。

#include<iostream>
#include<cmath>
using namespace std;
const int Max = 205;
const int inf = 99999999;
 
struct{
    int x, y;
}sto[Max];
int n;
float edge[Max][Max], dict[Max];
bool vis[Max];
 
void init_data(){
    memset(vis, false, sizeof(vis));
    vis[0] = true;
    for(int i = 1; i < n; i ++)
        dict[i] = inf;
}
 
float find_edge(int u, int v){   //  计算两石头之间的距离，即边长。
     float dx = sto[u].x - sto[v].x;
     float dy = sto[u].y - sto[v].y;
     return sqrt(dx * dx + dy * dy);
}
 
float max(float a, float b){
    return a > b ? a : b;
}
 
void dijkstra(){   //  dij的变形。
    int now = 0, count = n - 1;
    while(count --){
        int k;
        float min_dis = inf;
        for(int i = 1; i < n; i ++)
            if(!vis[i]){
                if(dict[i] > max(dict[now], edge[i][now]))  //  取路程中最长的值。
                    dict[i] = max(dict[now], edge[i][now]);
                if(min_dis > dict[i]){
                    min_dis = dict[i];
                    k = i;
                }
            }
        if(k == 1)  return;  //  若sto[1]已被访问，则说明已得到sto[0]到sto[1]的最短路径。跳出。
        now = k;
        vis[k] = true;
    }
}
 
int main(){
    int t = 0;
    while(cin >> n && n != 0){
        init_data();
        for(int i = 0; i < n; i ++){
            cin >> sto[i].x >> sto[i].y;  //  这样Freddy的点默认为sto[0]，Fiona的点默认为sto[1]。
            for(int j = i - 1; j >= 0; j --){
                float val = find_edge(i, j);
                edge[i][j] = edge[j][i] = val;
            }
        }
        dijkstra();
        printf("Scenario #%d\nFrog Distance = %.3f\n\n", ++t, dict[1]);
    }
    return 0;
}

2.prim

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
pair<int ,int> a[200];            //保存n个石头的坐标
double lowcost[200],closet[200];//Prim算法必备，lowcost[i]表示i距离集合的最近距离，closet[i]表示i距离集合最近的点
double map[200][200];            //两点之间的距离
int main()
{
    int n;
    int k=1;
    while(cin>>n,n)
    {
        int i,j;
        for (i = 0 ;i < n ; i++ )
            cin>>a[i].first>>a[i].second;    //输入n个点的坐标，从0开始，也就是说题目编程求0-1的最小Frog Distance
        memset(lowcost,0,sizeof(lowcost));    //清零
        for ( i = 0 ; i < n ; i ++ )
        {
            for ( j = 0 ; j < n ; j ++ )
            {//求任意两点的距离，保存到map中
                map[i][j]=1.0*sqrt(pow(1.0*abs(a[i].first-a[j].first),2)+pow(1.0*abs(a[i].second-a[j].second),2));
            }
        }
        double ans=0.0;//所要求的答案，初始化为0
        for ( i = 0 ; i< n ; i++ )
        {//把0放入集合，则点到集合的距离此时是点到0的距离
            lowcost[i]=map[0][i];
            closet[i]=0;
        }

        for ( i = 0 ; i < n - 1 ; i ++ )
        {
            double mindis=1.0*(1<<20);        //点到集合最小距离，初始化为最大
            int minone;                        //到集合最小距离对应的点
            for ( j = 0 ; j < n ; j ++ )
            {
                if(lowcost[j]&&mindis>lowcost[j])
                {//j点不在集合中，并且j到集合的距离比最小距离还小，则更新最小距离
                    mindis=lowcost[j];
                    minone=j;
                }
            }
            if(ans<mindis)        //如果答案并不比更新的最小距离大
                ans=mindis;        //更新答案
            lowcost[minone]=0.0;//将该点入集合
            if(minone==1)        //如果改点是1，则水明义江找到了答案
                break;
            for ( j = 0 ; j < n ; j ++ )
            {//更新各点到集合的最小距离
                if(map[j][minone]<lowcost[j])
                {//如果minone到某点j的距离比原来的j到集合的距离要小，则更新该点到集合的距离为改点到minone的距离
                    lowcost[j]=map[j][minone];
                    closet[j]=minone;
                }
            }
        }
        cout<<"Scenario #"<<k<<endl;
        printf("Frog Distance = %.3f\n\n",ans);
        k++;
    }
    return 0;
}