A quick solution to your issue (with a complexity of O((n*m)^2) (n being the number of levels and m the maximum nodes per level):

• as a structure for your nodes, simply have a hash with the name of the node-level (A, B, ...) and the numbers of nodes on that level

• As an algorithm, try the following
• traverse through each level
• generate all possible node-names of that level
• take all paths you already found and add the new node-names to each of them

The code below solves your issue. It is however just a short hack and in no way optimized. But it hopefully gives you an idea.

HTH, Rata

use strict;
use warnings;

my %nodes = (  A => 2,  B => 4,  C => 5, D => 1);
            
my @path = ("");
my @newpath;
    
foreach my $k (sort (keys(%nodes)))                    # each level
{
    my @nodename;
    for (my $i = 1; $i <= $nodes{$k}; $i++)
    {
        push (@nodename, "$k$i");                           # generate
+ node-names for each level
    }
    
    foreach my $old (@path)                                # take all 
+old paths
    {
        foreach my $new (@nodename)                            # appen
+d new node to each
        {
            push (@newpath, "$old-$new");
        }
    }
    @path = @newpath;                                          # save 
+old paths
    @newpath  = ();                                        # clear lis
+t of new paths
}
print join("\n", @path);    # print all paths (each in a new line)
exit 0;
[download]

Thanks,this works really well, i will be building my code on this code.

The enhancement I am doing is also print a list of all the nodes, and the paths passing through the nodes. for example node B2 may have paths 2,4,6,8,9 passing thorough it. Path number is the element number of @path+1.

Imagine, all nodes are bus stops, and the paths are buses. A bus has to stop at all nodes it passes through. So when going from level 1 to level 5, it has to pass through 1 node of each intermediate level.

Well, maybe the 45 does. I always try to avoid the 45.