我有一个由至少15个顶点组成的无向加权图(G)。给定一组顶点(G'),其中G' ⊆G,我需要计算穿越G'所需的最短路径。给出起始顶点(v)。 我卡住了! 我尝试了以下方法:
for (Vertex vx : G'):
computeShortestPath (v, vx)//using Dijkstra's algo
V与G'中任何顶点之间生成的所有路径中最短的路径。然后将构成初始化路径(P)。然后从G'中移除所有顶点。在P
中访问过的G'.remove (P)
递归计算P直到:
G'.size () == 0
我的算法有时似乎效率低下!有什么建议对这个问题采取不同的补救措施?
编辑:我需要访问G'中的每个节点。只有一次。
答案 0 :(得分:2)
如果我正确理解你的问题,那么基本上是Travelling Salesman问题已被证明是NP难的:没有有效的解决方案来解决这个问题。您提出的任何解决方案都需要随节点数量呈指数级增长的资源。有效的解决方案可以返回最可能的最短路径或迭代到最短路径。有一些算法可以在开始搜索之前确定是否有路径。
Djikstra的算法用于查找通过图表的最短路径,而不是访问所有节点的最短路径。
对于少量节点,最简单的解决方案是对所有路径进行详尽搜索。这看起来像是:
class PathFinder {
Path shortestPath;
public void findShortestPath(Path currentPath, List<Node> remainingNodes) {
if (remainingNodes.isEmpty()) {
if (currentPath.isShorterThan(shortestPath)) {
shortestPath = currentPath;
}
} else {
for (Node node: currentPath.possibleNextNodes(remainingNodes)) {
remainingNodes.remove(node);
currentPath.add(node);
findShortestPath(currentPath, remainingNodes);
currentPath.remove(node);
remainingNodes.add(node);
}
}
}
}
出于效率原因,此算法不会复制剩余节点的路径或列表。它可以找到15个节点的图形。对于数以千计的节点而言并非如此。
这要求您实施Path
和Node
类。以下是它们可能的部分实现:
public class Node {
private class Link {
private final Node destination;
private final int weight;
private Link(Node destination, int weight) {
this.destination = destination;
this.weight = weight;
}
private final List<Link> links;
public void addLink(Node destination, int weight) {
if (!connectsTo(destination)) {
Link link = new Link(destination, weight);
destination.addLink(this, weight);
}
}
public boolean connectsTo(Node node) {
return links.stream.anyMatch(link -> link.destination.equals(node));
}
public int weightTo(Node node) {
return links.stream.filter(link -> link.destination.equals(node))
.findAny().orElse(0);
}
}
public class Path {
private int length;
private List<Node> nodes;
private Node lastNode() {
return nodes.get(nodes.size() - 1);
}
public List<Node> possibleNextNodes(List<Node> possibleNodes) {
if (nodes.isEmpty());
return possibleNodes;
return possibleNodes.stream()
.filter(node -> lastNode().connectsTo(node))
.filter(node -> !nodes.contains(node))
.collect(Collectors.toList());
}
public boolean isShorterThan(Path other) {
return this.length < other.length;
}
public void add(Node node) {
length += lastNode().distanceTo(node);
nodes.add(node);
}
}