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

 std::stack<std::queue<int>> sq;

            // стек PN всех чиновников поставивших подписи,
            // начиная с самых нижних уровней
            Stack sq;
            Queue subclerks;
            // добавили главного чиновника
            subclerks.push(root->clerk->pn);
            do{
                sq.push({}); // добавили пустую очередь
                Queue next_subclerks;
                while(!subclerks.empty()){
                    auto clerk_pn = subclerks.front();
                    subclerks.pop();
                    sq.top().push(clerk_pn);
                    if (mem[clerk_pn].vplisti != -1){
                        auto& clerk_vlist = (clerks[clerk_pn].vplist[mem[clerk_pn].vplisti]).vlist;
                        int end = clerk_vlist.size();
                        for(int k = 0; k != end; ++k)
                            next_subclerks.push(clerk_vlist[k]->clerk->pn);
                    }
                }
                subclerks = std::move(next_subclerks);
            }while(!subclerks.empty());

   Queue( Queue&& other):Queue(){
      std::swap(tail, other.tail);
      std::swap(head, other.head); 
   }
   Queue& operator=(Queue&& other){
      std::swap(tail, other.tail);
      std::swap(head, other.head);
      return *this;
   }

#include <iostream>
#include <vector>
 
using namespace std;
 
// предварительное объявление узла графа, для установления связей 
struct Node;
using visas_spisok_t = vector<Node*>; // тип : список виз
// набор виз и цена набора
struct VisaPack
{
    visas_spisok_t vspisok;
    int cena; // цена
};
 
using visas_pack_spisok_t = vector<VisaPack>; // тип : список наборов виз
using chinovniki_t = vector<Node*>; // тип : список чиновников
struct Chinovnik
{
    int pn; // PN - индекс чиновника, нужен для к запоминанию n значений
    visas_pack_spisok_t vpspisok; // список наборов виз
};
struct Node
{
    Chinovnik* chinovnik{};    // указатель на чиновника
    chinovniki_t pod_chinovniki{}; // список подчиненных
};
 
// стурктура для сохранения наименьшей суммы и соответствующего набора виз
struct Memo
{
    int sum{ -1 }; // -1 - не требует взятки
    int vpspiski{ -1 }; // индекс набора виз, -1 - нет список наборов виз пуст
};
 
// Реализация структуры для стека
template <typename T>
class MyStack {
public:
    void push(const T& value) {
        data.push_back(value);
    }
 
    void pop() {
        if (!data.empty()) {
            data.pop_back();
        }
    }
 
    const T& top() const {
        return data.back();
    }
 
    bool empty() const {
        return data.empty();
    }
 
private:
    vector<T> data;
};
 
// Реализация структуры для очереди
template <typename T>
class MyQueue {
public:
    void push(const T& value) const {
        data.push_back(value);
        ++size;
    }
 
    void pop() const {
        if (!data.empty()) {
            data.erase(data.begin());
            --size;
        }
    }
 
    const T& front() const {
        return data.front();
    }
 
    bool empty() const {
        return data.empty();
    }
 
    int getSize() const {
        return size;
    }
 
private:
    mutable vector<T> data;
    mutable int size = 0;
};
 
// граф
class Graf
{
public:
    // chinovnik - начальник всех начальников, n - количество чиновников
    Graf(Node* chinovnik, const vector<Chinovnik>& chinovniki, int n) : head{ chinovnik }, chinovniki{ chinovniki }, mem(n) {  }
    void print()
    {
        if (head)
            print(head);
    }
    int Min_Sum_and_Print()
    {
        if (head)
        {
            int min_sum = poluchit_min_contract(head);
 
            // стек PN всех чиновников поставивших подписи, начиная с самых нижних уровней
            MyStack<MyQueue<int>> sq;
            MyQueue<int> pod_chinovniki;
            // добавили главного чиновника
            pod_chinovniki.push(head->chinovnik->pn);
            do
            {
                sq.push(MyQueue<int>()); // добавили пустую очередь
                int n = pod_chinovniki.getSize();
                for (int i = 0; i != n; ++i)
                {
                    auto chinovnik_pn = pod_chinovniki.front();
                    pod_chinovniki.pop();
                    sq.top().push(chinovnik_pn);
                    if (mem[chinovnik_pn].vpspiski != -1)
                    {
                        auto& chinovnik_vspisok = (chinovniki[chinovnik_pn].vpspisok[mem[chinovnik_pn].vpspiski]).vspisok;
                        int end = chinovnik_vspisok.size();
                        for (int k = 0; k != end; ++k)
                            pod_chinovniki.push(chinovnik_vspisok[k]->chinovnik->pn);
                    }
                }
            } while (!pod_chinovniki.empty());
 
            // печать чиновников подписей
            cout << "порядок получения подписей для лицензии, числа - ID чиновников " << endl;
            while (!sq.empty())
            {
                auto& q = sq.top();
                while (!q.empty())
                {
                    cout << q.front() << ' ';
                    q.pop();
                }
                cout << endl;
                sq.pop();
            }
            return min_sum;
        }
        return -1; // останавливает выполнение программы, если неверно, то будет -1
    }
private:
    Node* head; // корень графа
    // массив промежуточных результатов для каждого обработанного чиновника
    vector<Memo> mem;
    const vector<Chinovnik>& chinovniki;
 
    void print(const Node* h, int level = 0)
    {
        for (int i = 0; i < level; i++)
            cout << "    ";
        cout << " ID чиновника " << h->chinovnik->pn << endl;
        for (int i = 0; i < h->pod_chinovniki.size(); i++)
            print(h->pod_chinovniki[i], level + 1);
    }
 
    int poluchit_min_contract(Node* h)
    {
        if (mem[h->chinovnik->pn].sum == -1)
        {
            vector<int> cena_s;
            for (auto& contract : h->chinovnik->vpspisok)
            {
                int total_cena = contract.cena;
                for (auto& chinovnik : contract.vspisok)
                    total_cena += poluchit_min_contract(chinovnik);
                cena_s.push_back(total_cena);
            }
            auto min_cena_it = min_element(cena_s.begin(), cena_s.end());
            mem[h->chinovnik->pn].sum = (min_cena_it == cena_s.end() ? 0 : *min_cena_it);
            mem[h->chinovnik->pn].vpspiski = (min_cena_it == cena_s.end() ? -1 : (min_cena_it - cena_s.begin()));
        }
        return mem[h->chinovnik->pn].sum;
    }
};
 
int main()
{
    setlocale(LC_ALL, "Russian");
 
    int n;
    cout << " Введите количество чиновников ";
    cin >> n;
    vector<Chinovnik> chinovniki(n);
    vector<Node> node_s(n);
 
    for (int in = 0; in != n; ++in)
    {
        int pn, k, v;
        cout << " Введите через пробел: ID (порядковый номер) чиновника, количество подчиненных текущего чиновника, количество наборов виз (для текущего чиновника) ";
        cin >> pn >> k >> v;
        chinovniki[pn].pn = pn;
        chinovniki[pn].vpspisok.resize(v);
        node_s[pn].chinovnik = &chinovniki[pn];
        node_s[pn].pod_chinovniki.resize(k);
        for (int ik = 0; ik != k; ++ik)
        {
            int kpn;
            cout << " Введите ID (порядковый номер) подчиненных ";
            cin >> kpn;
            node_s[pn].pod_chinovniki[ik] = &node_s[kpn];
        }
 
        for (int iv = 0; iv != v; ++iv)
        {
            int vn;
            cout << " Введите количество виз " << iv + 1 << " набора ";
            cin >> vn;
            chinovniki[pn].vpspisok[iv].vspisok.resize(vn);
            for (int ivn = 0; ivn != vn; ++ivn)
            {
                int ivpn;
                cout << " Введите визы, ID подчиненных подписи которых необходимы ";
                cin >> ivpn;
                chinovniki[pn].vpspisok[iv].vspisok[ivn] = &node_s[ivpn];
            }
            cout << " Введите цену " << iv + 1 << " набора виз ";
            cin >> chinovniki[pn].vpspisok[iv].cena;
        }
    }
    Graf graf(&node_s[0], chinovniki, n);
    graf.print();
    int min_sum = graf.Min_Sum_and_Print();
    cout << " Стоимость: " << min_sum << endl;
}