kuangbin专题专题四 Frogger POJ - 2253

题目链接：https://vjudge.net/problem/POJ-2253

思路：

从一号到二号石头的所有路线中，每条路线中都个子选出该路线中两点通路的最长距离，并在这些选出的最长距离选出最短路的那个距离X，

就是青蛙距离，即青蛙至少能跳X米，才能安全的到达二号，因为什么，再看看第一句话。

再想，我们知道，djikstra中的价值数组存的是从u点到其他所有点的最短距离，way[ 1 ] 是u到1的最短距离， way[ x ] 是u到x的最短距离，

我们知道djikstra的时间复杂度是O（n^2），这个时间复杂是是因为我们访问了所有的从一个城市出发到其他城市所有情况（除去已经最优的城市），

有n个城市，去其他（除去最优）的个城市，所有比较次数可以用接近（n^2）表示。

我为什么要说这个呢，我只想表达。。。我只是想强调dijstra保存了最优路线和不确定路线的价值，访问了其他不确定的路线去更新不确定价值的路线，

慢慢得到所有最优路线。

那么，我们可不可以把这个价值数组利用在这个题目上，改变维护方式呢？

我们可以这么想题目意思，价值数组只存一条路线，那么它一定存的是到该城市的最长距离，然后，我们需要把这个最长距离尽可能变小，即最小化最大距离。

那么我们就可以用dijkstra算法来求这个问题，那我们需要怎么维护。

（1）：首先，价值数组初始化一样。

（2）：我们需要找出最小的价值数组，为什么？（里面存的是起始点到该点的所有路线中最小化的最大距离）

（3）：我们找出了最小的价值数组，即得到了城市编号，那么，我们用该点去访问其他不确定的城市。

（4）： 维护方法 :way[ k ] > max( dis[ x ][ k ], way[ x ] ),  max( dis[ x ][ k ], way[ x ] )表示，从起始点到x点所有路线的的最小化的最大距离和x到k的距离选出最大的和

从起始点到k点部分路线的的最小化的最大距离比较，如果k点的从起始点到k点部分路线的的最小化的最大距离比从起始点到x点所有路线的的最小化的最大距离和x到k的距离选出最大的

的大，说明k可以被优化，那么  :way[ k ] =max( dis[ x ][ k ], way[ x ] ),  max( dis[ x ][ k ], way[ x ] )。

（5）：直到最后得到从起始点到其他所有点的最小化最大距离。

( 代码就不加上注释了，只要上面的理解了，代码很容易理解 )

这个题目在思维上还是有点难的，可以慢慢理解。

---

 #include <iostream>
 #include <cstring>
 #include <algorithm>
 #include <cstdio>
 #include <string>
 #include <cmath>
 #include <iomanip>
 using namespace std;

 typedef long long LL;
 #define inf (1LL << 30) - 1
 #define rep(i,j,k) for(int i = (j); i <= (k); i++)
 #define rep__(i,j,k) for(int i = (j); i < (k); i++)
 #define per(i,j,k) for(int i = (j); i >= (k); i--)
 #define per__(i,j,k) for(int i = (j); i > (k); i--)

 const int N = ;
 double p_x[N];
 double p_y[N];
 double dis[N][N];
 bool vis[N];
 double way[N];
 int n,x,y;

 void init(){
     rep(i,,n) rep(j,,n){
         if(i == j) dis[i][j] = ;
         else dis[i][j] = inf;
     }
     rep(i,,n) vis[i] = false;
 }

 void input(){

     rep(i,,n){
         cin >> p_x[i] >> p_y[i];
     }
 }

 inline double fun_dis(double x1, double y1, double x2, double y2){
     return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
 }

 void calculate_dis(){

     rep(i,,n){
         rep(j,,n){
             double tmp_dis = fun_dis(p_x[i],p_y[i],p_x[j],p_y[j]);
             if( tmp_dis < dis[i][j] )
                 dis[i][j] = dis[j][i] = tmp_dis;
         }
     }
 }

 void dijkstra(){

     rep(i,,n) way[i] = dis[][i];
     vis[] = true;

     rep(i,,n){

         int x = -;
         double v = inf;

         rep(j,,n){
             if(!vis[j] && v > way[j]) v = way[x = j];
         }

         if(x == -) continue;
         vis[x] = true;

         rep(k,,n){
             if(!vis[k] && way[k] > max(way[x], dis[x][k])){
                 way[k] = max(way[x], dis[x][k]);
             }
         }
     }
 }

 int main(){

     ios::sync_with_stdio(false);
     cin.tie();

     int cnt = ;
     while(cin >> n){
         if(n == ) break;

         init();
         input();
         calculate_dis();
         dijkstra();

         cout << "Scenario #" << ++cnt << endl;
         cout << "Frog Distance = " << fixed << setprecision() << way[] << endl;
         cout << endl;
     }   

     getchar();getchar();

     return ;
 }