Assume you can't modify the tree other than to
remove edges to create subtrees.

First understand that you cannot guarantee that
by simply removing edges that you will have
subtrees within an arbitrary bound. You can create
tree that when you split them there is no way to
create subtrees within a target bound. For
example:

```
a(b(c,d,e,f),g)
```

You cannot split that into two balanced
sections. The best you can do is remove the edge
from a to b:

a(g) and b(c,d,e,f)

Also this criteria is a little underdefined
when k > 2. What is better a split 10,10,10,1 or
10,10,6,5?

But you can come up with a method to split
trees up in the most balanced way possible.

Implement you tree such that each node holds a
count of all of its children. You can add this
pretty efficiently to any tree. ( E.g. when you
add a node you have to iterate up the chain of
parent node incrementing the count. Remove a node
and you iterate up subtracting from the count
)

Then starting from the root iterate down, in a
breadth first manner until you find a set of nodes
that dominate child nodes in a way that is most
balanced. I don't have an algorithm for this at
the ready - but I think you can find one pretty
readily.

I think something where when you want to divide
into k subtrees you create an array of k tree
roots. One of those nodes must always be the root
of the current tree, then you iterate down looking
for nodes to replace on of the k-1 candidates that
improves the partitioning. You'll want some kind
of terminating condition where you don't interate
down to every leaf node. E.g. it never makes sense
to subdivide anything by the largest candidate
node.