Laskettelukeskus

#include <iostream>
#include <string>
#include <vector>
#include <stdint.h>

std::vector<uint32_t> parse_numbers(const std::string& input)
{
    std::vector<uint32_t> output;
    std::string curr_num = "";
 
    for (size_t i = 0; i < input.length(); i++)
    {
        char c = input.at(i);
        if ((c == ' ' || c == '\0' || c == '\n' || i + 1 == input.length()) && curr_num.length() != 0)
        {
            if (i + 1 == input.length())
            {
                curr_num.push_back(c);
            }
            output.push_back(static_cast<uint32_t>(std::stoi(curr_num)));
            curr_num.clear();
            continue;
        }
        curr_num.push_back(c);
    }
 
    return output;
}

class Node
{
public:
    Node(uint32_t val) : m_val(val) {}

    void add_child(Node* child)
    {
        m_children.push_back(child);
    }

    uint32_t evalualte()
    {
        uint32_t child_sum = 0;
        for (auto child : m_children)
        {
            child_sum += child->evalualte();
        }
        return m_val > child_sum ? m_val : child_sum;
    }

private:
    uint32_t m_val;
    std::vector<Node*> m_children;
};

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[i]));
    }
    return output;
}

int main()
{
    // inputs
    std::string num_slopes_str, times_per_slope_str;
    std::getline(std::cin, num_slopes_str);
    uint32_t num_slopes = std::stoi(num_slopes_str);

    std::vector<std::vector<uint32_t>> connections;
    for (uint32_t i = 0; i < num_slopes - 1; i++)
    {
        std::string input;
        std::getline(std::cin, input);
        input.push_back(' ');
        connections.push_back(parse_numbers(input));
    }

    std::getline(std::cin, times_per_slope_str);

    // nodes
    std::vector<Node*> nodes = create_nodes(num_slopes, parse_numbers(times_per_slope_str));

    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]);
    }

    //output
    std::cout << nodes[0]->evalualte();

	return 0;
}

Test 1

Group: 1, 2

Verdict: WRONG ANSWER

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