Poj_2253 Frogger(最短路-SPFA+Dijkstra)

题意：

青蛙1想要到青蛙2那儿去，中间有多个石头可供跳跃。求The frog distance.

The frog distance: the minimum necessary jump range over all possible paths between the two stones.

也就是说求所有路径中必须弹跳距离最短的那个，必须弹跳距离由路径中距离最远的那两个石头决定。

思路：

最开始题意理解了半天。。不是传统的最短路，从起点到终点路径的总长度不要求，但是对青蛙跳跃能力（最大跳跃距离）的要求尽可能小。也就是说青蛙跳多少次没关系，但是在这个过程中青蛙都不用跳的特别远。

因为仍然要保证起点和终点的可达，所以仍用最短路来做。但是dis数组的定义要修改。

定义如下：

dis[i]:起点到i的所有路径中最小的必须弹跳距离；

对应的状态改变方程：

dis[i] = min(dis[i],max(dis[tmp],edge[tmp][i]);

代码实现：

//SPFA
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <cmath>
#include <algorithm>

using namespace std;

const int MAX_V = 210;
const int INF = 0x7ffffff;

struct Node{
    int x,y;
};

int N;
int cnt;
queue<int> que;
Node node[MAX_V];
bool inque[MAX_V];
double dis[MAX_V];
double edge[MAX_V][MAX_V];
int main(){
    cnt = 1;
    while( scanf("%d",&N) != EOF ){
        if( N == 0 ){
            break;
        }
        for( int i = 1; i <= N; i++ ){
            scanf("%d%d",&node[i].x,&node[i].y);
        }
        for( int i = 1; i <= N; i++ ){
            for( int j = i+1; j <= N; j++ ){
                int dx = node[i].x-node[j].x;
                int dy = node[i].y-node[j].y;
                double cost = sqrt(dx*dx+dy*dy);
                edge[i][j] = cost;
                edge[j][i] = cost;
            }
            dis[i] = INF;
            edge[i][i] = 0;
        }
        memset(inque,false,sizeof(inque));
        dis[1] = 0;
        que.push(1);
        inque[1] = true;
        while( !que.empty() ){
            int tmp = que.front();
            que.pop();
            inque[tmp] = false;
            for( int i = 1; i <= N; i++ ){
                if( dis[i] > max(dis[tmp],edge[tmp][i]) ){
                    dis[i] = max(dis[tmp],edge[tmp][i]);
                    if( inque[i] == false ){
                        que.push(i);
                        inque[i] = true;
                    }
                }
            }
        }
        printf("Scenario #%d\n",cnt++);
        printf("Frog Distance = %.3f\n\n",dis[2]);
    }
    return 0;
}


//Dijkstra
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <cmath>
#include <algorithm>

using namespace std;

const int MAX_V = 210;
const int INF = 0x7ffffff;

struct Node{
    int x,y;
};

struct Pos{
    int to;
    double dis;
    Pos(const int to,const double dis){
        this->to = to;
        this->dis = dis;
    }
};

int N;
int cnt;
queue<Pos> que;
Node node[MAX_V];
double dis[MAX_V];
double edge[MAX_V][MAX_V];
int main(){
    cnt = 1;
    while( scanf("%d",&N) != EOF ){
        if( N == 0 ){
            break;
        }
        for( int i = 1; i <= N; i++ ){
            scanf("%d%d",&node[i].x,&node[i].y);
        }
        for( int i = 1; i <= N; i++ ){
            for( int j = i+1; j <= N; j++ ){
                int dx = node[i].x-node[j].x;
                int dy = node[i].y-node[j].y;
                double cost = sqrt(dx*dx+dy*dy);
                edge[i][j] = cost;
                edge[j][i] = cost;
            }
            dis[i] = INF;
            edge[i][i] = 0;
        }
        dis[1] = 0;
        que.push(Pos(1,0));
        while( !que.empty() ){
            Pos tmp = que.front();
            que.pop();
            if( dis[tmp.to] < tmp.dis ){
                continue;
            }
            for( int i = 1; i <= N; i++ ){
                if( dis[i] > max(tmp.dis,edge[tmp.to][i]) ){
                    dis[i] = max(tmp.dis,edge[tmp.to][i]);
                    que.push(Pos(i,dis[i]));
                }
            }
        }
        printf("Scenario #%d\n",cnt++);
        printf("Frog Distance = %.3f\n\n",dis[2]);
    }
    return 0;
}