Algorithm Design

446
Chapter 7
48.
(d)
Network Flow
is a path from v to t in the residual graph of the current preflow. Let
A = V-B. Prove that at the end of the algorithm, (A, B) is a minimumcapacity
s-t cut.
The algorithm in part (c) computes a minimum s-t cut but fails to find
a maximum flow (as it ends with a preflow that has excesses). Give
an algorithm that takes the preflow f at the end of the algorithm of
part (c) and converts it into a maximum flow in at most O(mn) time.
(Hint: Consider nodes with excess, and try to send the excess back
to s using only edges that the flow came on.)
In Section 7.4 we considered the Preflow-Push Algorithm, and discussed
one particular selection rule for considering vertices. Here we will explore
a different selection rule. We will also consider variants of the algorithm
that terminate early (and find a cut that is close to the minimum possible).
(a) Let f be any preflow. As f is not necessarily a valid flow, it is possible
that the value four (s) is much higher than the maximum-flow value in
G. Show, however, that fgn(t) is a lower bound on the maximum-flow
value.
(b) Consider a preflow f and a compatible labeling h. Recall that the set
A = {v : There is an s-v path in the residual graph Gf}, and B = V-A
defines an s-t cut for any preflow f that has a compatible labeling h.
Show that the capacity of the cut (A, B) is equal to c(A, B)
Combining (a) and (b) allows the algorithm to terminate early and
return (A, B) as an approximately minimum-capacity cut, assmning
c(A, B) - fin(t) is sufficiently small. Next we consider an implementation
that will work on decreasing this value by trying to push flow
(c)
out of nodes that have a lot of excess.
The scaling version of the Preflow-Push Algorithm mainta~s a scaling
parameter A. We set A initially to be a large power of 2. The
algorithm at each step selects a node with excess at least ~ with as
small a height as possible. When no nodes (other than t) have excess
at least ~, we divide ~ by 2, and continue. Note that this is
a valid implementation of the generic Preflow-Push Algorithm. The
algorithm runs in phases. A single phase continues as long as h is
unchanged. Note that A starts out at the largest capacity, and the
algorithm terminates when A = !. So there are at most O(log C) scaling
phases. Show how to implement this variant of the algorithm so
that the running time can be bounded by O(rnn + n !og C + K) ff the
algorithm has K nonsaturating push operations.
49.
50.
Exercises
(d) Show that the number of nonsaturating push operations in the above
algorithm is at most O(n 2 log C). Recall that O(log C) bounds the number
of scaling phases. To bound the number of nonsaturating push
operations in a single scaling phase, consider the potential function
q~ = ~.~,v h(v)ef(v)/a. What is the effect of a nonsaturating push on
~? Which operation(s) can make ¢ increase?
Consider an assignment problem where we have a set of n Stations that
can provide service, and there is a set of k requests for service. Say, for
example, that the stations are cell towers and the requests are cell phones.
Each request can be served by a given set of stations. The problem so far
can be represented by a bipartite graph G: one side is the stations, the
other the customers, and there is an edge (x, y) between customer x and
station y if customer x can be served from station y. Assume that each
station can serve at most one customer. Using a max-flow computation,
we can decide whether or not all customers can be served, or can get an
assignment of a subset of customers to stations maximizing the number
of served customers.
Here we consider a version of the problem with an additional complication:
Each customer offers a different amount of money for the service.
Let U be the set of customers, and assume that customer x ~ U is willing
to pay vx _> 0 for being served. Now the goal is to find a subset X c U maximizing
~xO: vx such that there is an assignment of the customers in X
to stations.
Consider the following greedy approach. We process customers in
order of decreasing value (breaking ties arbitrarily). When considering
customer x the algorithm will either "promise" service to x or reject x In
the following greedy fashion. Let X be the set of customers that so far
have been promised service. We add x to the set X if and ouly if there is
a way to assign X u {x} to servers, and we reject x otherwise. Note that
rejected customers will not be considered later. (This is viewed as an
advantage: If we need to reject a high-paying customer, at least we can tell
him/her early.) However, we do not assign accepted customers to servers
in a greedy fashion: we ouly fix the assignment after the set of accepted
customers is fixed. Does this greedy approach produce an optimal set of
customers? Prove that it does, or provide a countere~ample.
Consider the following scheduling problem. There are m machines, each
of wkich can process jobs, one job at a time. The problem is to assign
jobs to machines (each job needs to be assigned to exactly one machine)
and order the jobs on machines so as to minimize a cost function.
447