07- 图 5 Saving James Bond - Versión difícil (30 分)
Esta vez consideremos la situación en la película "Live and Let Die" en la que James Bond, el espía más famoso del mundo, fue capturado por un grupo de traficantes de drogas. Fue enviado a un pequeño pedazo de tierra en el centro de un lago lleno de cocodrilos. Allí realizó la acción más atrevida para escapar: ¡saltó sobre la cabeza del cocodrilo más cercano! Antes de que el animal se diera cuenta de lo que estaba sucediendo, James saltó nuevamente a la próxima cabeza grande ... Finalmente llegó a la orilla antes de que el último cocodrilo pudiera morderlo (en realidad, el hombre del truco fue atrapado por la boca grande y apenas escapó con su bota extra gruesa).
Suponga que el lago es de 100 por 100 cuadrados. Suponga que el centro del lago está en (0,0) y la esquina noreste en (50,50). La isla central es un disco centrado en (0,0) con un diámetro de 15. Varios cocodrilos se encuentran en el lago en varias posiciones. Dadas las coordenadas de cada cocodrilo y la distancia que James podría saltar, debes indicarle el camino más corto para llegar a uno de los bancos. La longitud de un camino es la cantidad de saltos que James tiene que hacer.
Especificación de entrada:
cada archivo de entrada contiene un caso de prueba. Cada caso comienza con una línea que contiene dos enteros positivos N (≤100), el número de cocodrilos y D, la distancia máxima que James podría saltar. Luego siguen N líneas, cada una de las cuales contiene la ubicación (x, y) de un cocodrilo. Tenga en cuenta que no hay dos cocodrilos en la misma posición.
Especificación de salida:
para cada caso de prueba, si James puede escapar, envíe en una línea el número mínimo de saltos que debe realizar. Luego, a partir de la siguiente línea, muestre la posición (x, y) de cada cocodrilo en el camino, cada par en una línea, desde la isla hasta el banco. Si es imposible para James escapar de esa manera, simplemente dale 0 como número de saltos. Si hay muchos caminos más cortos, simplemente envíe el que tenga el primer salto mínimo, que se garantiza que será único.
Entrada de muestra 1:
17 15
10 -21
10 21
-40 10
30 -50
20 40
35 10
0 -10
-25 22
40 -40
-30 30
-10 22
0 11
25 21
25 10
10 10
10 35
-30 10
Salida de muestra 1:
4
0 11
10 21
10 35
Entrada de muestra 2:
4 13
-12 12
12 12
-12 -12
12 -12
Salida de muestra 2:
0
Tenga en cuenta que la
pregunta tendrá una condición que hace que la respuesta sea única;
la condición de esta pregunta es que cuando hay múltiples rutas más cortas, se emite
la ruta más corta del primer salto; el método adoptado aquí es el primero más pequeño para ingresar al equipo;
Hay
muchos archivos de encabezado para resolver problemas ; la
pila se usa para guardar la ruta; la
cola se usa para BFS; el
algoritmo
se usa para ordenar; cmath se usa para calcular el valor absoluto;
1.定义鳄鱼结构，存放每只鳄鱼的x，y坐标
#include<iostream>
#include<queue>
#include<stack>
#include<algorithm>
#define MAX 101
using namespace std;
struct Crocodile{
int x;
int y;
//operator <(const Crocodile c)const{
//return x*x+y*y<c.x*c.x+c.y*c.y;
//}
}CR[MAX];
2.设定比较方法，用于sort
bool compare(Crocodile a,Crocodile b)
{
return a.x*a.x+a.y*a.y<b.x*b.x+b.y*b.y; //升序排列，如果改为return a>b，则为降序
}
3.input函数，用于输入数据
因为N和D在后面的BFS函数中要用，故设为全局变量
int N,D;
void input()
{
cin>>N>>D; //鳄鱼数量，每次跳跃的距离
for(int i=0;i<N;i++)
cin>>CR[i].x>>CR[i].y; //读入每个鳄鱼的xy
sort(CR,CR+N,compare);
}
4.bfs函数
dist记录每一个鳄鱼的距离；
path记录路径；
先判断能否从岛上直接到岸上，能则一步，不能则继续；
将岛上能达到的鳄鱼先入队，入队顺序为鳄鱼的距离由小到大，
排序就是为此；
进行BFS，当能跳到岸上时，就为最短路径，按要求输出即可；
保存在path中给的路径要放入stack中，然后挨个pop输出；
void BFS() //输入第一个鳄鱼的序号
{
int dist[MAX]; //记录距离
int path[MAX];//记录路径
for(int i=0;i<N;i++) { //不初始化的化只有第一个数为1;
dist[i]=-1;
path[i]=-1;
}
queue<int> T;
//visited改为记录步数的dist
//岸上能跳到的先入队,且标记步数为1
for(int i=0;i<N;i++)
if((D+7.5)*(D+7.5)>=(CR[i].x*CR[i].x+CR[i].y*CR[i].y))
{
if(50-abs(D+7.5)<=D||50-abs(D+7.5)<=D)
{
cout<<"1"<<endl;
return; //一步跳到岸
}
T.push(i);
dist[i]=1;
}
while(!T.empty()) //队列不空
{
int F=T.front();
T.pop();
int x=CR[F].x;
int y=CR[F].y;
//判断能否上岸
if(50-abs(x)<=D||50-abs(y)<=D) //可以上岸
{
cout<<dist[F]+1<<endl; //加上上岸的一步
stack<Crocodile> S;
while(path[F]!=-1)
{
S.push(CR[F]);
F=path[F];
}
S.push(CR[F]);
while(!S.empty())
{
Crocodile a=S.top();
S.pop();
cout<<a.x<<" "<<a.y<<endl;
}
return;
}
for(int i=0;i<N;i++)
{
//可以达到的坐标
int X= CR[i].x;
int Y= CR[i].y;
if(((X-x)*(X-x)+(Y-y)*(Y-y))<=D*D&&dist[i]==-1) //可以达到的鳄鱼，且没有走过
{
T.push(i);
dist[i]=dist[F]+1;
path[i]=F;
}
}
}
cout<<"0"<<endl;
return;
}
función principal
int main()
{
input();
BFS();
}
Resumen Solución BFS de
ruta más corta no ponderada
:
necesita dist [] para registrar la distancia de cada punto;
ruta para registrar la ruta; no es
necesario usar floyd (ruta más corta ponderada de múltiples fuentes)
y dijkstra (ruta más corta de una sola fuente), el problema simple es complicado.
