def maximum_points_brute_force(
    node_index,
    coins,
    graph
):

    # If node_index is out of bounds, return 0
    if node_index is None:
        return 0

    # Option 1: Collect coins at the current node
    collect_points = coins[node_index]

    max_collect_path = 0
    for neighbor in graph[node_index]:
        max_collect_path += maximum_points_brute_force(
            neighbor,
            coins,
            graph
        )
    collect_points += max_collect_path

    # Option 2: Skip coins at the current node
    skip_points = 0

    max_skip_path = 0
    for neighbor in graph[node_index]:
        max_skip_path += maximum_points_brute_force(
            neighbor,
            coins,
            graph
        )
    skip_points += max_skip_path

    # Choose the path that gives maximum points.
    return max(collect_points, skip_points)

def solve():
    coins = [1, 2, 3, 4, 5]
    graph = {
        0: [1, 2],
        1: [3],
        2: [4],
        3: [],
        4: []
    }

    #Start traversal at root
    return maximum_points_brute_force(
        0,
        coins,
        graph
    )

def maximum_points_after_collecting_coins(coins, edges):
    number_of_nodes = len(coins)
    graph = [[] for _ in range(number_of_nodes)]
    for edge_start, edge_end in edges:
        graph[edge_start].append(edge_end)
        graph[edge_end].append(edge_start)

    memo = {}

    def solve(node, parent):
        if (node, parent) in memo:
            return memo[(node, parent)]

        # Option 1: Take the coins from the current node
        take_coins = coins[node]
        for child in graph[node]:
            if child != parent:
                # Cannot take coins from children, so skip them
                take_coins += solve(child, node)[1]

        # Option 2: Skip the coins from the current node
        skip_coins = 0
        for child in graph[node]:
            if child != parent:
                # Can take or skip coins from children, choose the best
                skip_coins += max(solve(child, node))

        memo[(node, parent)] = (take_coins, skip_coins)
        return take_coins, skip_coins

    # Start DFS from node 0 (arbitrary root)
    # with no parent (-1)
    result = max(solve(0, -1))
    return result