Question

Has the following problem got a name and is there an algorithm to solve it? :
Given a graph, either directed or not, find all the paths which satisfy the specification given by

1. a list of exact nodes, or
2. ‘*?’ which denotes just ‘any node or no node at all’, or
3. ‘*{n}’ which denote ‘any n consecutively connected nodes’

e.g.

A -> B -> *? -> D which results in ABXD and ABYD and ABD etc.

or

A -> *{1} -> D -> *? -> E which results in ABXDZE and ABYDZE and ABDZE etc. etc.

thanks

p.s.
Does anyone know a graph library doing this either in R or perl or C?

Answer 1

What I did at the end was:

1. The problem is to find all paths of length N between 2 nodes. Cycles are excluded.
2. read the data in as an edgelist, e.g. pairs of from->to nodes (names of nodes are assumed to be unique)
3. create a hashtable (or unordered_map in boost and stl, c++) of node names as keys and a hashtable as a value.
4. this second hashtable will contain all nodes the first node leads to as keys.

For example

A->B
A->C
B->D
C->E
E->D

the resultant data structure holding the input data in perl notation looks like this after reading in all the data as an ‘edgelist’:

my %hash = (
'A' => {'B' => 1, 'C' => 1},
'B' => {'D' => 1},
'C' => {'E' => 1},
'E' => {'D' => 1},
);

finding if a pair of nodes is DIRECTLY connected can be done roughly as (perl):

sub search {
    my ($from,$to) = @_;
    if( $to eq '*' ){ return defined($x=$hash{$from}) ? [keys $hash{$from}] : [] }
    return defined($x=$hash{$from}) && defined($x{$to}) ? [$to] : []
}

In the above function there is provision to return all the nodes a ‘from’ node is connected to, by setting $to to ‘*’. The return is an array ref of nodes connected directly to the $from parameter.

Searching for the path between two nodes requires using the above function recursively.

e.g.

sub path {
    my ($from,$to, $hops, $save_results) = @_;
    if( $hops < 0 ){ return 0 }
    $results = search($from, '*');
    if( "".@$results == 0 ){ return 0 }
    $found = 0;
    foreach $result (@$results){
        $a_node = new Tree::Nary($result);
        if( path($result, $to, $hops-1, $a_node) == 1 ){
            $save_results->insert($save_results, -1, $a_node);
            $found = 1;
        }
    }
    return $found;

}

It’s ok to use recursion if the depth is not too much (i.e. $hops < 6 ?) because of stack overflow [sic].

The most tricky part is to read through the results and extract the nodes for each path. After a lot of deliberation I decided to use a Tree::Nary (n-ary tree) to store the results. At the end we have the following tree:

     |-> B -> D
A -> |-> C -> E -> D

In order to extract all the paths, do:

1. find all the leaf nodes
2. start from each leaf node moving backwards via its parent to the root node and saving the node name.

The above was implemented using perl, but have also done it in C++ using boost::unordered_map for hashtable. I haven’t yet added a tree structure in then C++ code.

Results: for 3281415 edges and 18601 unique nodes, perl takes 3 mins to find A->’*’->’*’->B. I will give an update on the C++ code when ready.