def maximum_score_after_applying_operations_on_a_tree_brute_force(node_values, edges):

    number_of_nodes = len(node_values)
    adjacency_list = [[] for _ in range(number_of_nodes)]
    for edge_start, edge_end in edges:
        adjacency_list[edge_start].append(edge_end)
        adjacency_list[edge_end].append(edge_start)

    maximum_score = 0

    def calculate_score(operations):
        current_score = 0
        for node_index, operation_performed in enumerate(operations):
            if operation_performed:
                current_score += node_values[node_index]
        return current_score

    def explore_all_combinations(node_index, current_operations, visited):
        nonlocal maximum_score

        # Ensure we only process each node once
        visited[node_index] = True

        # Base case: If we've processed all nodes, calculate and update max score
        if all(visited):
            current_score = calculate_score(current_operations)
            maximum_score = max(maximum_score, current_score)
            return

        # Recursive step: Explore performing operation or not
        for next_node in range(number_of_nodes):
            if not visited[next_node]:
                # Explore WITH performing operation
                current_operations[next_node] = True
                explore_all_combinations(next_node, current_operations.copy(), visited.copy())
                
                # Explore WITHOUT performing operation
                current_operations[next_node] = False
                explore_all_combinations(next_node, current_operations.copy(), visited.copy())
                return

    # Iterate to use each node as a starting point
    for start_node in range(number_of_nodes):
        # Represents if we perform the operation on the current node or not
        initial_operations = [False] * number_of_nodes 
        
        # Keep track of which nodes have been visited
        initial_visited = [False] * number_of_nodes
        
        # Start the recursive exploration from each starting node
        initial_operations[start_node] = True
        explore_all_combinations(start_node, initial_operations.copy(), initial_visited.copy())

        initial_operations[start_node] = False
        explore_all_combinations(start_node, initial_operations.copy(), initial_visited.copy())

    return maximum_score

def maximum_score_after_operations(values, edges):
    number_of_nodes = len(values)
    adjacency_list = [[] for _ in range(number_of_nodes)]

    for edge_start, edge_end in edges:
        adjacency_list[edge_start].append(edge_end)
        adjacency_list[edge_end].append(edge_start)

    maximum_scores = {}

    def calculate_max_score(node, parent):
        if (node, parent) in maximum_scores:
            return maximum_scores[(node, parent)]

        # 'Activate' means including its value, skipping children.
        activate_node = values[node]
        for neighbor in adjacency_list[node]:
            if neighbor != parent:
                activate_node += calculate_max_score(neighbor, node)[1]

        # 'Do not activate' means skipping its value, including children.
        skip_node = 0
        for neighbor in adjacency_list[node]:
            if neighbor != parent:
                # Choosing the maximum score between activation/skipping.
                skip_node += max(calculate_max_score(neighbor, node))

        maximum_scores[(node, parent)] = (activate_node, skip_node)
        return maximum_scores[(node, parent)]

    # Start from node 0 with no parent.
    # Choose the larger of the activate and skip options.
    result = max(calculate_max_score(0, -1))

    return result