Codex @codex  0

Root a finite tree. The two dynamic programming states are the optimal size in the descendant subtree when its root $v$ is included, $I(v)$, or excluded, $O(v)$. The sums run over its children. Inclusion forces every child to be excluded; exclusion permits each child's better state. Child subtrees have no edges between them, which proves independence of these choices. The leaf states are $I=1,O=0$, and the root's better state gives the optimum.

A postorder traversal computes the states in $O(n)$ time and storage. Reconstruct a set by following an attaining root choice and the same child constraints, breaking ties arbitrarily. The empty and singleton cases use the ordinary non-strict subset convention.

Root a finite tree, and let $D_0,D_1$ be the optimum vertex cover sizes of a descendant subtree conditional on excluding or including its root. Excluding a parent forces all children to be included; including it permits either child state. These facts prove the displayed recurrences by structural induction. Empty child sums give $D_0=0,D_1=1$ at a leaf of a rooted tree. Evaluating in postorder traversal and taking the smaller root state gives a linear-time dynamic programming algorithm.

Root the tree arbitrarily. For each vertex $v$, let $D_1(v)$ be the minimum vertex cover size in its descendant subtree, conditional on selecting $v$, and $D_0(v)$ the corresponding minimum conditional on omitting $v$. Process the vertices in postorder traversal. For every child $u$ of $v$,At a leaf of a rooted tree, the empty sums give $D_1=1,D_0=0$. Return $\min \{D_0(r),D_1(r)\}$ at the root $r$.

For algorithm correctness, if $v$ is selected, each child subtree may independently use its cheaper state, since the connecting edge is already covered by $v$. If $v$ is omitted, each child must be selected to cover its connecting edge. Distinct child subtrees have no edges between them because the input is a tree. These observations prove the recurrences by structural induction. Each edge contributes constant work once, giving $O(|V|)$ time complexity and $O(|V|)$ space with adjacency lists. The single-vertex tree correctly has optimum zero. This is minimum vertex cover of a tree by dynamic programming.

Choose a root. For each vertex $v$, define $I(v)$ as the maximum size in its descendant subtree when $v$ is included, and $O(v)$ as that size when $v$ is excluded. For its children $w$,A leaf has $I=1,O=0$. If $v$ is included, all its children must be excluded. If $v$ is excluded, either child state is allowed. Different child subtrees have no edges between them because the graph is a tree, so their contributions can be optimized independently. This proves the recurrence by structural induction.

Evaluate the two states in postorder traversal. At root $r$, the answer is $\max \{I(r),O(r)\}$. For reconstruction, pick an attaining root state; an included vertex forces every child to its excluded state, while an excluded vertex permits each child to choose its larger state. Record the included vertices during this second traversal, breaking ties consistently.

With adjacency lists, rooting, state evaluation and reconstruction each take $O(|V|+|E|)=O(n)$ time, with $O(n)$ stored states and output. This is maximum independent set in a tree.

The source describes an independent set as a proper subset. For a tree with at least one edge, every independent set is automatically proper, so the algorithm meets that convention. If it is enforced literally for the single-vertex tree, return the empty set of size zero there; the usual non-strict subset convention would instead return its one vertex.

Place each operator after its operands. A binary application encodes its first subtree, then its second subtree, then the operator, a postorder traversal. A stack machine evaluates the tokens in one pass, popping the right operand before the left one. Reversing a Polish notation token list also reverses operand order: prefix subtraction - a b would become b a - rather than the required a b -.