计算无向加权图中一组顶点之间的最短路径

Question

I have an undirected weighted graph (G) composed of at least 15 vertices. Given a set of vertices (G'), where G' ⊆ G, I need to calculate the shortest path required to traverse G' given a start vertex (v). I am stuck! I tried the following:

for (Vertex vx : G'):
    computeShortestPath (v, vx)//using Dijkstra's algo

The shortest of all the paths generated between V and any vertex from G' will then constitute the initialized path (P).I then remove all vertices from G' that have been visited in P

G'.remove (P)

Recursively compute P until:

G'.size () == 0

My algorithm seems inefficient at times though! Any suggestions into different remedies to this problem?

Edit: I need to visit every node in G' only once.

Answer 1

If I understand your problem correctly then it is, essentially, the Travelling Salesman problem which has been proven to be NP-hard: there is no efficient solution to this problem. Any solution you come up with requires resources that increase exponentially with the number of nodes. There are efficient solutions for returning the most likely shortest path or to iterate towards the shortest path. There are algorithms for determining if there is a path before starting the search.

Djikstra's algorithm is used to find the shortest path through the graph rather than the shortest path that visits all nodes.

For small numbers of nodes the easiest solution is an exhaustive search of all paths. This will look something like:

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);
            }
        }
    }
}

This algorithm does not copy the path or list of remaining nodes for efficiency reasons. It will work find for graphs of 15 nodes. For thousands of nodes not so much.

This requires you to implement Path and Node classes. Here is a possible partial implementation of them:

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);
    }
}