poj 2253 (dis最短路径)

Frogger

Time Limit: 1000MS   Memory Limit: 65536K
Total Submissions: 24979   Accepted: 8114

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

Source

Ulm Local 1997

#include<iostream>
#include<math.h>
#include<iomanip>
using namespace std;
double G[210][210];
int n;
struct Point{
    double x,y;
}a[210];
float dist(Point a,Point b){
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
void dij(){
    double dis[210];
    int vis[210];
    for(int i=1;i<=n;i++)
        vis[i]=0;
    vis[1]=1;
    dis[1]=0.0;
    for(int i=2;i<=n;i++)
        dis[i]=G[1][i];
    for(int i=1;i<n;i++){
        double min=999999.0;
        int v;
        for(int j=2;j<=n;j++)
            if(!vis[j] && dis[j]<min){
                min=dis[j];
                v=j;
            }
        vis[v]=1;
        for(int j=1;j<=n;j++){
            double tmp=(dis[v]<G[v][j] ? G[v][j] : dis[v]);     //注意这里是最短路径变形
            dis[j]= tmp<dis[j] ? tmp : dis[j];
        }
    }
    cout<<setiosflags(ios::fixed)<<setprecision(3)<<dis[2]<<endl<<endl;
}
int main(){
    int cas=1;
    while(cin>>n&&n){
        for(int i=1;i<=n;i++)
            cin>>a[i].x>>a[i].y;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                G[i][j]=dist(a[i],a[j]);
        cout<<"Scenario #"<<cas++<<endl;
        cout<<"Frog Distance = ";
        dij();
    }
    return 0;
}

poj 2253 (dis最短路径)

时间: 2024-10-13 19:30:48

poj 2253 (dis最短路径)的相关文章

Floyd-Warshall算法(求解任意两点间的最短路) 详解 + 变形 之 poj 2253 Frogger

/* 好久没有做有关图论的题了,复习一下. --------------------------------------------------------- 任意两点间的最短路(Floyd-Warshall算法) 动态规划: dp[k][i][j] := 节点i可以通过编号1,2...k的节点到达j节点的最短路径. 使用1,2...k的节点,可以分为以下两种情况来讨论: (1)i到j的最短路正好经过节点k一次 dp[k-1][i][k] + dp[k-1][k][j] (2)i到j的最短路完全

POJ 2253 Frogger

题意:一只青蛙找到另外一只青蛙,不过可以通过其它的石头跳到目标青蛙的位置去,其中,输入数据的时候第一组数据是第一只青蛙的位置,第二组是目标青蛙的位置,其它的为石头的位置 思路:dijkstra算法的一种小小的变形,做法还是一样的 Tips:POJ上的双精度浮点型输出竟然是%f输出害的我一直错,或者是编译错误,恼啊! AC代码: #include<cstdio> #include<cmath> #include<algorithm> using namespace std

poj 2253

群 #include <stdio.h>#include <math.h> int a[220][220];int x[220],y[220],n;int init(){ int i,j; for(i=0;i<n;i++) scanf("%d%d",&x[i],&y[i]); for(i=0;i<n;i++) for(j=0;j<n;j++) a[i][j]=(x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])

POJ 2253 - Frogger (floyd)

A - Frogger Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u Submit Status 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

poj 3259(bellman最短路径)

Wormholes Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 30169   Accepted: 10914 Description While exploring his many farms, Farmer John has discovered a number of amazing wormholes. A wormhole is very peculiar because it is a one-way p

【POJ 2253】Frogger

[POJ 2253]Frogger 求起点到终点的通路中每天路的最大权中的最小值 最短路保证最大权联通求最小值(最短) Floyd 524K 79MS 1170B #include using namespace std; typedef struct Point { int x,y; }Point; Point p[233]; double dis[233][233]; int n; int dcmp(double x) { return x < -esp? -1: x > esp; } d

poj 2253 Frogger (最长路中的最短路)

链接:poj 2253 题意:给出青蛙A,B和若干石头的坐标,现青蛙A想到青蛙B那,A可通过任意石头到达B, 问从A到B多条路径中的最长边中的最短距离 分析:这题是最短路的变形,以前求的是路径总长的最小值,而此题是通路中最长边的最小值,每条边的权值可以通过坐标算出,因为是单源起点,直接用SPFA算法或dijkstra算法就可以了 SPFA 16MS #include<cstdio> #include<queue> #include<cmath> #include<

poj 1062 (dij最短路径)

昂贵的聘礼 Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 35968   Accepted: 10314 Description 年轻的探险家来到了一个印第安部落里.在那里他和酋长的女儿相爱了,于是便向酋长去求亲.酋长要他用10000个金币作为聘礼才答应把女儿嫁给他.探险家拿不出这么多金币,便请求酋长降低要求.酋长说:"嗯,如果你能够替我弄到大祭司的皮袄,我可以只要8000金币.如果你能够弄来他的水晶球,那么只要5000

poj 3259Wormholes (spfa最短路径)

#include<stdio.h> #include<string.h> #include<limits.h> #include<queue> using namespace std; #define N 5505 #define M 55000//注意边和点集的数组大小 struct edge { int to,value,next; }edges[M]; int heads[N],len=0; int addedge(int u,int v,int w)