Java 通过向量列表查找路径

我有一张地球地图上325个节点的列表。 这些节点通过航运路线绘制出地球

我的任务是制作一种方法，只需使用一条节点路径就可以找到从一个节点到另一个节点的最短路径。它需要实时和快速，因为可能会有数百艘船

我已经研究了A*和Dijkstras的解决方案，但它们不能很好地处理拐角

我在考虑使用角度和距离，但我不确定如何实现它

地图上的每个节点都是objectMap中的以下对象。Int是节点号

节点和计算在应用程序加载过程中完成。所以我们有所有这些

下面的类包含在objectMap中，可以很好地工作

public static class Node
{
    private int nodeNumber;
    private Vector2 pos;
    private int connectedNodes[];

    private ObjectMap<Integer, Node> masterList;
    private ObjectMap<Integer, Float> connectedNodeDistances;
    private ObjectMap<Integer, Float> connectedNodeDegrees;

    public Node(int nodeNumber, float x, float y, int connectedNodes[], ObjectMap<Integer, Node> masterList)
    {
        this.nodeNumber = nodeNumber;

        float areaX = x / MapCreator.WORLD_SCALE;
        float areaY = y / MapCreator.WORLD_SCALE;
        this.pos = new Vector2(areaX / MapCreator.CURRENT_DOWN_SIZE_X, (PolyUtils.getInstance().getScreenPercentageY(1f) - (areaY / MapCreator.CURRENT_DOWN_SIZE_X)) - MapCreator.TOP_EXTRA);

        this.connectedNodes = connectedNodes;
        this.masterList = masterList;
        this.connectedNodeDistances = new ObjectMap<Integer, Float>();
        this.connectedNodeDegrees = new ObjectMap<Integer, Float>();
    }

    public void calculateDistances()
    {
        for(int eachConnectedNode : connectedNodes)
        {
            float angleDegree = new Vector2(this.pos).sub(masterList.get(eachConnectedNode).getPos()).angle();
            connectedNodeDistances.put(eachConnectedNode, this.pos.dst(masterList.get(eachConnectedNode).getPos()));
            connectedNodeDegrees.put(eachConnectedNode, angleDegree);
        }
    }

    public int getNodeNumber() {
        return nodeNumber;
    }

    public float getDistanceFromNode(int number)
    {
        return connectedNodeDistances.get(number);
    }

    public Vector2 getPos() {
        return pos;
    }

    public int[] getConnectedNodes() {
        return connectedNodes;
    }
}

公共静态类节点
{
私有节点；
私人矢量2位置；
私有int连接节点[]；
私有对象映射主列表；
私有对象映射连接的节点实例；
私有对象映射连接节点协议；
公共节点（int-nodeNumber、float x、float y、int-connectedNodes[]，ObjectMap主列表）
{
this.nodeNumber=nodeNumber；
浮动面积x=x/MapCreator.WORLD\u比例；
浮动面积y=y/MapCreator.WORLD\u比例；
this.pos=new Vector2（areaX/MapCreator.CURRENT_DOWN_SIZE_X，（PolyUtils.getInstance（）.getScreenPercentageY（1f）-（areaY/MapCreator.CURRENT_DOWN_SIZE_X））-MapCreator.TOP_EXTRA）；
this.connectedNodes=connectedNodes；
this.masterList=masterList；
this.connectedNodeInstances=newObjectMap（）；
this.connectedNodegrees=newObjectMap（）；
}
公共空间计算实例（）
{
for（int-eachConnectedNode:connectedNodes）
{
float angleDegree=newvector2（this.pos）.sub（masterList.get（eachConnectedNode.getPos（））.angle（）；
connectedNodeInstances.put（eachConnectedNode，this.pos.dst（masterList.get（eachConnectedNode.getPos（）））；
connectedNodegrees.put（每个connectedNode，角度度）；
}
}
public int getNodeNumber（）{
返回节点数；
}
公共浮点getDistanceFromNode（整数）
{
返回ConnectedNodeInstances.get（编号）；
}
公共向量2 getPos（）{
返回pos；
}
public int[]getConnectedNodes（）{
返回连接的节点；
}
}

我被困的地方是：

public Array<Node> getFastestRoute(Vector2 startPos, Vector2 endPos, int numberOfAttempts)
{
    Array<Array<Node>> potentialRoutes = new Array<Array<Node>>();

    int sizeOfShortestRouteNodes = 999999;

    for(int index = 0; index < numberOfAttempts; index++)
    {
        Array<Node> newRoute = getListOfNodes(startPos, endPos, MathUtils.random(-0.75f, 0.75f));
        if(newRoute != null)
        {
            if(newRoute.size < sizeOfShortestRouteNodes)
            {
                potentialRoutes.clear();
                potentialRoutes.add(newRoute);
                sizeOfShortestRouteNodes = potentialRoutes.size;
            }
            else if(newRoute.size == sizeOfShortestRouteNodes)
            {
                potentialRoutes.add(newRoute);
            }
        }
    }

    return getShortestRouteDistance(potentialRoutes);
}

private Array<Node> getListOfNodes(Vector2 startPos, Vector2 endPos, float randomizationSeed)
{
    //TODO Draw as lines as test.

    Array<Node> nodeList = new Array<Node>();
    Array<Node> deadNodes = new Array<Node>();

    int iterations = 0;
    final int maxIterations = 100; //Needs to be low so that boat trip isn't too long also helps performance.

    nodeList.add(getNearestNode(startPos));

    Node lastNode = getNearestNode(endPos);
    Node currentNode = nodeList.first();

    while(true)
    {
        float currentNodeToEndAngle = new Vector2(new Vector2(currentNode.getPos())).sub(endPos).angle();

        //Find closest direction
        Node closestNodeInDirection = null;
        float closestDirection = 361;

        for(int eachConnectedNode : currentNode.getConnectedNodes())
        {
            Node potentialNode = boatNodes.get((eachConnectedNode));

            if(!deadNodes.contains(potentialNode, true))
            {
                float angleToEndNodeFromCurrent = (new Vector2(currentNode.getPos()).sub(potentialNode.getPos()).angle());

                //Randomize the direction from the seed.
                angleToEndNodeFromCurrent = angleToEndNodeFromCurrent * randomizationSeed;

                float differenceInDegrees = Math.abs(angleToEndNodeFromCurrent - currentNodeToEndAngle);

                if(differenceInDegrees < closestDirection)
                {
                    closestDirection = differenceInDegrees;
                    closestNodeInDirection = potentialNode;
                }
            }
        }

        //No new nodes.
        if(closestNodeInDirection == null)
        {
            //Go back and try another route.
            if(nodeList.size > 1)
            {
                nodeList.pop();
                currentNode = nodeList.peek();
            }
        }

        //Adding nodes.
        if(closestNodeInDirection != null && lastNode != closestNodeInDirection)
        {
            nodeList.add(closestNodeInDirection);
            deadNodes.add(closestNodeInDirection);
            currentNode = closestNodeInDirection;
        }
        else if(closestNodeInDirection != null)
        {
            //Last node reached.
            nodeList.add(lastNode);
            return nodeList;
        }

        //Iterations too many.
        iterations++;
        if(iterations >= maxIterations){
            return null;
        }
    }
}

public Array<Node> getShortestRouteDistance(Array<Array<Node>> allNodeRoutes)
{
    Array<Node> shortestRoute = null;
    float shortestRouteLength = 99999f;

    for(int arraysIndex = 0; arraysIndex < allNodeRoutes.size; arraysIndex++)
    {
        Array<Node> nodeArray = allNodeRoutes.get(arraysIndex);

        float lengthOfThisRoute = 0f;

        for(int nodesIndex = 0; nodesIndex < nodeArray.size; nodesIndex++)
        {
            Node nextNode = null;
            Node thisNode = nodeArray.get(nodesIndex);

            if(nodesIndex + 1 < nodeArray.size)
            {
                nextNode = nodeArray.get(nodesIndex + 1);
            }

            if(nextNode != null)
            {
                lengthOfThisRoute += thisNode.getDistanceFromNode(nextNode.getNodeNumber());
            }
        }

        if(lengthOfThisRoute < shortestRouteLength)
        {
            shortestRouteLength = lengthOfThisRoute;
            shortestRoute = nodeArray;
        }
    }

    return shortestRoute;
}

public Array getFastestRoute（Vector2 startPos、Vector2 endPos、int numberofthreads）
{
Array potentialRoutes=新数组（）；
int sizeOfShortestRouteNodes=999999；
for（int-index=0；索引<尝试次数；索引++）
{
数组newRoute=getListOfNodes（startPos、endPos、MathUtils.random（-0.75f、0.75f））；
if（newRoute！=null）
{
if（newRoute.size1）
{
nodeList.pop（）；
currentNode=nodeList.peek（）；
}
}
//添加节点。
if（closestNodeInDirection！=null&&lastNode！=closestNodeInDirection）
{
nodeList.add（closestNodeInDirection）；
添加（closestNodeInDirection）；
currentNode=closestNodeInDirection；
}
else if（closestNodeInDirection！=null）
{
//已到达最后一个节点。
nodeList.add（lastNode）；
返回节点列表；
}
//迭代次数太多。
迭代++；
如果（迭代次数>=最大迭代次数）{
返回null；
}
}
}
公共数组getShortestRouteDistance（数组allNodeRoutes）
{
数组shortestRoute=null；
浮动短路由长度=9999F；
对于（int-arraysIndex=0；arraysIndex