import java.util.*;
import java.util.function.BinaryOperator;

abstract class AbstractTree<T extends Number> {
    Node<T> root;
    BinaryOperator<T> adder;
    T sum;
    Comparator<T> comporator;
    T zero;

    Node<T> getRoot() {
        return this.root;
    }

    int getSize() {
        ArrayList<Node<T>> used = null;
        //used.add(this.root);
        //int count = 0;
        DFS(this, used, getRoot());

        //return count;
        return used.size();
    }

    void DFS(AbstractTree<T> tree, ArrayList<Node<T>> used, Node<T> vertex) {
        if (!used.contains(vertex)) {
            used.add(vertex);
            for (int i = 0; i < vertex.getChildren().size(); i++) {
                DFS(tree, used, (Node<T>) vertex.getChildren().toArray()[i]);
            }
        }
    }

    T getSum() {
        ArrayList<Node<T>> used = null;
        int count = 0;
        DFS(this, used, getRoot());

        for (int i = 0; i < used.size(); i++) {
            adder.apply(sum, used.get(i).getValue());
        }

        return sum;
    }

    abstract AbstractTree<T> removeSubtree(Node<T> rootSubtree);

    abstract AbstractTree<T> maximize(int k);

    abstract AbstractTree<T> maximize();

}