关于排序路径的想法？答案

【问题标题】：Ideas About Sorting Path?关于排序路径的想法？
【发布时间】：2019-01-05 15:21:57
【问题描述】：

我正在尝试通过接近度将点列表排序到路径中，但我能想到的唯一方法是迭代它们并获取当前存储的项目与我的项目之间的绝对值距离m 迭代，如果新坐标与当前坐标之差的绝对值大于 0 但不大于 2，则将该点设为当前点（查找相邻坐标）。

但是，我有一个范围问题，我正在摸索这里该怎么做。我不是通过增加 x、y 或 z 值来对它们进行排序 - 现在，我正在使用半径 1 进行测试 - 所以更传统的排序方法在这里不起作用。

有人指点吗？

package pickquest.common;

import java.util.ArrayList;
import java.util.HashMap;

import org.bukkit.Location;

public class Path {
    private HashMap<Integer, Location> pathSequence = new HashMap<>();

    public HashMap<Integer, Location> getPathSequence() {
        return pathSequence;
    }

    public void setPathSequence(HashMap<Integer, Location> pathSequence) {
        this.pathSequence = pathSequence;
    }

    public void setsequencePath(Location origin, ArrayList<Location> points, Location destination) {
        sequencePath(origin, points, destination);
    }

    private void sequencePath(Location origin, ArrayList<Location> points, Location destination) {
        Location current = origin;
        ArrayList<Location> processedPoints = new ArrayList<>();
        processedPoints.addAll(points);
        while (!(processedPoints.isEmpty())) {
            Integer index = 0;

            for (int i = 0; i < points.size(); i++) {

                if ((Math.abs(current.getX() - processedPoints.get(i).getX()) > 0) && (Math.abs(current.getX() - processedPoints.get(i).getX()) <= 1.9)) {
                    if (!(pathSequence.containsValue(processedPoints.get(i)))) {
                        getPathSequence().put(index, processedPoints.get(i));
                        processedPoints.remove(i);
                        break;
                    }
                } else if ((Math.abs(current.getY() - processedPoints.get(i).getY()) > 0) && (Math.abs(current.getY() - processedPoints.get(i).getY()) <= 1.9)) {
                    if (!(pathSequence.containsValue(processedPoints.get(i)))) {
                        getPathSequence().put(index, processedPoints.get(i));
                        processedPoints.remove(i);
                        break;
                    }
                } else if ((Math.abs(current.getY() - processedPoints.get(i).getY()) > 0) && (Math.abs(current.getY() - processedPoints.get(i).getY()) <= 1.9)) {
                    if (!(pathSequence.containsValue(processedPoints.get(i)))) {
                        getPathSequence().put(index, processedPoints.get(i));
                        processedPoints.remove(i);
                        break;
                    }
                }

                processedPoints.remove(i);
                index++;
            }
        }

        for (int i = 0; i < pathSequence.size(); i++) {
            System.out.println(i + ": " + pathSequence.get(i));
        }
    }


}

【问题讨论】：

我相信一种常见的方法是使用绝对距离.. (√ (distX² + distY² + distZ²) 其中 distXYZ 是您当前位置和每个轴上下一个位置之间的距离。问这个在 Math.SE 上可能是一个好主意，因为这样的问题经常发生（例如“旅行推销员”，但这是针对二维坐标系统的）。

标签： java coordinates minecraft bukkit

【解决方案1】：

您可能会使用 TreeMap 并根据距离对您的位置进行排序，然后使用 TreeMap 的标题/尾随功能。例如：

public class Path {

    private final Iterable<Location> points;
    public Path(Iterable<Location> points) {
        this.points= points;
    }

    public TreeMap<Double, Location> getNearby(Location from) {
        TreeMap<Double, Location> nearby = new TreeMap<>();
        for (Location point: points) {
            nearby.put(distance(point, from), point);
        }
        return nearby;
    }

    public SortedMap<Double, Location> getNearby(Location from, double maxDistance) {
        return getNearby(from).headMap(maxDistance);
    }

    private static double distance(Location o1, Location o2) {
        double a = o1.getX() - o2.getX();
        double b = o1.getY() - o2.getY();
        double c = o1.getZ() - o2.getZ();
        return Math.sqrt(a * a + b * b + c * c);
    }
}

【讨论】：

有趣。稍后我将研究 TreeMaps 和 SortedMaps。我仍然熟悉 Java 集合框架的许多方面。

【解决方案2】：

我现在基本上已经弄清楚了。可能有更简单的方法，我想要更具体的应急系统，但对于我想要的，即围绕玩家对 1 格半径进行排序，这是可行的。

稍后，我将添加某种加权系统，考虑 x、y 和 z 点之间的距离，并通常相应地支持某些操作。可能有很多不必要的代码在这一点上没有任何作用。有些事情被声明了两次——一次在开头，一次在结尾。稍后我会清理它。

package pickquest.common;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.ListIterator;

import org.bukkit.Location;

public class Path {
 private HashMap<Integer, Location> pathSequence = new HashMap<>(); 

 public HashMap<Integer, Location> getPathSequence() {
    return pathSequence;
}

 public void setPathSequence(HashMap<Integer, Location> pathSequence) {
    this.pathSequence = pathSequence;
}
 public void setsequencePath(Location origin, ArrayList<Location> points, Location destination) {
    sequencePath(origin, points, destination);
}

 private HashMap<Integer, Location> sequencePath(Location origin, ArrayList<Location> points, Location destination) {
    Location current = origin;
    ArrayList<Location> processedPoints = new ArrayList<>();
    processedPoints.addAll(points);
    ListIterator<Location> pointsIterator = processedPoints.listIterator();
    Integer index = 0;
    Location loc = origin;
    int counter = 0;
    while(pointsIterator.hasNext()) {
        loc=pointsIterator.next();
        if(!(pathSequence.isEmpty())) {
            current = pathSequence.get(pathSequence.size()-1);
        }
        else if(pathSequence.isEmpty()) {
            current= origin;
        }

        if(Math.abs(current.getX() - loc.getX()) > 0 && (Math.abs(current.getX() - loc.getX())) <= 1.3 && (Math.abs(current.getY() - loc.getY())) >= 0 && (Math.abs(current.getY() - loc.getY())) < 1 && (Math.abs(current.getZ() - loc.getZ())) >= 0 && (Math.abs(current.getZ() - loc.getZ())) < 1) { 
            pathSequence.put(index, loc);
            pointsIterator.remove();
            index++;

        }
        else if( ( (Math.abs(current.getY() - loc.getY())) > 0 && (Math.abs(current.getY() - loc.getY())) <= 1.3) && (Math.abs(current.getZ() - loc.getZ())) >= 0 && (Math.abs(current.getZ() - loc.getZ())) < 1 && (Math.abs(current.getX() - loc.getX())) >= 0 && (Math.abs(current.getX() - loc.getX())) < 1) {
            pathSequence.put(index, loc);
            pointsIterator.remove();
            index++;

        }
        else if(Math.abs(current.getZ() - loc.getZ()) > 0 && (Math.abs(current.getZ() - loc.getZ())) <= 1.3 && (Math.abs(current.getY() - loc.getY())) >= 0 && (Math.abs(current.getY() - loc.getY())) < 1 && (Math.abs(current.getX() - loc.getX())) >= 0 && (Math.abs(current.getX() - loc.getX())) < 1) {
            pathSequence.put(index, loc);
            pointsIterator.remove();
            index++;

        }
        if(!(pathSequence.isEmpty())) {
            current = pathSequence.get(pathSequence.size()-1);
        }

        if(!(pointsIterator.hasNext()) && !(processedPoints.isEmpty())) {

            System.out.println("reset fired");
            counter++;

            if(processedPoints.size() == 1) {
                pathSequence.put(index, loc);
            }
            if(pointsIterator.hasPrevious()) {
            int i = processedPoints.size() - 1;

                    Collections.swap(processedPoints, (processedPoints.size() -1 ), i );
                    if(!(pathSequence.isEmpty())) {
                        current = pathSequence.get(pathSequence.size()-1);
                    }
                    while(pointsIterator.hasPrevious()) {
                        pointsIterator.previous();
                    }
                }
            }
        System.out.println(processedPoints.size()); 

        if(counter > 250) {
            break;

        }
            }
    return pathSequence;
}

}

【讨论】：