Sadonkorjuu

input/code.cpp: In function 'size_t solve(const std::vector<std::vector<std::pair<long long int, long long int> > >&, std::vector<short int>, size_t)':
input/code.cpp:47:63: error: invalid initialization of reference of type 'std::pair<long unsigned int, long unsigned int>&' from expression of type 'const std::pair<long long int, long long int>'
   47 |         for ( pair<size_t, size_t>& a_node : edges[curr.second] ) {
      |                                                               ^
input/code.cpp:47:37: warning: loop variable 'a_node' of type 'std::pair<long unsigned int, long unsigned int>&' binds to a temporary constructed from type 'const std::pair<long long int, long long int>' [-Wrange-loop-construct]
   47 |         for ( pair<size_t, size_t>& a_node : edges[curr.second] ) {
      |                                     ^~~~~~
input/code.cpp:47:37: note: use non-reference type 'std::pair<long unsigned int, long unsigned int>' to make the copy explicit or 'const std::pair<l...

#include <vector>
#include <utility>
#include <map>
#include <algorithm>
#include <iostream>
#include <cstdint>
#include <queue>
#include <limits>
#include <execution>
 
using namespace std;
using LLi = long long int;
 
static const LLi MAX_DIST = std::numeric_limits<LLi>::max();
 
 
auto solve(const vector<vector<pair<LLi, LLi>>>& edges, const vector<int16_t> node_types, size_t n) -> size_t
{
    priority_queue<pair<LLi, LLi>, std::vector<pair<LLi, LLi>>, std::greater<pair<LLi, LLi>>> distances;
 
    vector<bool> is_processed(n + 1, false); 
    vector<pair<LLi, LLi>> vertex_attributes(n + 1, make_pair(MAX_DIST, 0));
 
    for (size_t i = 0; i < node_types.size(); i++) {
        int16_t curr = node_types[i];
        if (curr == 0) {
            vertex_attributes[i] = make_pair(0, i);
            distances.push( vertex_attributes[i]);
            is_processed[i] = true;
        }
    }
 
    
    auto Relax = [&vertex_attributes]( const pair<LLi, LLi>& curr, const LLi a_neighbour, int32_t weight ) -> void
    {
        if ( curr.first + weight < vertex_attributes[a_neighbour].first )  {
            vertex_attributes[a_neighbour].first = curr.first + weight;
            vertex_attributes[a_neighbour].second = curr.second;
        }
    };
 
 
    while ( !(distances.empty()) ) {
        pair<LLi, LLi> curr = distances.top();
        distances.pop();
 
        for ( pair<size_t, size_t>& a_node : edges[curr.second] ) {
            if ( !is_processed[a_node.second] && (node_types[a_node.second] == 1) ) {
                Relax(curr, a_node.second, a_node.first);
                distances.emplace( vertex_attributes[a_node.second].first, a_node.second );
            }
        }
 
        is_processed[curr.second] = true;
    }
 
    return accumulate(vertex_attributes.begin(), vertex_attributes.end(), size_t(0), 
    [](size_t total, const pair<LLi, LLi>& curr) -> size_t
    {
        return total + curr.first;
    });
 
}
 
 
 
int main()
{
    size_t n = 0;
    
    cin >> n;
 
    vector<int16_t> node_types(n + 1);
    vector<vector<pair<LLi, LLi>>> edges(n + 1);
 
    for (size_t i = 1; i <= n; i++) {
        cin >> node_types[i];
    }
 
 
    int32_t a = 0;
    int32_t b = 0;
    int32_t dist = 0;
    for (size_t i = 0; i < n - 1; i++) {
        cin >> a >> b >> dist;
        edges[a].push_back(make_pair(dist, b));
        edges[b].push_back(make_pair(dist, a));
        
    }
 
    cout << solve(edges, node_types, n) << endl;
 
    return EXIT_SUCCESS;
}