Combining a set of reversable paths - arrays

Question

I need some help recognizing this problem and finding a solution. I don't need someone to code the solution, just to say how to go about solving it.
An array of hashes, each hash containing one path, its ID, and its order (forward (F) or reverse (R))
Each path is initialized in the F position
my #paths = (
{ id => 1, path => [ A, B ], order => 'F' },
{ id => 2, path => [ C, D, E ], order => 'F' },
{ id => 3, path => [ E, B ], order => 'F' }
);
Each node or vertex of each path also has an orientation ( + or - )
my %plus_minus;
$plus_minus{1}{A} = '+';
$plus_minus{1}{B} = '+';
$plus_minus{2}{C} = '+';
$plus_minus{2}{D} = '-';
$plus_minus{2}{E} = '-';
$plus_minus{3}{E} = '-';
$plus_minus{3}{B} = '-';
You can reverse the order of a path ( e.g., [A, B] to [B, A] )
When you reverse order from F => R or R => F you also switch the orientation of each node in the path from + to - or - to +
The paths with orientations look like this:
A+ : B+
C+ : D- : E-
E- : B-
This is the problem input
For output, I'd like to know whether or not it is possible by reversing path orders to create a consensus path, and also what is the way to do this such that you are guaranteed to find the consensus path.
For example, if we reversed path 1 we'd get:
B- : A-
C+ : D- : E-
E- : B-
and the resulting consensus path would be:
C+ : D- : E- : B- : A-
But it's not clear to reverse path 1 first. For example, what if we reverse 3 first? So you can't proceed randomly.
Does anyone recognize this problem or know how to solve it?

Answer 1

What you're asking for isn't easy, and I'm not exactly clear about your requirements
This partial solution takes the brute-force approach of creating a directed graph, adding all the paths from your data and their reversals, and finding the longest path in the resulting data structure
Using your sample data, it produces the reverse of the consensus path that you expect, but according to your rules there will always be two equally valid answers if there are any at all, and because of the random nature of Perl hashes, either one may be presented as the result from one run to the next
If I have understood you correctly then you also need to ensure that the result contains all of the paths in the original data
use strict;
use warnings 'all';
use feature 'say';
use Graph::Directed;
use List::Util 'max';
use List::MoreUtils 'first_index';
my #paths = (
{ id => 1, path => [ qw[ A B ] ], order => 'F' },
{ id => 2, path => [ qw[ C D E ] ], order => 'F' },
{ id => 3, path => [ qw[ E B ] ], order => 'F' },
);
my %plus_minus;
$plus_minus{1}{A} = '+';
$plus_minus{1}{B} = '+';
$plus_minus{2}{C} = '+';
$plus_minus{2}{D} = '-';
$plus_minus{2}{E} = '-';
$plus_minus{3}{E} = '-';
$plus_minus{3}{B} = '-';
# index the array by ID
#
my %paths;
$paths{$_->{id}} = $_ for #paths;
# Incorporate the inexplicably separate plus-minus data
#
for my $id ( keys %plus_minus ) {
my $nodes = $plus_minus{$id};
for my $node ( keys %$nodes ) {
my $sign = $nodes->{$node};
my $nodes = $paths{$id}{path};
my $i = first_index { $_ eq $node } #$nodes;
die sprintf "Node $node not found in path ID $id" if $i < 0;
$nodes->[$i] .= $sign;
}
}
# Add the reverse paths to the hash:
# - Change the `order` field to `R` (original is reliably `F`)
# - Reverse the order of the elements of `path`
# - Reverse the sign of the elements of `path`
#
my $n = max map { $_->{id} } values %paths;
for my $path ( #paths ) {
my $nodes = $path->{path};
my $new_id = ++$n;
$paths{$new_id} = {
id => $new_id,
order => 'R',
path => [
map {
s/([+-])/ $1 eq '+' ? '-' : '+' /er or die;
} reverse #$nodes
],
};
}
# Build the directed graph
#
my $g = Graph::Directed->new;
for my $path ( values %paths ) {
my $nodes = $path->{path};
for my $i ( 0 .. $#$nodes - 1 ) {
$g->add_edge(#{$nodes}[$i, $i+1]);
}
}
# Report the longest path
#
say join ' : ', $g->longest_path;
output
C+ : D- : E- : B- : A-