Question

I am trying to determine the best time efficient algorithm to accomplish the task described below.

I have a set of records. For this set of records I have connection data which indicates how pairs of records from this set connect to one another. This basically represents an undirected graph, with the records being the vertices and the connection data the edges.

All of the records in the set have connection information (i.e. no orphan records are present; each record in the set connects to one or more other records in the set).

I want to choose any two records from the set and be able to show all simple paths between the chosen records. By ‘simple paths’ I mean the paths which do not have repeated records in the path (i.e. finite paths only).

Note: The two chosen records will always be different (i.e. start and end vertex will never be the same; no cycles).

For example:

     If I have the following records:         A, B, C, D, E      and the following represents the connections:          (A,B),(A,C),(B,A),(B,D),(B,E),(B,F),(C,A),(C,E),         (C,F),(D,B),(E,C),(E,F),(F,B),(F,C),(F,E)          [where (A,B) means record A connects to record B] 

If I chose B as my starting record and E as my ending record, I would want to find all simple paths through the record connections that would connect record B to record E.

    All paths connecting B to E:       B->E       B->F->E       B->F->C->E       B->A->C->E       B->A->C->F->E 

This is an example, in practice I may have sets containing hundreds of thousands of records.

Answer 1

It appears that this can be accomplished with a depth-first search of the graph. The depth-first search will find all non-cyclical paths between two nodes. This algorithm should be very fast and scale to large graphs (The graph data structure is sparse so it only uses as much memory as it needs to).

I noticed that the graph you specified above has only one edge that is directional (B,E). Was this a typo or is it really a directed graph? This solution works regardless. Sorry I was unable to do it in C, I’m a bit weak in that area. I expect that you will be able to translate this Java code without too much trouble though.

Graph.java:

import java.util.HashMap; import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.Map; import java.util.Set;  public class Graph {     private Map<String, LinkedHashSet<String>> map = new HashMap();      public void addEdge(String node1, String node2) {         LinkedHashSet<String> adjacent = map.get(node1);         if(adjacent==null) {             adjacent = new LinkedHashSet();             map.put(node1, adjacent);         }         adjacent.add(node2);     }      public void addTwoWayVertex(String node1, String node2) {         addEdge(node1, node2);         addEdge(node2, node1);     }      public boolean isConnected(String node1, String node2) {         Set adjacent = map.get(node1);         if(adjacent==null) {             return false;         }         return adjacent.contains(node2);     }      public LinkedList<String> adjacentNodes(String last) {         LinkedHashSet<String> adjacent = map.get(last);         if(adjacent==null) {             return new LinkedList();         }         return new LinkedList<String>(adjacent);     } } 

Search.java:

import java.util.LinkedList;  public class Search {      private static final String START = 'B';     private static final String END = 'E';      public static void main(String[] args) {         // this graph is directional         Graph graph = new Graph();         graph.addEdge('A', 'B');         graph.addEdge('A', 'C');         graph.addEdge('B', 'A');         graph.addEdge('B', 'D');         graph.addEdge('B', 'E'); // this is the only one-way connection         graph.addEdge('B', 'F');         graph.addEdge('C', 'A');         graph.addEdge('C', 'E');         graph.addEdge('C', 'F');         graph.addEdge('D', 'B');         graph.addEdge('E', 'C');         graph.addEdge('E', 'F');         graph.addEdge('F', 'B');         graph.addEdge('F', 'C');         graph.addEdge('F', 'E');         LinkedList<String> visited = new LinkedList();         visited.add(START);         new Search().depthFirst(graph, visited);     }      private void depthFirst(Graph graph, LinkedList<String> visited) {         LinkedList<String> nodes = graph.adjacentNodes(visited.getLast());         // examine adjacent nodes         for (String node : nodes) {             if (visited.contains(node)) {                 continue;             }             if (node.equals(END)) {                 visited.add(node);                 printPath(visited);                 visited.removeLast();                 break;             }         }         for (String node : nodes) {             if (visited.contains(node) || node.equals(END)) {                 continue;             }             visited.addLast(node);             depthFirst(graph, visited);             visited.removeLast();         }     }      private void printPath(LinkedList<String> visited) {         for (String node : visited) {             System.out.print(node);             System.out.print(' ');         }         System.out.println();     } } 

Program Output:

B E  B A C E  B A C F E  B F E  B F C E