poj2253 最短路

题意:青蛙跳石头,给出石头的坐标,然后要确定一条路径,使路径上的最大跨度最小,其实也是一道最短路问题,只要将更新条件从总距离最短改为最大跨度最小就行,即从某点到当前点路径上的最大跨度如果小于当前点原本记录下的最大跨度,或当前点还没有被访问过,无最大跨度,那么就更新它,然后以此为条件跑dij或者spfa就行了

dij:

 1 #include<stdio.h>
 2 #include<string.h>
 3 #include<queue>
 4 #include<algorithm>
 5 #include<vector>
 6 #include<math.h>
 7 #define max(a,b) a>b?a:b
 8 using namespace std;
 9 typedef pair<double,int> pii;
10 const double INF=100000.0;
11
12 int n;
13
14 struct point{
15     int x,y;
16 }p[205];
17
18 double g[205][205],dist[205];
19
20 struct cmp{
21     bool operator()(pii a,pii b){
22         return a.first>b.first;
23     }
24 };
25
26 void dij(int s,int p){
27     int i;
28     for(i=1;i<=n;i++){
29         dist[i]=INF;
30     }
31     dist[s]=0;
32     priority_queue<pii,vector<pii>,cmp>q;
33     q.push(make_pair(0,s));
34     while(!q.empty()){
35         pii u=q.top();
36         q.pop();
37         if(u.first>dist[u.second])continue;
38         for(i=1;i<=n;i++){
39             double j=max(u.first,g[u.second][i]);
40             if(i!=u.second&&dist[i]>j){
41                 dist[i]=j;
42                 q.push(make_pair(dist[i],i));
43             }
44         }
45     }
46     printf("%.3lf\n\n",dist[p]);
47 }
48
49 int main(){
50     int c=0;
51     while(scanf("%d",&n)!=EOF&&n!=0){
52         int i,j;
53         for(i=1;i<=n;i++){
54             scanf("%d%d",&p[i].x,&p[i].y);
55             for(j=1;j<=i;j++){
56                 g[i][j]=g[j][i]=sqrt((p[i].x-p[j].x)*(p[i].x-p[j].x)*1.0+(p[i].y-p[j].y)*(p[i].y-p[j].y)*1.0);
57             }
58         }
59         printf("Scenario #%d\nFrog Distance = ",++c);
60         dij(1,2);
61     }
62     return 0;
63 }

dij

spfa:

 1 #include<stdio.h>
 2 #include<string.h>
 3 #include<queue>
 4 #include<math.h>
 5 #define max(a,b) a>b?a:b
 6 const double INF=10000.0;
 7 using namespace std;
 8
 9 struct point{
10     int x,y;
11 }p[205];
12
13 double g[205][205],dist[205];
14 bool vis[205];
15 int n;
16
17 void spfa(int s,int p){
18     int i;
19     for(i=1;i<=n;i++){
20         dist[i]=INF;
21     }
22     memset(vis,0,sizeof(vis));
23     dist[s]=0;
24     queue<int>q;
25     q.push(s);
26     vis[s]=1;
27     while(!q.empty()){
28         int u=q.front();
29         q.pop();
30         vis[u]=0;
31         for(i=1;i<=n;i++){
32             double j=max(dist[u],g[u][i]);
33             if(i!=u&&dist[i]>j){
34                 dist[i]=j;
35                 if(!vis[i]){
36                     q.push(i);
37                     vis[i]=1;
38                 }
39             }
40         }
41     }
42     printf("%.3lf\n\n",dist[p]);
43 }
44
45 int main(){
46     int c=0;
47     while(scanf("%d",&n)!=EOF&&n!=0){
48         int i,j;
49         for(i=1;i<=n;i++){
50             scanf("%d%d",&p[i].x,&p[i].y);
51             for(j=1;j<=i;j++){
52                 g[i][j]=g[j][i]=sqrt((p[i].x-p[j].x)*(p[i].x-p[j].x)*1.0+(p[i].y-p[j].y)*(p[i].y-p[j].y)*1.0);
53             }
54         }
55         printf("Scenario #%d\nFrog Distance = ",++c);
56         spfa(1,2);
57     }
58     return 0;
59 }

spfa

时间: 2024-08-10 15:09:18

poj2253 最短路的相关文章

poj2253 最短路 floyd Frogger

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

poj2253 Frogger(最短路变型或者最小生成树)

1 /* 2 题意:就是源点到终点有多条的路径,每一条路径中都有一段最大的距离! 3 求这些路径中最大距离的最小值! 4 5 Dijkstra, Floyd, spfa都是可以的!只不过是将松弛的条件变一下就行了! 6 7 想了一下,这道题用最小生成树做也可以啊,图总是连通的嘛!所以建一棵最小 8 生成树,然后dfs一下,从源点1,到终点2的路径上,查找边长最大的路径! 9 附上代码..... 10 */ 11 #include<iostream> 12 #include<cstdio&

POJ2253&amp;ZOJ1942--Frogger【SPFA】单源最短路变形

链接:http://poj.org/problem?id=2253 题意:一个青蛙在一块石头上,看到了另一个青蛙在另一块石头上,它想跳过去找它,如果距离太远它就需要借助别的石头当跳板,两块石头之间的青蛙距离被定义成两块石头之间所有路径中最大跳跃距离的最小值,求两个青蛙之间的青蛙距离. poj2263和它类似,链接:http://poj.org/problem?id=2263 解题报告:Here 这是最短路的变形,每两点之间都有路可以跳,更新最短路的值,权值记录成目前到这一点的最小青蛙距离就行了

poj2253(最短路小变形)

题目连接:http://poj.org/problem?id=2253 题意:给出一个无向图,求一条1~2的路径使得路径上的最大边权最小. 分析:dij将距离更新改成取最大值即可,即dp[i]表示到达i点过程中的最大边权,更新后可能多个,再靠优先队列取出最小的最大边权. 不过好像精度问题,我的代码C++能AC,但G++就不能. #include <cstdio> #include <cstring> #include <string> #include <cmat

POJ2253 Frogger —— 最短路变形

题目链接:http://poj.org/problem?id=2253 Frogger Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 49409   Accepted: 15729 Description Freddy Frog is sitting on a stone in the middle of a lake. Suddenly he notices Fiona Frog who is sitting on a

poj1797 最短路

虽然不是求最短路,但是仍然是最短路题目,题意是要求1到N点的一条路径,由于每一段路都是双向的并且有承受能力,求一条路最小承受能力最大,其实就是之前POJ2253的翻版,一个求最大值最小,一个求最小值最大,于是只要修改最短路的更新条件就可以直接跑模板了 dij: 1 #include<stdio.h> 2 #include<string.h> 3 #include<vector> 4 #include<algorithm> 5 #include<queu

POJ2263&amp;ZOJ1952--Heavy Cargo【Floyd】多源最短路变形

链接:http://poj.org/problem?id=2263 题意:有n个点,m条路,每条路双向的,现在卡车从某点到另一点,卡车的承载无上限,但是马路的承载有上限,问卡车应该承载多少才不会压坏马路. poj2253和它类似,链接:http://poj.org/problem?id=2253 解题报告:Here 就是在两点之间找一条路径,使路径中权值最小的那条边的权值最大,edge数组记录当前路径中最小权值边的权值 #include<cstring> #include<string&

poj2253 Frogger(Floyd)

题目链接 http://poj.org/problem?id=2253 题意 给出青蛙A,B和若干石头的坐标,现在青蛙A要跳到青蛙B所在的石头上,求出所有路径中最远那一跳的最小值. 思路 Floyd算法的变形,将求两点之间的最短路改成求两点之间最大边权的最小值即可. 代码 1 #include <algorithm> 2 #include <iostream> 3 #include <cstring> 4 #include <cstdio> 5 #inclu

hdu3461Marriage Match IV 最短路+最大流

//给一个图.给定起点和终点,仅仅能走图上的最短路 //问最多有多少种走的方法.每条路仅仅能走一次 //仅仅要将在最短路上的全部边的权值改为1.求一个最大流即可 #include<cstdio> #include<cstring> #include<iostream> #include<queue> #include<vector> using namespace std ; const int inf = 0x3f3f3f3f ; const