Algorithm Design

558
Chapter 10 Extending the Limits of Tractability
10.2 Solving NP-Hard Problems on Trees
In Section I0.I we designed an algorithm for the Vertex Cover Problem that
works well when the size of the desired vertex cover is not too large. We saw
that finding a relatively small vertex cover is much easier than the Vertex Cover
Problem in its ful! generality.
Here we consider special cases of NP-complete graph problems with a
different flavor--not when the natural "size" parameters are small, but when
the input graph is structurally "simple." Perhaps the simplest types of graphs
are trees. Recall that an undirected graph is a tree if it is connected and has
no cycles. Not only are trees structurally easy to understand, but it has been
found that many NP-hard graph problems can be solved efficiently when
the underlying graph is a tree. At a qualitative level, the reason for this
is the following: If we consider a subtree of the input rooted at some node
u, the solution to the problem restricted to this subtree only "interacts" with
the rest of the tree through v. Thus, by considering the different ways in which
v might figure in the overall solution, we can essentially decouple the problem
in v’s subtree from the problem in the rest of the tree.
It takes some amount of effort to make this general approach precise and to
turn it into an efficient algorithm. Here we will see how to do this for variants
of the Independent Set Problem; however, it is important to keep in mind that
this principle is quite general, and we could equally well have considered many
other NP-complete graph problems on trees.
First we will see that the Independent Set Problem itself can be solved
by a greedy algorithm on a tree. Then we will consider the generalization
called the Maximum-Weight Independent Set Problem, in which nodes have
weight, and we seek an independent set of maximum weight. Weql see that
the Maximum-Weight Independent Set Problem can be solved on trees via
dynamic programming, using a fairly direct implementation of the intuition
described above. ~
A Greedy Algorithm for Independent Set on Trees
The starting point of our greedy algorithm on a tree is to consider the way a
solution looks from the perspective of a single edge; this is a variant on an
idea from Section 10.!. Specifically, consider an edge e = (u, v) in G. In any
independent set S of G, at most one of u or v can belong to S. We’d like to find
an edge e for which we can greedily decide which of the two ends to place in
our independent set.
For this we exploit a crucial property of trees: Every tree has at least
one Ieaf--a node of degree 1. Consider a leaf ~, and let (u, u) be the unique
edge incident to v. How might we "greedily" evaluate the relative benefits of
10.2 Solving NP-Hard Problems on Trees
including u or u in our independent set S? If we include u, the only other node
that is directly "blocked" from joining the independent set is u. If we include
u, it blocks not only v but all the other nodes joined to u as well. So if we’re
trying to maximize the size of the independent set, it seems that including u
should be better than, or at least as good as, including u.
maximum-size independent set that contains
Proof. Consider a maximum-size independent set S, and let e = (u, v) be the
unique edge incident to node v. Clearly, at least one of u or v is in S; for if
neither is present, then we could add v to S, thereby increasing its size. Now, if
v ~ S, then we are done; and if u ~ S, then we can obtain another independent
set S’ of the same size by deleting u from S and inserting v. ~
We will use (10.5) repeatedly to identify and delete nodes that can be
placed in the independent set. As we do this deletion, the tree T may become
disconnected. So, to handle things more cleanly, we actually describe our
algorithm for the more general case in which the underlying graph is a forest-a
graph in which each connected component is a tree. We can view the problem
of finding a maximum-size independent set for a forest as really being the same
as the problem for trees: an optimal solution for a forest is simply the union
of optimal solutions for each tree component, and we can still use (10.5) to
think about the problem in any component.
Specifically, suppose we have a forest F; then (10.5) allows us to make our
first decision in the following greedy way. Consider again an edge e = (u, v),
where v is a leaf. We will include node v in our independent set S, and not
include node u. Given this decision, we can delete the node u (since it’s already
been included) and the node u (since it cannot be included) and obtain a
smaller forest. We continue recursively on this smaller forest to get a solution.
To find a maximum-size independent set in a forest F:
Let S be the independent set to be constr~cted ~(initially empty)
While F has at least one edge
Let e=(u,u) be an edge of F such that u is a leaf
Add u to S
Delete from F nodes u and v, and all edges incident to them
Endwhile
Return S
559