寻找两点之间的最短路径（bfs）

Question

I have a task. I need find the shortest path between two points. For this i use breadth first search algorithm. I create class Graph which has amount of vertices, and adjacency list. Here is my code:

class Graph
{
    private int V;   
    private LinkedList<Integer> adj[]; //Adjacency Lists

    // Constructor
    Graph(int v)
    {
        V = v;
        adj = new LinkedList[v];
        for (int i=0; i<v; ++i)
            adj[i] = new LinkedList();
    }

    // Function to add an edge into the graph
    void addEdge(int v,int w)
    {
        adj[v].add(w);
    }

    // prints BFS traversal from a given source s
    void BFS(int s)
    {
        // Mark all the vertices as not visited(By default
        // set as false)
        boolean visited[] = new boolean[V];

        // Create a queue for BFS
        LinkedList<Integer> queue = new LinkedList<Integer>();

        // Mark the current node as visited and enqueue it
        visited[s]=true;
        queue.add(s);

        while (queue.size() != 0)
        {
            // Dequeue a vertex from queue and print it
            s = queue.poll();
            System.out.print(s+" ");

            // Get all adjacent vertices of the dequeued vertex s
            // If a adjacent has not been visited, then mark it
            // visited and enqueue it
            Iterator<Integer> i = adj[s].listIterator();
            while (i.hasNext())
            {
                int n = i.next();
                if (!visited[n])
                {
                    visited[n] = true;
                    queue.add(n);
                }
            }
        }
    }

    // Driver method to
    public static void main(String args[])
    {
       Graph g = new Graph(8);
        g.addEdge(0, 5);
        g.addEdge(0, 7);
        g.addEdge(1, 5);
        g.addEdge(1, 4);
        g.addEdge(1, 2);
        g.addEdge(2, 1);
        g.addEdge(2, 4);
        g.addEdge(2, 3);
        g.addEdge(3, 4);
        g.addEdge(3, 2);
        g.addEdge(4, 5);
        g.addEdge(4, 1);
        g.addEdge(4, 2);
        g.addEdge(4, 3);
        g.addEdge(5, 0);
        g.addEdge(5, 1);
        g.addEdge(5, 4);
        g.addEdge(6, 7);
        g.addEdge(7,6);
        g.addEdge(7,0);
        g.BFS(2);

        g.BFS(2);
    }
}

But i need function that print shortest path from the start index to the end. How i can organize it. Please, help me.

Answer 1

I used a recursion, where all answers will be stored in the arrayList.

getPath(int from, int to, int current, String answer)

• from - a starting point
• to - ending point
• current - just a current value
• answer - the whole path

Just add this code to the Graph class.

public ArrayList<String> answers = new ArrayList<String>();

public void printShortAnswer() {
    String realAnswer = "";
    for (String answer : answers) {
        if (realAnswer == "" || realAnswer.length() > answer.length()) {
            realAnswer = answer;
        }
    }
    System.err.println("The shortest path is: " + realAnswer);
}

//store all answers in answers
public boolean getPath(int from, int to, int current, String answer) {
    boolean visited[] = new boolean[V];
    visited[from] = true;
    visited[current] = true;

    if (current == to) {
         answers.add(answer);
        return true;
    }

    Iterator<Integer> i = adj[current].listIterator();
    while (i.hasNext())
    {
        int n = i.next();
        if (!visited[n])
        {
            visited[n] = true;
            getPath(from, to, n, answer + " " + n);
        }
    }
    return false;
}

To run it, just use this setup

  Graph g = new Graph(12);
    g.addEdge(0, 1);
    g.addEdge(0, 2);

    //set 1
    g.addEdge(1, 3);
    g.addEdge(3, 4);
    g.addEdge(4, 5);

    //set 2
    g.addEdge(2, 8);
    g.addEdge(8, 9);
    g.addEdge(9, 11);
    g.addEdge(11, 5);

    g.addEdge(0, 5);
    //g.BFS(0);

    int startPoint = 0;
    g.getPath(startPoint, 5, startPoint, startPoint + " ");
    g.printShortAnswer();

And don't forget to import ArrayList.

import java.util.ArrayList;

The output will be:

• 0 1 3 4 5
• 0 2 8 9 11 5
• 0 5
• The shortest path is: 0 5

Answer 2

Breadth-first search is appropriate here, because when you visit the destination node for the first time, you will do so via the shortest path. This works, because all edges have the same weight, 1. If edges can have different weights, the path with the fewest edges isn't necessarily the shortest one and you will need other algorithms, for example Dijkstra's .

You code doesn't check whether you have reached the destination; it just visits all nodes in breadh-first order.

You also cannot print the nodes as you go, because when you visit an adjacent unvisited node, you don't know yet whether it is part of the shortest path or whether you are going in the wrong direction.

A solution to this is to store the previous vertex, ie the one you have come from, for each vertex. For example if you start your search at vertex 0, you will visit the adjacent vertices 5 and 7. Therefore, the previous vertex for both 5 and 7 is 0.

This information can do double duty: If you use −1 to mean "no vertex", a previous vertex of −1 means that the vertex hasn't been visited yet.

When you visit the destination, just retrace your steps via the information of previous nodes until you reach the original vertex. This list will be the path from the destination to the origin.

Here's the implementation in (my poor) Java:

import java.util.LinkedList;
import java.util.Iterator;

class Graph
{
    private int V;   
    private LinkedList<Integer> adj[];

    Graph(int v)
    {
        V = v;
        adj = new LinkedList[v];

        for (int i = 0; i < v; i++) {
            adj[i] = new LinkedList();
        }
    }

    void addEdge(int v, int w)
    {
        adj[v].add(w);
    }

    LinkedList shortest(int from, int to)
    {
        LinkedList<Integer> queue = new LinkedList<Integer>();
        LinkedList<Integer> res = new LinkedList<Integer>();

        int prev[] = new int[V];

        if (from == to) return res;
        queue.add(from);

        for (int i = 0; i < V; i++) {
            prev[i] = -1;
        }        

        while (queue.size() != 0) {
            int curr = queue.poll();
            Iterator<Integer> i = adj[curr].listIterator();

            while (i.hasNext()) {
                int n = i.next();

                if (prev[n] == -1) {                // unvisited?
                    prev[n] = curr;                 // store previous vertex

                    if (n == to) {                  // we're finally there!
                        while (n != from) {         // build result list ...
                            res.addFirst(n);
                            n = prev[n];
                        }

                        return res;                 // ... and return it
                    }                    

                    queue.add(n);
                }
            }
        }

        return res;
    }

    public static void main(String args[])
    {
        Graph g = new Graph(9);

        g.addEdge(0, 5);
        g.addEdge(0, 7);
        g.addEdge(1, 5);
        g.addEdge(1, 4);
        g.addEdge(1, 2);
        g.addEdge(2, 1);
        g.addEdge(2, 4);
        g.addEdge(2, 3);
        g.addEdge(3, 4);
        g.addEdge(3, 2);
        g.addEdge(4, 5);
        g.addEdge(4, 1);
        g.addEdge(4, 2);
        g.addEdge(4, 3);
        g.addEdge(5, 0);
        g.addEdge(5, 1);
        g.addEdge(5, 4);
        g.addEdge(6, 7);
        g.addEdge(7,6);
        g.addEdge(7,0);

        for (int a = 0; a < 9; a++) {
            System.out.print("--- ");
            System.out.println(a);

            for (int b = 0; b < 9; b++) {
                System.out.println(g.shortest(a, b));                
            }
        }    
    }
}