JustLearning's questions

Tenho dois aliases para gerenciar uma coleção de estados para uma máquina de estados de brinquedo usando ponteiros inteligentes:

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

O exemplo acima tem dois estados, mas eu quero, digamos, 40. Pergunta para minha própria educação: como usar modelos variádicos (ou qualquer outra estratégia) para evitar repetir a typelist de 40 anos em ambos os aliases? Estou tentando evitar usar uma biblioteca TMP externa.

Pergunta possivelmente relacionada: Quero que o objeto sob cuja estrutura esses aliases são definidos possua os estados. Usar ponteiros inteligentes é o caminho a seguir aqui se estou preocupado que cada estado na minha máquina seja muito grande para manter todos eles na pilha? Espero que a pergunta faça sentido.

Tenho um conjunto de N compostos químicos enumerados 1, 2,..., N. Para cada composto, tenho a fração de cada um de seus constituintes, “A”, “B” e assim por diante. Os compostos também podem conter outros compostos, caso em que a fração correspondente é fornecida. Por exemplo, para N = 5, um conjunto de amostra é

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
    }
}

Eu gostaria de um algoritmo que fornecesse a fração líquida de cada constituinte em cada composto, ou seja,

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
    }
}

Minha abordagem atual envolve recursão, mas gostaria de saber se existe uma maneira inteligente de fazer isso. Talvez usar uma estrutura de dados semelhante a uma árvore possa ajudar?

EDIT: para simplificar, suponha que não haja relacionamentos cíclicos no conjunto de dados.