如果您真正关心的是从最短路径到最长路径的顺序排序，那么使用改进的A *或Dijkstra算法会更好。稍作修改，该算法将以最短路径优先的顺序返回所需的尽可能多的路径。因此，如果您真正想要的是从最短到最长的所有可能路径排序，那么这就是要走的路。
如果您想要一个基于A *的实现，该实现能够返回从最短到最长的所有路径排序，那么下面的操作将实现这一点。它有几个优点。首先，它可以有效地从最短到最长排序。此外，它仅在需要时才计算每个其他路径，因此如果您由于不需要每个路径而提早停止，则可以节省一些处理时间。每次计算下一条路径时，它还会为后续路径重用数据，因此效率更高。最后，如果找到了所需的路径，则可以中止，从而节省一些计算时间。总体而言，如果您关心按路径长度排序，那么这应该是最有效的算法。
import java.util.*;
public class AstarSearch {
private final Map<Integer, Set<Neighbor>> adjacency;
private final int destination;
private final NavigableSet<Step> pending = new TreeSet<>();
public AstarSearch(Map<Integer, Set<Neighbor>> adjacency, int source, int destination) {
this.adjacency = adjacency;
this.destination = destination;
this.pending.add(new Step(source, null, 0));
}
public List<Integer> nextShortestPath() {
Step current = this.pending.pollFirst();
while( current != null) {
if( current.getId() == this.destination )
return current.generatePath();
for (Neighbor neighbor : this.adjacency.get(current.id)) {
if(!current.seen(neighbor.getId())) {
final Step nextStep = new Step(neighbor.getId(), current, current.cost + neighbor.cost + predictCost(neighbor.id, this.destination));
this.pending.add(nextStep);
}
}
current = this.pending.pollFirst();
}
return null;
}
protected int predictCost(int source, int destination) {
return 0;
}
private static class Step implements Comparable<Step> {
final int id;
final Step parent;
final int cost;
public Step(int id, Step parent, int cost) {
this.id = id;
this.parent = parent;
this.cost = cost;
}
public int getId() {
return id;
}
public Step getParent() {
return parent;
}
public int getCost() {
return cost;
}
public boolean seen(int node) {
if(this.id == node)
return true;
else if(parent == null)
return false;
else
return this.parent.seen(node);
}
public List<Integer> generatePath() {
final List<Integer> path;
if(this.parent != null)
path = this.parent.generatePath();
else
path = new ArrayList<>();
path.add(this.id);
return path;
}
@Override
public int compareTo(Step step) {
if(step == null)
return 1;
if( this.cost != step.cost)
return Integer.compare(this.cost, step.cost);
if( this.id != step.id )
return Integer.compare(this.id, step.id);
if( this.parent != null )
this.parent.compareTo(step.parent);
if(step.parent == null)
return 0;
return -1;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Step step = (Step) o;
return id == step.id &&
cost == step.cost &&
Objects.equals(parent, step.parent);
}
@Override
public int hashCode() {
return Objects.hash(id, parent, cost);
}
}
private static class Neighbor {
final int id;
final int cost;
public Neighbor(int id, int cost) {
this.id = id;
this.cost = cost;
}
public int getId() {
return id;
}
public int getCost() {
return cost;
}
}
public static void main(String[] args) {
final Map<Integer, Set<Neighbor>> adjacency = createAdjacency();
final AstarSearch search = new AstarSearch(adjacency, 1, 4);
System.out.println("printing all paths from shortest to longest...");
List<Integer> path = search.nextShortestPath();
while(path != null) {
System.out.println(path);
path = search.nextShortestPath();
}
}
private static Map<Integer, Set<Neighbor>> createAdjacency() {
final Map<Integer, Set<Neighbor>> adjacency = new HashMap<>();
addAdjacency(adjacency, 1,2,1,5,1);
addAdjacency(adjacency, 2,1,1,3,1,4,1,5,1);
addAdjacency(adjacency, 3,2,1,5,1);
addAdjacency(adjacency, 4,2,1);
addAdjacency(adjacency, 5,1,1,2,1,3,1);
return Collections.unmodifiableMap(adjacency);
}
private static void addAdjacency(Map<Integer, Set<Neighbor>> adjacency, int source, Integer... dests) {
if( dests.length % 2 != 0)
throw new IllegalArgumentException("dests must have an equal number of arguments, each pair is the id and cost for that traversal");
final Set<Neighbor> destinations = new HashSet<>();
for(int i = 0; i < dests.length; i+=2)
destinations.add(new Neighbor(dests[i], dests[i+1]));
adjacency.put(source, Collections.unmodifiableSet(destinations));
}
}
上面代码的输出如下：
[1, 2, 4]
[1, 5, 2, 4]
[1, 5, 3, 2, 4]
请注意，每次致电 nextShortestPath()它会根据需要为您生成下一条最短路径。它仅计算所需的额外步骤，并且不会遍历任何旧路径两次。而且，如果您决定不需要所有路径并尽早结束执行，则可以节省大量的计算时间。您只计算最多所需的路径数，而无需再计算。
最后应该指出的是，尽管我认为A *和Dijkstra算法不会对您造成影响，但确实存在一些较小的限制。也就是说，它在权重为负的图形上无法正常工作。
这是JDoodle的链接，您可以在其中自行在浏览器中运行代码并查看其工作情况。您还可以在图表周围进行更改，以显示它也可以在其他图表上使用：http : //jdoodle.com/a/ukx
