Laskettelukeskus

input/code.cpp: In member function 'uint32_t Node::evalualte()':
input/code.cpp:59:40: warning: comparison of integer expressions of different signedness: 'uint32_t' {aka 'unsigned int'} and 'int32_t' {aka 'int'} [-Wsign-compare]
   59 |                 if (m_pools.at(i)->val > difference)
      |                     ~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~

#include <iostream>
#include <string>
#include <vector>
#include <stdint.h>
#include <cassert>
 
class SharedPool
{
public:
    SharedPool(uint32_t _val) : val(_val) {}
 
    uint32_t val;
};
 
std::vector<SharedPool*> pools;
 
class Node
{
public:
    Node(uint32_t val) : m_val(val) {}
 
    uint32_t get_val()
    {
        return m_val;
    }
 
    void add_child(Node* child)
    {
        assert(child);
        m_children.push_back(child);
    }
 
    void add_parent(Node* parent)
    {
        assert(parent);
        m_parents.push_back(parent);
    }
 
    void add_pool(SharedPool* pool)
    {
        assert(pool);
        m_pools.push_back(pool);
    }
 
    uint32_t evalualte()
    {
        uint32_t child_sum = 0u;
        for (Node* child : m_children)
        {
            child_sum += child->evalualte();
        }
 
        int32_t difference = (int32_t)child_sum - (int32_t)m_val;
        if (difference > 0)
        {
            uint32_t i = 0;
            while (i < m_pools.size() && difference > 0)
            {
                if (m_pools.at(i)->val > difference)
                {
                    m_pools.at(i)->val -= difference;
 
                    return child_sum;
                }
 
                difference -= m_pools.at(i)->val;
                m_pools.at(i)->val = 0;
                
                i++;
            }
 
            return child_sum;
        }
 
        if (m_parents.size() > 1)
        {
            uint32_t total = m_val;
            for (Node* parent : m_parents)
            {
                total -= parent->get_val();
            }
 
            if (total > 0)
            {
                SharedPool* new_pool = new SharedPool(total);
                pools.push_back(new_pool);
                for (Node* parent : m_parents)
                {
                    parent->add_pool(new_pool);
                }
            }
            
            return 0;
        }
        
        return m_val;
    }
 
private:
    uint32_t m_val;
    std::vector<Node*> m_children;
    std::vector<Node*> m_parents;
    std::vector<SharedPool*> m_pools;
};
 
std::vector<Node*> create_nodes(uint32_t amount, const std::vector<uint32_t>& values)
{
    std::vector<Node*> output;
    for (uint32_t i = 0; i < amount; i++)
    {
        output.push_back(new Node(values.at(i)));
    }
    return output;
}
 
int main()
{
    // inputs
    uint32_t num_slopes;
    std::cin >> num_slopes;
 
    std::vector<std::vector<uint32_t> > connections(num_slopes - 1);
    for (uint32_t i = 0; i < num_slopes - 1; i++)
    {
        for (uint32_t j = 0; j < 2; j++)
        {
            uint32_t input;
            std::cin >> input;
            connections.at(i).push_back(input);
        }
    }
 
    std::vector<uint32_t> times_per_slope(num_slopes);
    for (uint32_t i = 0; i < num_slopes; i++)
    {
        std::cin >> times_per_slope.at(i);
    }
 
    // nodes
    std::vector<Node*> nodes = create_nodes(num_slopes, times_per_slope);
 
    for (uint32_t i = 0; i < connections.size(); i++)
    {
        const uint32_t from = connections[i][0];
        const uint32_t to = connections[i][1];
 
        nodes[from - 1]->add_child(nodes[to - 1]);
        nodes[to - 1]->add_parent(nodes[from - 1]);
    }
 
    //output
    uint32_t output = nodes.at(0)->evalualte();
    for (SharedPool* pool : pools)
    {
        output += pool->val;
    }
 
    std::cout << output << std::endl;
 
	return 0;
}

Test 1

Group: 1, 2

Verdict: ACCEPTED

Test 2

Group: 1, 2

Verdict: ACCEPTED

Test 3

Group: 1, 2

Verdict: ACCEPTED

Test 4

Group: 2

Verdict: WRONG ANSWER

Test 5

Group: 2

Verdict: WRONG ANSWER

Test 6

Group: 1, 2

Verdict: ACCEPTED

Test 7

Group: 2

Verdict: ACCEPTED

Test 8

Group: 1, 2

Verdict: ACCEPTED

Test 9

Group: 2

Verdict: ACCEPTED

Test 10

Group: 1, 2

Verdict: ACCEPTED

Test 11

Group: 2

Verdict: WRONG ANSWER

Test 12

Group: 1, 2

Verdict: ACCEPTED

Test 13

Group: 2

Verdict: WRONG ANSWER