POJ [2253] Frogger 【La deformación del camino más corto】

Descripción

Freddy Frog está sentado en una piedra en medio de un lago. De repente se da cuenta de Fiona Frog que está sentada en otra piedra. Él planea visitarla, pero como el agua está sucia y llena de protector solar para turistas, quiere evitar nadar y, en cambio, alcanzarla saltando.
Lamentablemente, la piedra de Fiona está fuera de su rango de salto. Por lo tanto, Freddy considera usar otras piedras como paradas intermedias y alcanzarla mediante una secuencia de varios saltos pequeños.
Para ejecutar una secuencia dada de saltos, el rango de salto de una rana obviamente debe ser al menos tan largo como el salto más largo que ocurre en la secuencia.
La distancia de la rana (los humanos también lo llaman distancia mínima) entre dos piedras, por lo tanto, se define como el rango de salto mínimo necesario sobre todos los caminos posibles entre las dos piedras.
Te dan las coordenadas de la piedra de Freddy, la piedra de Fiona y todas las demás piedras en el lago. Tu trabajo es calcular la distancia de rana entre la piedra de Freddy y Fiona.

Entrada 

La entrada contendrá uno o más casos de prueba. La primera línea de cada caso de prueba contendrá el número de cálculos n (2 <= n <= 200). Las siguientes n líneas contienen dos números enteros xi, yi (0 <= xi, yi <= 1000) que representan las coordenadas de la piedra #i. La piedra # 1 es la piedra de Freddy, la piedra # 2 es la piedra de Fiona, las otras piedras n-2 están desocupadas. Hay una línea en blanco después de cada caso de prueba. La entrada termina con un valor de cero (0) para n.

Salida 

Para cada caso de prueba, imprima una línea que diga "Escenario #x" y una línea que diga "Distancia de rana = y" donde x se reemplaza por el número de caso de prueba (están numerados del 1) e y se reemplaza por el número real apropiado, impreso a tres decimales. Ponga una línea en blanco después de cada caso de prueba, incluso después del último.

Entrada de muestra 

2 
0 0 
3 4 

3 
17 4 
19 4 
18 5 

0

Salida de muestra 

Escenario # 1 
Distancia de rana = 5.000 

Escenario # 2 
Distancia de rana = 1.414

La idea principal:

Dadas las coordenadas de n puntos, forme un gráfico no dirigido, encuentre una ruta de 1 ~ 2, de modo que el peso máximo del borde en la ruta sea el valor mínimo del peso máximo del borde en todas las rutas de 1 ~ 2.

Análisis:

Esta pregunta es la deformación de la ruta más corta, modificar la definición de la matriz en el algoritmo de Dijkstra, guardar el valor mínimo del peso máximo del borde en todas las rutas desde el punto de partida hasta el punto actual en la matriz y usar el valor del punto actual y el máximo de los bordes adyacentes Valor para actualizar el valor dis del punto adyacente.

Vea el código para una explicación específica.

//#include <bits/stdc++.h>
#include <iostream>
#include <cstring>
#include <queue>
#include <map>
#include <cmath>
#include <vector>
#include <iomanip>

using namespace std;

const int maxn=205;
const int INF=0x3f3f3f3f;

int vis[maxn];
double dis[maxn],tm[maxn];

int head[maxn];
int ans;
int e,n;

struct node{
 
    int u,v;
    
    double w;
 
    int next;
 
}edge[maxn*maxn];

void add(int u,int v,double w){//向邻接表中加边 
 
    edge[ans].u=u;
 
    edge[ans].v=v;
 
    edge[ans].w=w;
 
    edge[ans].next=head[u];
 
    head[u]=ans++;
 
}

struct dot{	//存储点的坐标 
	int x,y;
	dot(){}
	dot(int x,int y):x(x),y(y) {}
}; 

dot po[205];

struct point{	//定义优先队列中的节点 
    int id;
    double val;
    point(int id,double val):id(id),val(val) {}
    bool operator <(const point &x)const{
        return val>x.val;
    }
};

void dijkstra(int s){
    memset(vis,0,sizeof(vis));
    for(int i=1; i<=n; i++){
    	dis[i]=INF;
	}
    priority_queue<point> q;
    q.push(point(s,0));
    vis[s]=1;
    dis[s]=0;
    while(!q.empty()){
        int cur=q.top().id;
        q.pop();
        vis[cur]=1;	//优先队列中最小的值不可能再被经过其他节点的路径更新 
        if(cur==2) return;	//dis[2]算完即可退出; 
        for(int i=head[cur]; i!=-1; i=edge[i].next){
            int id=edge[i].v;
            if(!vis[id] && max(dis[cur],edge[i].w) < dis[id]){	//用当前点的dis和相邻边的最大值去更新相邻点的dis值
                dis[id]=max(dis[cur],edge[i].w);
                q.push(point(id,dis[id]));
            }
        }
    }
}

int main(){
	int cas=0;
	while(scanf("%d",&n)!=EOF&&n){
		cas++;
		ans=0;
		memset(head,-1,sizeof(head));
		int tx,ty;
		for(int i=1;i<=n;i++){
			scanf("%d%d",&tx,&ty);
			po[i]=dot(tx,ty);
		}
		//建图 
		for(int i=1;i<=n;i++){
			for(int j=i+1;j<=n;j++){
				double dist=sqrt((double)(po[i].x-po[j].x)*(po[i].x-po[j].x)+(po[i].y-po[j].y)*(po[i].y-po[j].y));
				add(i,j,dist);
				add(j,i,dist);
			}
		}
		dijkstra(1);
		printf("Scenario #%d\nFrog Distance = %.3f\n\n", cas, dis[2]);	//注意要多输出一个空行 
	}
	return 0;
}

 

30 artículos originales publicados · ganó 5 · 900 visitas

Supongo que te gusta

Origin blog.csdn.net/qq_42840665/article/details/101206500
Recomendado
Clasificación