JustLearning's questions

我有两个别名来使用智能指针管理玩具状态机的状态集合：

using States = std::tuple<std::shared_ptr<State1>, std::shared_ptr<State2>>;
using CurrentState = std::variant<std::shared_ptr<State1>, std::shared_ptr<State2>>;

上面的例子有两个状态，但我想要 40 个。我自己的教育问题是：如何使用可变参数模板（或任何其他策略）来避免在两个别名中重复 40 个长的类型列表？我试图避免使用外部 TMP 库。

可能相关的问题：我希望这些别名定义在其结构下的对象拥有这些状态。如果我担心我的机器中的每个状态都太大而无法将它们全部保存在堆栈中，那么使用智能指针是解决问题的方法吗？希望这个问题有意义。

我有一组 N 种化合物，分别为 1, 2,..., N。对于每种化合物，我都有其每种成分的分数，“A”，“B”等。化合物还可以包含其他化合物，在这种情况下给出相应的分数。例如，对于 N = 5，样本集为

mixes = {
    1: {
        "A": 0.32,
        "B": 0.12,
        "C": 0.15,
        2: 0.41
    },
    2: {
        "C": 0.23,
        "D": 0.12,
        "E": 0.51,
        4: 0.14
    },
    3: {
        "A": 0.24,
        "E": 0.76
    },
    4: {
        "B": 0.13,
        "F": 0.01,
        "H": 0.86
    },
    5: {
        "G": 0.1,
        2: 0.4,
        3: 0.5
    }
}

我想要一种算法，可以给出每种化合物中每种成分的净分数，即

mixes = {
    1: {
        "A": 0.32,
        "B": 0.12 + 0.41 * 0.14 * 0.13,
        "C": 0.15 + 0.41 * 0.23,
        "D": 0.41 * 0.12,
        "E": 0.41 * 0.51,
        "F": 0.41 * 0.14 * 0.01,
        "H": 0.41 * 0.14 * 0.86
    },
    2: {
        "B": 0.14 * 0.13,
        "C": 0.23,
        "D": 0.12,
        "E": 0.51,
        "F": 0.14 * 0.01,
        "H": 0.14 * 0.86
    },
    3: {
        "A": 0.24,
        "E": 0.76
    },
    4: {
        "B": 0.13,
        "F": 0.01,
        "H": 0.86
    },
    5: {
        "A": 0.5 * 0.24,
        "G": 0.1,
        "B": 0.4 * 0.14 * 0.13,
        "C": 0.4 * 0.23,
        "D": 0.4 * 0.12,
        "E": 0.4 * 0.51 + 0.5 * 0.76,
        "F": 0.4 * 0.14 * 0.01,
        "H": 0.4 * 0.14 * 0.86
    }
}

我目前的方法涉及递归，但我想知道是否有一个聪明的方法来做到这一点。也许使用树状数据结构可能会有所帮助？

编辑：为了简单起见，假设数据集中没有循环关系。