复杂决策树生成器

Question

我正在尝试编写一种二叉树，但是它很大，我不想在内存中保存每个元素。 我希望在需要时使用生成器函数构造每个节点。

树在游戏中为决策建模。 游戏以n个选项的框架开始。 播放器选择两个选项（不能相同），然后使用不同的操作组合它们。 因此，一帧具有（n *（n-1））* t个可能采取的步骤，其中t是操作数。

做出决定后，将生成n-1个选项的新帧，其中上次选择的两个选项已删除，但这些选项的结果已包括在内。 现在，可能的不同选择的数量为（（n-1）*（n-2））* t 。 此过程一直持续到当前帧中的选项数<= 1为止。

我想以一种特定的方式在决策树中遍历所有可能的路线-在继续前进到下一条可能的路线（从最大的路线开始）之前，将所有路线一直遍历到最后一帧（其中n = 1）帧（大小= n ），但在每个帧中采用下一个选择范围。 除了我在这里描述的内容外，决策的结果与这些目的无关。 所有路线都必须一直到达最后一帧（其中n = 1）-我不需要包括部分遍历的路线。

我有以下代码，我想生成要制定的决策图。 ：

public class PathStep
{
    public int FrameSize;
    public int Index1;
    public int Index2;
    public int Operation;

    public override string ToString()
    {
        return String.Format("F:{0} I1:{1} I2:{2} O{3}", this.FrameSize, this.Index1, this.Index2, this.Operation);
    }
}

public class Frame
{
    public int Size { get; private set; }

    public Frame(int size)
    {
        this.Size = size;
    }

    public IEnumerable<PathStep> AllPossibleSteps()
    {
        return this.step_helper(this.Size, 0);
    }

    private IEnumerable<PathStep> step_helper(int frame_size, int depth)
    {
        throw new NotImplementedException(); //TODO
    }


    private static IEnumerable<Frame> frames_in_game(int initial_frame_size)
    {
        for (var i = initial_frame_size; i > 0; i--)
            yield return new Frame(i);
    }

    private static IEnumerable<PathStep> steps_in_frame(int frame_size)
    {
        int op_count = Operation.Operations().Count();

        for (var first = 0; first < frame_size; first++)
        {
            for (var second = 0; second < frame_size - 1; second++)
            {
                for (var i = 0; i < op_count; i++)
                {
                    yield return new PathStep() { FrameSize = frame_size, Index1 = first, Index2 = second, Operation = i };
                }
            }
        }
    }



}

如何填充step_helper方法以映射树中决策的每个可能变化，并以连续游戏的顺序产生决策？ 我需要覆盖所有可能的路线，并yield return顺序yield return给定路线中的每个步骤，但是只要我覆盖所有路线，我采用完整路线的顺序就无关紧要。

Answer 1

我重新考虑了我的问题，并意识到以下几点：

如果n *（n -1）* t = options_per_frame

然后，我可以将每个路径表示为选项网格，该选项网格（如果已索引1）从以下位置开始：

   let t = 4

   n |n-1|t | n = ?
   1 |1  |1 | 6
   1 |1  |1 | 5
   1 |1  |1 | 4
   1 |1  |1 | 3
   1 |1  |1 | 2

其次是：

   n |n-1|t | n = ?
   1 |1  |1 | 6
   1 |1  |1 | 5
   1 |1  |1 | 4
   1 |1  |1 | 3
   1 |1  |2 | 2

并以

   n |n-1|t | n = ?
   6 |5  |4 | 6
   5 |4  |4 | 5
   4 |3  |4 | 4
   3 |2  |4 | 3
   2 |1  |4 | 2

单元格中的每个值都表示所选选项的索引/ ID，而标题则指定可以放入单元格中的最大值。 因此，您可以将其想像成一个时钟，其中使用大小不同的“齿轮”彼此旋转，以便随着幅度减小而级联下降。 在时间上，每秒1000毫秒“旋转”，60秒“每小时旋转”，24小时“一天旋转”等。因此，我创建了一个PathGrid类，该类返回了网格的下一个迭代，这使我可以遵循所有路径无需建模树或使用递归。 我已经在这里上传了我的解决方案。