Эффективный метод для извлечения всех перестановок древовидной структуры

Отредактировано для большего дерева, для получения дополнительных примеров.

У меня есть древовидная структура, в которой мне нужно сгенерировать все возможные перестановки с некоторыми ограничениями. Для такого дерева:

    A1----(B1, B2)
     \    
      \___(C1)
             \__(E1, E2)
/       
-  A2----(B3, B4)
\     \     \
       \     \__(D1)
        \
         \_(F1, F2)
                |
                (D4)   

    A3----(B5, B6)
                \__(D2, D3)

Или, если это немного расплывчато, та же структура, что и с надписью Perl:

my $nodes = [
{
    name => 'A1',
    children => [
        [ { name => 'B1', children => []  }, 
          { name => 'B2', children => []  }
        ],
        [
          { name => 'C1', 
                    children => [
                        [
                            { name => 'E1', children => [] },
                            { name => 'E2', children => [] }
                        ]
                    ]
            }
        ]
    ]
},
{
    name => 'A2',
    children => [
        [ { name => 'B3', 
                children => [
                    [
                        { name => 'D1', children => [] }
                    ]
                ] 
          },
          { name => 'B4', children => [] }
        ],
        [
          { name => 'F1', children => [] },
          { name => 'F2', children => [
                        [ { name => 'D4', children => [] } ]
                    ]
            }
        ]
    ]
},
{
    name => 'A3',
    children => [
        [ { name => 'B5', children => [] },
          { name => 'B6', children => [
                    [ { name => 'D2', children => [] },
                      { name => 'D3', children => [] }
                    ] 
                ]                 
            }
        ]
    ]
}

];

(Честно говоря, если вы можете понять это в читаемом Perl, я тоже это сделаю.)

Я ищу, чтобы пересечь дерево и получить все возможные "пути" с верхнего уровня вниз. Все дочерние группы node должны быть представлены ровно 1 членом в "пути". Например, в A1 необходимо представить один из (B1, B2) и один из (C1). Поэтому каждый путь, спускающийся с A1, начинается с:

A1 B1 C1

или

A1 B2 C1

Если у B1, B2 или C1 есть дети, они также должны быть представлены.

Используя это вручную, вы получите следующие возможности:

A1 B1 C1 E1
A1 B1 C1 E2
A1 B2 C1 E1
A1 B2 C1 E2

A2 B3 D1 F1
A2 B3 D1 F2 D4
A2 B4 F1
A2 B4 F2 D4

A3 B5
A3 B6 D2
A3 B6 D3

Каждый node здесь является объектом DataRow:

internal class DataRow
{
    internal string tag = "";
    internal int id = 0;
    internal Dictionary<string, List<DataRow>> children = null;

    internal DataRow(int id, string tagname)
    {
        this.tag = tagname;
        this.id = id;
    }        internal void AddChildren(string type, List<DataRow> drList)
    {
        if (children == null)
            children = new Dictionary<string, List<DataRow>>();
        if (!children.ContainsKey(type))
            children[type] = new List<DataRow>();
        children[type].AddRange(drList);
    }
    internal void AddChild(string type, DataRow dr)
    {
        List<DataRow> drList = new List<DataRow>();
        drList.Add(dr);
        AddChildren(type, drList);
    }
    public override string ToString()
    {
        return this.tag + " " + this.id;
    }
}

Чтобы создать образец дерева выше (за исключением уровней E и F, добавленных позже):

        DataRow fullList = new DataRow(null, "");
        DataRow dr, dr2, dr3;

        // First node above
        dr = new DataRow(1, "A");
        List<DataRow> drList = new List<DataRow>();
        drList.Add(new DataRow(1, "B"));
        drList.Add(new DataRow(2, "B"));
        dr.AddChildren("B", drList);
        drList.Clear();
        dr2 = new DataRow(1, "C");
        dr2.AddChild("C", new DataRow(1, "E"));
        dr2.AddChild("C", new DataRow(2, "E"));
        drList.Add(dr2);
        dr.AddChildren("C", drList);
        fullList.AddChild("A", dr);


        // Second Node above (without the "F" stuff)
        drList.Clear();
        dr = new DataRow(3, "B");
        dr.AddChild("D", new DataRow(1, "D"));
        drList.Add(dr);
        drList.Add(new DataRow(4, "B"));
        dr = new DataRow(2, "A");
        dr.AddChildren("B", drList);
        fullList.AddChild("A", dr);

        // Third node above
        drList.Clear();
        dr3 = new DataRow(6, "B");
        dr3.AddChild("B", new DataRow(2, "D"));
        dr3.AddChild("B", new DataRow(3, "D"));
        dr2 = new DataRow(3, "A");
        dr2.AddChild("B", new DataRow(5, "B"));
        dr2.AddChild("B", dr3);
        fullList.AddChild("A", dr2);

Прогулка по всему дереву тривиальна:

    internal void PermutedList()
    {
        if ( children == null ) return;
        foreach (string kidType in children.Keys)
        {
            foreach (DataRow dr in children[kidType])
            {
                dr.PermutedList();
            }
        }
    }

Но это не то, что мне нужно. Эта проблема - полное древовидное движение, но в определенном порядке. Что я не получу? Что это за прогулка?

У меня есть грязная и медленная реализация этого, которую я написал в Perl 10 лет назад, но я больше не могу расшифровывать свой собственный код (позор мне!).

Edit: График и приведенные ниже списки были расширены, код не имеет.

Если бы я мог описать график, я мог бы запрограммировать его. Если бы я знал, как это называется, я мог бы найти его. Но я не могу. Поэтому позвольте мне немного пояснить.

Имена ковша несущественны!

Каждый node имеет "ведра детей". A1 имеет два ведра, один из которых содержит "B", а другой - "C". Если бы все, что у него было (и у C не было ковшей под ним), у меня были бы "A1 B1 C1" и "A1 B2 C1" - по крайней мере один представитель от всех присутствующих дочерних ведер.

Итак, я думаю, что каждому ковшу нужен кросс-продукт его детей (полностью вниз).