保存广度优先搜索中遍历的边 Java

Question

Below is my bfs algorithm, the algorithm works and finds the node given the start and target. But I want to save edges for the used path in a linkedList to draw the path.

My BFS:

public DGPath breadthFirstSearch(String startId, String targetId) {

        V start = this.getVertexById(startId);
        V target = this.getVertexById(targetId);
        if (start == null || target == null) return null;

        DGPath path = new DGPath();
        path.start = start;
        path.visited.add(start);

        // easy target
        if (start == target) return path;

        // TODO calculate the path from start to target by breadth-first-search
        //  register all visited vertices while going, for statistical purposes
        //  if you hit the target: complete the path and bail out !!!
        Queue<V> fifoQueue = new LinkedList<>();
        Map<V,V> visitedFrom = new HashMap<>();

        fifoQueue.offer(start);
        visitedFrom.put(start, null);

        while (!fifoQueue.isEmpty()) {
            V current = fifoQueue.poll();
            for (E e : current.getEdges()) {
                V neighbour = e.getTo();
                path.visited.add(neighbour);
                if (neighbour == target) {
                    while (current != null) {
                        path.getEdges().addFirst(e);
                        current = visitedFrom.get(current);

                    }
                    return path;
                } else if (!visitedFrom.containsKey(neighbour)) {
                    visitedFrom.put(neighbour,current);
                    fifoQueue.offer(neighbour);
                }
            }
        }


        // no path found, graph was not connected ???
        return null;
    }

The DGPath is the class that creates the path as shown below:

public class DGPath {
        private V start = null;
        private LinkedList<E> edges = new LinkedList<>();
        private double totalWeight = 0.0;
        private Set<V> visited = new HashSet<>();

        /**
         * representation invariants:
         * 1. The edges are connected by vertices, i.e. FOR ALL i: 0 < i < edges.length: edges[i].from == edges[i-1].to
         * 2. The path begins at vertex == start
         * 3. if edges is empty, the path also ends at vertex == start
         * otherwise edges[0].from == start and the path continues along edges[i].to for all 0 <= i < edges.length
         **/

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder(
                    String.format("Weight=%f Length=%d Visited=%d (",
                            this.totalWeight, 1 + this.edges.size(), this.visited.size()));
            sb.append(start.getId());
            for (E e : edges) {
                sb.append(", " + e.getTo().getId());
            }
            sb.append(")");
            return sb.toString();
        }

        public V getStart() {
            return start;
        }

        public LinkedList<E> getEdges() {
            return edges;
        }

        public double getTotalWeight() {
            return totalWeight;
        }

        public Set<V> getVisited() {
            return visited;
        }
    }

I want to save the right edges in de linkedlist edges from the BGPath class (called path in my BFS algo method). So I already saved the used vertices in a map to go back to the root. But when I add the edge to the path it just saves the last edge used multiple times.. The problem is the vertex can have multiple edges, so I need to add the edge from the previous that was pointing to the last "current" until I'm back to the root. But I cant wrap my head around the right way to do this.

The line where I now add the edge to the list of edges is: path.getEdges().add(e)

Answer 1

I think, your problem is the same line, where your are adding the edges, that line is adding the same edge in inner while loop again and again, so you are only traversing back but not adding those nodes to your edges list.

I think, it should be like this

while (!fifoQueue.isEmpty()) {
            V current = fifoQueue.poll();
            for (E e : current.getEdges()) {
                V neighbour = e.getTo();
                path.visited.add(neighbour);
                if (neighbour == target) {
                    path.getEdges().addFirst(e):
                    while (current != null) {
                        path.getEdges().addFirst(current) ;
                        current = visitedFrom.get(current);
                    }
                    return path;
                } else if (!visitedFrom.containsKey(neighbour)) {
                    visitedFrom.put(neighbour,current);
                    fifoQueue.offer(neighbour);
                }
            }
        }


        // no path found, graph was not connected ???
        return null;
    }