Saving James Bond - Hard Version java实现

与简单版的区别在于，要找出最少跳跃路径，并记录下跳跃位置。我还没有完成在相同跳跃数时输出第一跳最短距离的方法，目前思路是将第一次跳跃的点按距离从小到大排序，依次入队。

import java.util.LinkedList;
import java.util.Scanner;
//声明鳄鱼节点，小岛节点为x=0,y=0的节点
class Node
{
    int x;
    int y;

    public Node(int x,int y)
    {
        this.x=x;
        this.y=y;
    }
    //计算当前鳄鱼和制定鳄鱼的距离
    public double getDistant(Node node)
    {
        //如果当前节点是小岛，要考虑小岛的半径
        if (this.x==0&&this.y==0)
            return ( Math.sqrt(Math.pow(node.x, 2)+Math.pow(node.y, 2))-7.5);
        
        else
            return Math.sqrt((this.x-node.x)*(this.x-node.x)+(this.y-node.y)*(this.y-node.y));
    }
    //计算当前鳄鱼到岸边的最短距离
    public double getDistant()
    {
        double nearest= (50-Math.abs(x))>(50-Math.abs(y))?(50-Math.abs(y)):(50-Math.abs(x));
        return nearest;
    }
}
//声明图类型
class Graph
{
    Node[] arr;
    int distant;
    boolean[] visited;
    //记录到相应鳄鱼的跳跃次数
    int[] dist;
    //记录跳到当前位置的上一个跳跃点的位置
    int[] path;
    public Graph(Node[] arr,int jumpDst)
    {
        this.arr=arr;
        distant=jumpDst;
        visited=new boolean[arr.length];
        dist=new int[arr.length];
        path=new int[arr.length];
        //初始化dist和path
        for (int i=0;i<arr.length ;i++ )
        {
            visited[i]=false;
            dist[i]=-1;
            path[i]=-1;
        }
    }
    //根绝元素获取其在数组中的位置
    public int getIndex(Node n,Node[] arr)
    {
        for (int i=0;i<arr.length ;i++ )
        {
            if (n.x==arr[i].x&&n.y==arr[i].y)
                return i;
            
        }
        return -1;
    }
    public boolean serchBFS()
    {
        //因为不论是否有节点到岸边距离小于跳跃距离，都要从小岛上出发，因此只考虑包含小岛节点的连通集
        if(distant>=50-7.5)
        {
            System.out.print(1);
            return true;
        }
        LinkedList<Node> l=new LinkedList<>();
        visited[0]=true;
        dist[0]=0;
        //对第一跳能跳上的点从小到大排序
        
     
        l.add(arr[0]);
        while (l.size()>0)
        {
            Node n=l.remove();
            if (n.getDistant()<=distant)
            {
                int temp=dist[getIndex(n,arr)];
                System.out.println(temp+1);
                while(path[getIndex(n,arr)]!=-1)
                {
                    System.out.println(arr[getIndex(n,arr)].x+" "+arr[getIndex(n,arr)].y);
                    n=arr[path[getIndex(n,arr)]];
                }
                return true;
            }
            
            for (int j=0;j<arr.length ;j++ )
            {
                
                if (n.getDistant(arr[j])<=distant&&visited[j]==false)
                {
                    visited[j]=true;
                    dist[j]=dist[getIndex(n,arr)]+1;
                    path[j]=getIndex(n,arr);
                    l.add(arr[j]);
                }
            }
        }
        System.out.print(0);
        return false;
    }
}
//测试类
public class test
{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();
        int jumpDst=sc.nextInt();
        Node[] arr=new Node[num+1];
        arr[0]=new Node(0,0);
        for (int i=1;i<num+1 ;i++ )
        {
            int x=sc.nextInt();
            int y=sc.nextInt();

            arr[i]=new Node(x,y);

        }
        Graph g=new Graph(arr,jumpDst);
        g.serchBFS();
        
        
    }
}