Algorithm Design

180
Chapter 4 Greedy Algorithms
the other edges out of r. This kind of argument never clouded our thinking in
the Minimum Spanning Tree Problem, where it was always safe to plunge
ahead and include the cheapest edge; it suggests that finding the optimal
arborescence may be a significantly more complicated task. (It’s worth noticing
that the optimal arborescence in Figure 4.19 also includes the most expensive
edge on a cycle; with a different construction, one can even cause the optimal
arborescence to include the most expensive edge in the whole graph.)
Despite this, it is possible to design a greedy type of algorithm for this
problem; it’s just that our myopic rule for choosing edges has to be a little
more sophisticated. First let’s consider a little more carefully what goes wrong
with the general strategy of including the cheapest edges. Here’s a particular
version of this strategy: for each node v # r, select the cheapest edge entering
v (breaking ties arbitrarily), and let F* be this set of n - 1 edges. Now consider
the subgraph (V, F*). Since we know that the optimal arborescence needs to
have exactly one edge entering each node v # r, and (V, F*) represents the
cheapest possible way of making these choices, we have the following fact2
(4.36) I[ (V, F*) is an arborescence, then it is a minimum-cost arborescence.
So the difficulty is that (V, F*) may not be an arborescence. In this case,
(4.34) implies that (V, F*) must contain a cycle C, which does not include the
root. We now must decide how to proceed in this situation.
To make matters somewhat clearer, we begin with the following observation.
Every arborescence contains exactly one edge entering each node v # r;
so if we pick some node v and subtract a uniform quantity from the cost of
every edge entering v, then the total cost of every arborescence changes by
exactly the same amount. This means, essentially, that the actual cost of the
cheapest edge entering v is not important; what matters is the cost of all other
edges entering v relative to this. Thus let Yv denote the minimum cogt of any
edge entering v. For each edge e = (u, v), with cost c e >_ O, we define its modified
cost c’ e to be ce - Yv- Note that since ce >_ y,, all the modified costs are still
nonnegafive. More crucially, our discussion motivates the following fact.
(4.37) T is an optimal arborescence in G subject to costs (Ce) if and Only if it
is an optimal arborescence Subject to the modified costs c’
ProoL Consider an arbitrary arborescence T. The difference between its cost
with costs (ce} and [c’ e} is exactly ~,#r y~--that is,
eaT
eaT \
4.9 Minimum-Cost Arborescences: A Multi-Phase Greedy Algorithm
This is because an arborescence has exactly one edge entering each node
in the sum. Since the difference between the two costs is independent of the
choice of the arborescence T, we see that T has minimum cost subiect to {ce}
if and only if it has minimum cost subject to {c’e}. ,,
We now consider the problem in terms of the costs {de}. All the edges in
our set F* have cost 0 under these modified costs; and so if (V, F*) contains
a cycle C, we know that all edges in C have cost 0. This suggests that we can
afford to use as many edges from C as we want (consistent with producing an
arborescence), since including edges from C doesn’t raise the cost.
Thus our algorithm continues as follows. We contract C into a single
supemode, obtaining a smaller graph G’ = (V’, E’). Here, V’ contains the nodes
of V-C, plus a single node c* representing C. We transform each edge e E E to
an edge e’ E E’ by replacing each end of e that belongs to C with the new node
c*. This can result in G’ having parallel edges (i.e., edges with the same ends),
which is fine; however, we delete self-loops from E’--edges that have both
ends equal to c*. We recursively find an optimal arborescence in this smaller
graph G’, subject to the costs {C’e}. The arborescence returned by this recursive
call can be converted into an arborescence of G by including all but one edge
on the cycle C.
In summary, here is the full algorithm.
For each node u7 &r
Let Yu be the minimum cost of an edge entering node
Modify the costs of all edges e entering v to c’e=c e
Choose one 0-cost edge entering each u7~r, obtaining a set F*
If F* forms an arborescence, then return it
Else there is a directed cycle C_CF*
Contract C to a single supernode, yielding a graph G’= (V’,E’)
Recursively find an optimal arborescence (V’,F’) in G’
with costs [C’e}
Extend (V’,F ~) to an arborescence (V, F) in G
by adding all but one edge of C
~ Analyzing the Algorithm
It is easy to implement this algorithm so that it runs in polynomial time. But
does it lead to an optimal arborescence? Before concluding that it does, we need
to worry about the following point: not every arborescence in G corresponds to
an arborescence in the contracted graph G’. Could we perhaps "miss" the true
optimal arborescence in G by focusing on G’? What is true is the following.
181