II Homework Exercises

HOMEWORK 1 219

Homework 1
1. (a) Let (S,I) be a matroid and let A ~ S. Prove that all maximal
independent subsets of A have the same cardinality. (This number is
called the mnk of A. The rank of the matroid is the rank of the set
s.)
(b) Let I be a maximal independent set and let x rf- I. Prove that there
is a unique cycle contained in I U {x}. (This is called the fundamental
cycle of x and I.)
(c) Let G = (V, E) be an undirected graph, not necessarily connected.
Consider the system (E,I), where I consists of all subsets E' ~ E
such that the subgraph (V, E') has no cycles. Show that (E, I) is a
matroid. What is its rank? What are its maximal independent sets?

2. Let G = (V, E) be a directed graph. A tmnsitive reduction or Hasse di-

agmm of G is a subgraph G H = (V,EH ) with minimum number of edges
such that E and EH have the same transitive closure.

(a) Prove that if G is acyclic, then the transitive reduction of G is unique.

(b) Give an efficient algorithm to find the transitive reduction of G in
case G is acyclic. Your algorithm should have roughly the same com-
plexity as transitive closure. (We will see later that the problem is
NP-complete when G is cyclic.)

3. An Euler circuit in a connected undirected graph G = (V, E) is a circuit

that traverses all edges exactly once.

(a) Prove that G has an Euler circuit iff G is connected and the degree of
every vertex is even.
(b) Give an D(IED algorithm to find an Euler circuit if one exists. Give
a proof of correctness and detailed complexity analysis.
220 HOMEWORK 2

Homework 2
1. Give a linear-time algorithm for topological sort based on depth-first search.

2. Let G = (V, E) be an undirected graph, and let (J be a circular ordering of

the edges adjacent to each vertex. The ordering (J is said to be consistent
with an embedding of G in the plane if for each vertex v, the ordering of the
edges adjacent to v given by (J agrees with their counterclockwise ordering
around v in the embedding.

(a) Give a linear-time algorithm that determines whether a given (J is

consistent with some plane embedding.
(b) Consider two embeddings to be the same if one can be transformed
into the other by a smooth motion in the plane without tearing or
cutting. Assume that G is connected. How many distinct plane em-
beddings are consistent with a given (J? (Extm credit. Remove the
assumption of connectedness.)

3. A scorpion is an undirected graph G of the following form: there are three

special vertices, called the sting, the tail, and the body, of degree 1, 2,
and n - 2, respectively. The sting is connected only to the tail; the tail is
connected only to the sting and the body; and the body is connected to
all vertices except the sting. The other vertices of G may be connected to
each other arbitrarily.

/ s t i ng

tail

Give an algorithm that makes only O(n) probes of the adjacency matrix of
G and determines whether G is a scorpion. (This is a counterexample to an
earlier version of the famous Andema-Rosenberg conjecture, which stated
that any nontrivial graph property that is invariant under graph isomor-
phism requires O(n 2 ) probes of the adjacency matrix to test. Anderaa
disproved this version in 1975 using a different counterexample (see [91]),
but conjectured that it held for monotone properties (those that cannot
change from false to true when edges are deleted). This was later verified
by Rivest and Vuillemin [91].)
HOMEWORK 3 221

Homework 3
1. Verify that the family RegE ofregular expressions over an alphabet E with
the operations defined as in Lecture 6, Example 6.2 is a Kleene algebra.

2. Let R be the standard interpretation of regular expressions over RegE.

Prove that for regular expressions a, {3, "( and interpretation J over a
Kleene algebra IC,

J(a{3"() = sup J(ax"() .

:XER(!3)

In other words, the supremum of the set

{J(ax"() Ix E R({3)}

exists and is equal to J(a{3"(). (Hint. Try induction on {3, using the axioms
of Kleene algebra.) Note that Lemma 7.1 of Lecture 7 is a special case with
a="(=1.

3. Modify Dijkstra's algorithm to produce the minimum-weight paths them-

selves, not just their weights.
222 HOMEWORK 4

Homework 4
1. The following algorithm, known as Prim's algorithm, produces a minimum
spanning tree T in a connected undirected graph with edge weights. Ini-
tially, we choose an arbitrary vertex and let T be the tree consisting of that
vertex and no edges. We then repeat the following step n - 1 times: find
an edge of minimum weight with exactly one endpoint in T and include
that edge in T.

(a) Argue that Prim's algorithm is correct.

(b) Give an implementation that runs in time O(m + nlogn).

2. The Planar Separator Theorem gives ~-~ separators of size O( y'n) for ar-
bitrary planar graphs. Show that this is the best you can do in general;
i.e., give a family of planar graphs whose smallest ~-~ separators are of size
O(y'n).
HOMEWORK 5 223

Homework 5
1. (a) Given a flow f on a directed graph G with positive edge capacities,
show how to construct the residual graph G, in Oem) time.
(b) Using (a), show how to calculate efficiently an augmenting path of
maximum bottleneck capacity. (Hint. Modify Dijkstra's algorithm.)

2. Give an efficient algorithm for the s, t-connectivity problem: given a directed

or undirected graph G = (V, E) and elements s, t E V, s =1= t, decide
whether there exist k edge-disjoint paths from s to t, and find them if so.
(The vertex-disjoint version of this problem is NP-complete; see Homework
7 Exercise 3.)

3. Give an efficient algorithm for the min cut problem: given an undirected
graph G = (V, E), elements s, t E V, s =1= t, and edge weights w : E -+ 'R,+,
find an s, t-cut of minimum weight; i.e., find a partition A, B of V with
sEA, t E B minimizing

L w(u,v) .
(u,v)EEn(AxB)

(Several minor variants of this problem are NP-complete. For example, the
max cut problem is NP-complete.)
224 HOMEWORK 6

Homework 6
1. (The stable marriage problem.) In a group of n boys and n girls, each girl
ranks the n boys according to her preference, and each boy ranks the n girls
according to his preference. A marriage is a perfect matching between the
boys and the girls. A marriage is unstable if there is a pair who are not
married to each other but who like each other more than they like their
respective spouses, otherwise it is stable. Prove that a stable marriage
always exists, and give an efficient algorithm to find one.

2. Prove the Konig-Egeruary Theorem: in a bipartite graph, the size of a

maximum matching is equal to the size of a minimum vertex cover.

3. Let G = (U, V, E) be a bipartite graph. For 8 ~ U, let N(8) be the set

of neighbors of 8; i.e.,

N (8) = {v E V I 3u E 8 (u, v) E E} .

Prove Hall's Theorem: G has a matching in which every vertex of U is

matched iff for every subset 8 of U,

IN(8)1 > 181·

(Hint. Use 2.)

4. An undirected graph is regular if all vertices have the same degree. Prove
that any nontrivial regular bipartite graph has a perfect matching. (Hint.
Use 2 or 3.)
HOMEWORK 7 225

Homework 7
1. Consider a restricted version of CNFSat in which formulas may contain at
most k occurrences of any variable, either negated or unnegated, where k
is fixed.

(a) Show that the problem is NP-complete if k ~ 3.

(b) Show that the problem is solvable in polynomial time if k ~ 2.

2. Suppose that TSP E P; that is, suppose there is a polynomial-time algo-

rithm which, given any directed graph G with integral edge weights and
positive integer k, determines whether there exists a tour of weight at most
k that visits every vertex at least once. Give a polynomial-time algorithm
to find such a tour of minimum weight.

3. In Homework 5 Exercise 2 we gave an efficient algorithm for the s, t-

connectivity problem. Formulate a version of this problem in which the
requirement "edge-disjoint" is replaced by "vertex-disjoint" (this problem
is called the disjoint connecting paths problem in [39, p. 217]), and show
that it is NP-complete. (Hint. Use 3CNFSat. Let k be the number of
clauses plus the number of variables.)
226 HOMEWORK 8

Homework 8
1. Let Zp denote the field of integers modulo a fixed prime p. Consider the
problem of determining whether a given expression involving +, -,·,0,1,
and variables ranging over Zp vanishes for all possible values for the vari-
ables. Show that this problem is coNP-complete. (Hint. You may want to
use Fermat's Theorem: aP- 1 = 1 for all nonzero a E Zp.)

2. Consider a restricted version of the TSP such that distances are symmetric
and satisfy the triangle inequality:

d(u,v) d(v,u)
d(u,w) < d(u,v) + d(v,w) .

(a) Argue that this restricted version is still NP-complete.

(b) Give a polynomial-time algorithm that finds a tour visiting all cities
exactly once whose total distance is at most twice optimal. (Hint.
Start with a minimum spanning tree.)

3. Recall that a tmnsitive reduction or Hasse diagmm of a directed graph

G is a subgraph with as few edges as possible having the same transitive
closure as G. Show that the problem of determining whether a given G has
a transitive reduction with k or fewer edges is NP-complete.
HOMEWORK 9 227

Homework 9
1. Give an NC algorithm for obtaining a topological sort of a given directed
acyclic graph. (Hint. Use Miscellaneous Exercise 27.)

2. Show that the problem of determining whether a given undirected graph

is bipartite, i.e. does not have an odd cycle, is in NC.

3. A linear recurrence is of order k if it is of the form

Xi Ci, 0 ~ i ~ k - 1
Xn alXn-l + a2Xn -2 + ... + akXn-k + c, n;::: k
where the Ci, ai, and c are constants. For example, the Fibonacci sequence
is of order 2 with Co = Cl = al = a2 = 1 and C = O. Show that the nth term
of a linear recurrence of order k can be computed in time

(a) O(k 2 Iogn) with a single processor. (Hint. Use Miscellaneous Exercise
22.)
(b) o (log k logn) with O(kO!) processors, where a = 2.81. .. is the con-
stant in Strassen's matrix multiplication algorithm.
(c) O(log k + log n) with O(kn) processors, assuming that the ring we
are working in supports an FFT. (Hint. Work with the generating
function
00

x(y) = LXiyi
i=O

where y is an indeterminate and the coefficients Xi are the solution to

the recurrence.)
228 HOMEWORK 10

Homework 10
1. In Luby's algorithm, we need to show that if we expect to delete at least
a fixed fraction of the remaining edges in each stage, then the expected
number of stages is logarithmic in the number of edges. We can formalize
this as follows.

Proposition Let m ~ 0 and 0 < f < 1. Let Xl, X 2 , ••• and So, Sl,
S2, . .. be nonnegative integer-valued random variables such that

Sn = Xl + ... + Xn ~ m
£(Xn+1 I Sn) ~ f· (m - Sn) .

Then the expected least n such that Sn = m is O(logm).

In our application, m is the number of edges in the original graph, Xn is

the number of edges deleted in stage n, Sn is the total number of edges
deleted so far after stage n, and f = i2.
(a) Show that

(Hint. Using the fact £(£(Xn+l I Sn)) = £Xn+1 shown in class, give
a recurrence for £Sn.)
(b) Using the definition of expectation, show also that

£Sn ~ m - 1 + Pr(Sn = m)
and therefore

Pr(Sn = m) ~ 1 - m(l - ft .
(c) Conclude that the expected least n such that Sn = m is O(logm).
(Hint. Define the function

I, ifx<m
{
f(x) = 0, otherwise

and compute the expectation of the random variable

that counts the number of rounds.)

HOMEWORK 10 229

2. A collection A of events are d-wise independent if for any subset B S;; A of

size d or less, the probability that all events in B occur is the product of their
probabilities. Consider the following generalization of Luby's scheme. For
each u E Zp, let Au be any subset of Zp. Randomly select Xo, ... ,Xd-l E Zp.
Show that the p events

for U E Zp are d-wise independent. (Hint. Consider d x d Vandermonde

matrices over Zp with rows

(1 , u, 2 ..• , U d-l)
U,

shown in class to be nonsingular.)

3. Consider the following random NO algorithm for finding a maximal (not

maximum) matching in an undirected graph G = (V, E). The algorithm
proceeds in stages. At each stage, a matching M is produced, and the
matched vertices and all adjacent edges are deleted. Each stage proceeds
as follows:

(a) In parallel, each vertex u chooses a neighbor t(u) at random. Set

H := {( u, t( u)) I u E V} .

(b) If there are two or more edges (u, t(u)) in H with t(u) = v, then v
chooses one of them arbitrarily and deletes the rest from H.
(c) Let U be the set of vertices with at least one incident edge in H. Each
vertex in the graph (U, H) has degree 1 or 2. If 2, it randomly selects
one of its two incident edges as its favorite. If 1, it selects its one
incident edge as its favorite.
(d) For each edge e E H, e is included in M if it is the favorite of both
its endpoints.

Show that M is a matching, and the expected number of edges deleted is

at least a constant fraction of the remaining edges. Conclude that the ex-
pected number of stages before achieving a maximal matching is o (log m).
230 MISCELLANEOUS EXERCISES

Miscellaneous Exercises
1. Let (S,I,w) be a weighted matroid. Let M be the family of all maximal
independent sets of minimum weight, and let Imax be the family of all
subsets of elements of M. Show that (S,Imax ) is a matroid. (Hint. Use the
blue rule to give a procedure for finding an x E J - I such that IU{ x} E Imax
whenever I, J E Imax and III < IJI.)

2. Let T = (V, E) be a connected undirected tree such that each vertex has
degree at most 3. Let n = IVI. Show that T has an edge whose removal
disconnects T into two disjoint subtrees with no more than 2nt
vertices
each. Give a linear-time algorithm to find such an edge.

3. Show how to solve the all-pairs shortest path problem on directed graphs
when negative edge weights are allowed. (If there is no lower bound to the
weights of paths from s to t, then we define the distance from s to t to be
-00.)
4. Suppose that we wish to schedule n unit-time jobs on a single processor,
starting at time O. Associated with each job j is a deadline dj 2:: 1 and a
penalty Pj 2:: O. Job j must be completed by time dj or the penalty Pj is
incurred.

(a) Let S be the set of jobs. Call a subset A ~ S independent if all

the jobs in A can be scheduled without violating their deadlines, ir-
respective of the jobs not in A. Thus A is independent if, when the
elements of A are sorted by deadline, the ith element in sorted order
has deadline d(i) 2:: i. Let I be the set of independent subsets of S.
Show that (S, I) is a matroid.
(b) Give an efficient algorithm to produce a schedule that minimizes the
total penalty.

5. A pattern is a finite-length string over the alphabet {O, 1, *}. A pattern a

covers a string x of D's and 1's if x can be obtained from a by replacing
each occurrence of * with either 0 or 1. For example, the pattern 0 * *1
covers the four strings 0001, 0011, 0101, and 0111. A set A of patterns
covers a set B of strings if every string in B is covered by some pattern
in A. Show that the following problem is coNP-complete: given a set of
patterns of length n, do they cover all strings of O's and l's of length n?

6. (The Carpenter's Rule Problem) Prove that the following problem is NP-
complete: given a sequence of rigid rods of various integral lengths con-
nected end-to-end by hinges, can it be folded so that its overall length is
as most k?
 MISCELLANEOUS EXERCISES 231

. /c=::+~+~+~~._
hmge
.
5:.k

7. Give a parsimonious reduction from CNFSat to 3CNFSat.

8. The standard adjacency list representation of an undirected graph G, as de-

scribed for example in [3, p. 51]' consists of a linked list of vertices in which
the list element for vertex u contains a pointer to a linked list of pointers
to all vertices adjacent to u. For plane graphs, the counterclockwise order
of the vertices about u is given by the list order.
For our purposes, this representation is inadequate for two reasons. First,
in the representation of Lecture 14, the function - which reverses direction
cannot be computed in constant time. In addition, the representation
does not deal adequately with multiple edges; for example, it does not
distinguish the following two nonisomorphic1 plane graphs:

Describe an enhanced adjacency list representation in which distinct undi-

rected graphs with multiple edges and self-loops have distinct representa-
tions, each of the functions e, - , h, and t can be computed in constant
time, and single edges or vertices with all adjacent edges can be deleted
in time proportional to the number of objects deleted. In the absence of
multiple edges and self-loops, show how to obtain the new representation
from the old one in linear time. All computations are to be done with pure
pointer manipulation; no random access is allowed.

9. Let G = (E, e, -) be an undirected graph in the formalism described in

Lecture 14. Assume that G is represented by the adjacency list represen-
tation constructed in Miscellaneous Exercise 8. Show how to construct the
dual G* of G in linear time.

10. Let G = (E, e, -)

be an undirected graph in the formalism described in
Lecture 14. Show that its characteristic x( G) is always a nonnegative even
number.

11. Prove Theorem 14.6 of Lecture 14: agraphG= (E, e, -)hascharacteristic

e
x( G) = 0 iff corresponds to the counterclockwise ordering induced by
some plane embedding of G. (Hint. Use Exercise 10.)
IThey are isomorphic as graphs, but not as plane graphs.
 232 MISCELLANEOUS EXERCISES

12. The following problem arose recently in Keith Marzullo's META project.
Given an undirected graph with black and red vertices, does there exist
a maximal clique with no red vertices? Show that this problem is NP-
complete.
13. Show that the partition problem can be solved in polynomial time if the
weights are restricted to be integers and bounded in absolute value by a
fixed polynomial in the number of items.
14. Given n > 0, prove that there exists a number k such that when the
binary-to-Gray operation is applied k times in succession starting with any
bit string of length n, we get back the original bit string. What is the
smallest such k as a function of n?
15. (a) In the proof given in Lecture 27 of the #P-completeness of the perma-
nent, show that the four-node widget can be replaced by a three-node
widget.
(b) Show that no two-node widget exists.
16. Consider the following scheduling problem. You are given positive integers
m and t and an undirected graph G = (V, E) whose vertices specify unit-
time jobs and whose edges specify that the two jobs cannot be scheduled
simultaneously. Can the jobs be scheduled on m identical processors so
that all jobs complete within t time units?
(a) Give a polynomial time algorithm for t = 2. (Hint. Use Miscellaneous
Exercise 13.)
(b) Show that the problem is NP-complete for t ~ 3.
17. Let G be a directed graph with positive and negative edge weights and let
sand t be vertices of G. Recall that a path or cycle of G is simple if it has
no repeated vertices.
(a) Give a polynomial-time algorithm to determine whether G contains a
simple cycle of negative weight.
(b) Show that the problem of determining whether G contains a simple
path from s to t of negative weight is NP-complete.
18. Show how matching can be used to give efficient algorithms for the following
two problems.
(a) Given an undirected graph with no isolated vertices, find an edge cover
of minimum cardinality. (An edge cover is a subset of the edges such
that every vertex is an endpoint of some edge in the subset.)
(b) Find a vertex cover in a given undirected graph that is at most twice
the cardinality of the smallest vertex cover.
 MISCELLANEOUS EXERCISES 233

19. Give a fast algorithm to determine whether a given directed graph has a
cycle cover.
20. Given a bipartite graph G = (U, V, E), say that D ~ U is deficient if
IDI > IN(D)I, where N(D) denotes the set of neighbors of D; i.e.,
N(D) = {vEVI3uED(u,v)EE}.

Give a polynomial-time algorithm for finding a minimal deficient set if one

exists. (Hint. Use Hall's Theorem; see Exercise 3, Homework 6. Grow a
Hungarian tree.)
21. Let G be a connected undirected graph. We say G is k-connected if the
deletion of any k - 1 vertices leaves G connected. Give a polynomial-time
algorithm (ideally, O(k2 mn)) for testing k-connectivity, and for finding a
set of k - 1 disconnecting vertices if G is not k-connected. (Hint. Use
Menger's Theorem, which states that Gis k-connected if and only if any
pair of vertices is connected by at least k vertex-disjoint paths, then use
maximum flow. You need not prove Menger's Theorem.)
22. Let p be a monic univariate polynomial of degree k:
p(x) = Xk + ak_lx k- 1 + ... + alX + ao .
The companion matrix of p is the k x k matrix
0 1 0 0 0 0
0 0 1 0 0 0
0 0 0 1 0 0
Cp
0 0 0 0 1 0
0 0 0 0 0 1
-ao -al -a2 -a3 -a4 -a5
here illustrated for the case k = 6. The characteristic polynomial of Cp is
p itself. Show how to compute the nth power of Cp in time O(k 2 Iogn).

23. Let k be a finite field with q elements. Let A be an n x n matrix over k of

rank r. Prove that for an n X n matrix R with entries chosen independently
and uniformly at random from k,
1
II (1 -
r
Pr(rank (RA)2 = rank RA = rank A) = i) .
i=l q

24. The following problem arose recently in Tim Teitelbaum's synthesizer gen-
erator project. Let f be a binary function symbol, a and b constant sym-
bols, and X = {x, y, ... } a set of variables. A term is a well-formed expres-
sion over f, a, b, and X; for example, the following are terms:
a (1)
 234 MISCELLANEOUS EXERCISES

b (2)
x (3)
f(a,b) (4)
f(a,x) (5)
f(b,x) (6)
f(f(x,y),z) (7)
A term is a ground term if it contains no variables; for example, (1), (2)
and (4) above are ground terms. A ground term t is a substitution instance
of a term s if t can be obtained from s by substituting ground terms for the
variables of s; for example, (4) is a substitution instance of (5) obtained by
substituting b for x. A set of terms T is a cover if every ground term is a
substitution instance of some term in T; for example, (1), (2), (5), (6), (7)
form a cover.

(a) Show that determining whether a given set of terms is a cover is

coNP-hard. (Hint. Encode the problem of Miscellaneous Exercise 5.)
(b) Extra credit. Show that the problem is coNP-complete.

25. Give an NC algorithm for finding the preorder numbering of a directed tree.
That is, the algorithm should label each node of the tree with number of
vertices visited before it in a preorder traversal.

26. An outerplanar is a graph that can be embedded in the plane so that every
vertex is on the outer face. An outerplane graph is an outerplanar graph
along with such an embedding.

o
An outerplane graph.

(a) Give a linear-time algorithm for testing whether a graph is outer-

planar, and for finding an outerplane embedding if one exists. You
may use for free the Hopcroft-Tarjan linear-time algorithm for finding
a plane embedding of an arbitrary planar graph [52]. Warning: an
arbitrary plane embedding of an outerplanar graph is not necessar-
ily an outerplane embedding. Here are two embeddings of the same
outerplanar graph, one outerplane and one not:
 MISCELLANEOUS EXERCISES 235

(b) Find the best s(n) possible such that any outerplanar graph has a ~-~
separator of size s(n); i.e., such that there exists a partition A, S, B of
the vertices with IAI, IBI ~ 2;,
lSI ~ s(n), and there are no edges be-
tween A and B. Give a linear time algorithm for finding the separator.
(Hint. Use Miscellaneous Exercise 2.)

27. Assuming that comparisons between data elements take one unit of time
on one processor, give parallel sorting algorithms that run on a CREW
PRAM in
(a) time O(logn) with O(n 2) processors
(b) time O((logn)2) with O(n) processors
where n is the number of inputs. Your algorithm should produce an array
of length n containing the input data in sorted order.
28. An n x n matrix is called a circulant matrix if the ith row is obtained from
the first row by a right rotation of i positions, 0 ~ i ~ n - 1. For example,

[ ~ ! ~ ~l
c dab
bed a
is a 4 x 4 circulant matrix.
(a) Find an algorithm to multiply two n x n circulant matrices in time
O(logn) with O(n 2) processors.
(b) Assuming that the field contains all nth roots of unity and a multi-
plicative inverse of n, show that the processor bound in part (a) can
be reduced to O(n). Represent circulant matrices by their first row.
(Hint. See [3, pp. 256-257].)
(c) Under the assumptions of (b), find an algorithm to invert a nonsingu-
lar circulant matrix in O(logn) time with O(n) processors.
29. In Lecture 40 we gave an RNC algorithm to test for the existence of a
perfect matching in a given bipartite graph. In this exercise we extend this
technique to arbitrary undirected graphs.
The Thtte matrix of an undirected graph G = (V, E) is an n x n matrix T
with rows and columns indexed by V such that
Xuv, if (u,v) E E and u < v
Tuv = { -X vu ,if(u,v)EEandu>v
0, if(u,v)¢E
236 MISCELLANEOUS EXERCISES

where the X uv , U < v, are indeterminates.

(a) Show that det T "I- 0 iff G has a perfect matching.
(b) Use this fact to give an RNC test for the existence of a perfect match-
ing in G.
(c) If G has a perfect matching, show how to compute one in random
polynomial time.
III Homework Solutions
HOMEWORK 1 SOLUTIONS 239

Homework 1 Solutions
1. (a) Suppose I and J are maximal independent subsets of A, but III < IJI.
By property (ii) of matroids, we can find an x E J - I such that
I U {x} E I. But then I was not a maximal independent subset of A;
this is a contradiction.
Incidentally, it can be shown that for systems (S,I) satisfying axiom
(i) of matroids that the property we have just proved is equivalent to
axiom (ii) of matroids.
(b) The set I U {x} is dependent, since I is a maximal independent set.
It therefore contains a minimal dependent set D. We show that D is
unique. First, xED, since any subset of I is independent. Suppose
there were two such cycles D and D'; assume without loss of generality
that y E D - D'. The set (D U D') - {x} is a subset of I and is
therefore independent. The set D - {y} is also independent, since D
is minimal, and its cardinality is no more than that of (D U D') - {x}.
By property (ii) of matroids, elements of (DUD') - {x} can be added to
D-{y} until the cardinality is the same as (DUD')-{x}, maintaining
independence. Then y is not in the resulting set, since then D would
be a subset, and D is dependent. Therefore the resulting set must
be (D U D') - {y}. But this set contains D' as a subset, which is
dependent; this is a contradiction.
(c) Property (i) holds trivially, since removing an edge from a graph can-
not add any cycles. To show (ii), let E', E" ~ E such that (V, E') and
(V, E") have no cycles. Let d and d' be the number of connected com-
ponentsof (V,E') and (V, E"), respectively, m' = IE'I, mil = IE"I, and
n = IVI. Suppose that m' < mil. By the equation m+c = n proved in
class, d > d'. Then there must be an edge of E" between two distinct
connected components of (V, E'), otherwise all components of (V, E")
would be contained in components of (V, E'), implying that d' ~ d.
Adding that edge to E' cannot give a cycle.
The rank is n - c and the maximal independent sets are the spanning
forests.
Two good references about matroids in optimization problems are [85, 70].
An excellent reference on matroid theory itself is [107].

2. (a) Since the graph is acyclic, all directed paths are of length at most
n -1. Define

Euv {e EEl e lies on some E-path from u to v

of maximum length}
EH U Euv'
u,VEV
240 HOMEWORK 1 SOLUTIONS

For any (x, y) E E H , the only E-path from x to y is the edge (x, y)
itself; if there were a longer path, then (x,y) would never lie on any
maximal length path and would not be in E H. Thus

EH = {(u,v) EEl the length of the longest (1)

path from u to v is I} .

Let F be an arbitrary subset of E such that F* = E*. For e E E H,

if e ¢ F, then F* would not contain e either, by (1); this contradicts
F* = E*. Thus E H ~ F. Moreover, E; = E*, since any two
vertices connected by a path are connected by a path of maximum
length. Since E; = E* and EH is contained in every subset of E
whose transitive closure is E*, it is the unique minimal such set.
(b) Our algorithm to find E H simply removes all edges (u, v) of E for
which there exists a path of length two or more from u to v. We
use the adjacency matrix representation. Let E denote this matrix.
Using Boolean matrix multiplication (V instead of +, /\ instead of .),
the matrix Ek has a 1 in position (u, v) iff there is a path from u to v
of length exactly k. Compute the transitive closure matrix

E* I V E V E2 V ... V E n- 1 V En V ...
I V E V E2 V ... V E n - 1 (why?)
(I V E)n-l .

This can be done by repeated squaring in time O(M(n) logn), where

M(n) is the time to multiply two n x n matrices. (We can actually
compute E* in time O(M(n)), as we will see later.) Then compute
E2 . E*. This matrix has a nonzero value in position (u, v) iff there is
a path oflength at least 2 from u to v. Finally, the adjacency matrix
of EH is given by E /\ -,(E 2 . E*).
In this problem the goal was to minimize the running time. If the goal
were to minimize the amount of extra space used, then an in-place algo-
rithm would be better; see [46]. The original paper showing that transitive
reduction is as easy as transitive closure is [2].

3. This solution is from [85].

(a) Suppose the graph is connected and each vertex is of even degree.
Starting from an arbitrary vertex v, trace an arbitrary path, traversing
edges at most once (mark each edge as traversed as we encounter it),
until we return to v. This must happen eventually: because each
vertex is of even degree, is impossible to get stuck. Now delete the
cycle we have found. Deleting a cycle maintains the invariant that all
vertices are of even degree, but the graph may no longer be connected.
HOMEWORK 1 SOLUTIONS 241

However, we can repeat the process on the connected components,

and so on until all edges have been deleted. Now we string the cycles
together to form one long cycle. Two cycles that contain a vertex v can
be combined into one cycle in a figure 8, with v at the intersection
point. Since the graph is connected, it is possible to string all the
cycles together in this way to get one long cycle, an Euler circuit.
Conversely, if there is an Euler circuit, then each vertex v is of even
degree, since each occurrence of v on the circuit accounts for two
incident edges.
(b) We assume an adjacency list representation of the graph. Starting at
vertex vo, trace an arbitrary path until we return to Vo as in part (a),
giving a cycle c = VO, VI, ... ,Vn-b Vo (the vi's need not be distinct).
As we traverse c, we delete each edge from the graph and create a
doubly-linked circular list of these edges in the order they are encoun-
tered. Now for each Vi in order, we recursively find an Euler circuit ~
beginning and ending with Vi in the connected component containing
Vi' We link Ci into c at Vi and then go on to Vi+!. In the recursive call
to get an Euler circuit in the connected component of Vi, any Vj, j > i,
in that connected component will have all remaining edges deleted, so
by the time the algorithm gets to vi' the connected component of vi
will consist only of vi and there will be no work to do.
The algorithm runs in O(m) time, because there is only a constant
amount of work done for each edge.
242 HOMEWORK 2 SOLUTIONS

Homework 2 Solutions
1. As shown in Theorem 4.8, a directed graph is a dag iff the DFS tree has no
back edges. It was also shown that if the DFS tree is numbered in postorder,
then all edges go from higher numbered vertices to lower numbered vertices.
Then this numbering gives a topological sort.
2. (a) The graph G has an embedding consistent with (J iff this is true for
every connected component of G, so we can assume without loss of
generality that G is connected.
Assume the adjacency lists are ordered according to (J. Then a depth-
first search corresponds to traversing the edges clockwise around each
face. All back edges can be drawn going up the right side of the path
from the root down to the source of the back edge. The very first back
edge encountered can be taken to be on the outer face. We need only
maintain a stack of back edges that we are "inside", and make sure
that any new back edge does not go up higher than the destination
vertex of the innermost back edge that we are inside. The back edges
that we are inside form a chain.
In Lecture 14, Theorem 14.6 and Miscellaneous Exercise 11 we will
see another approach using Euler's Theorem, which states that n +
n* - m = 2 for a connected plane graph G, where n, n*, m are the
number of vertices, faces, and edges of G, respectively. We will use the
theorem in the opposite direction: given (J, we calculate the number
n* of "faces". We will show that n + n* - m = 2 iff (J does indeed
correspond to a plane embedding with n* faces.
(b) If G is not planar then it has no planar embeddings. Otherwise, G
has exactly one embedding on the sphere consistent with (J. We can
choose the North Pole to be in anyone of the faces of the embedding
and then project the graph onto the plane from the North Pole. Each
choice of face for the pole gives a different embedding in the plane.
Thus there are as many different embeddings as faces of G.
Suppose now that G is not connected. Number the connected com-
ponents 0,1, ... , c -1 and let Ii be the number of faces of component
i. There are Ii ways to choose the outer face of the component i, so
there are loft·· . Ic-l ways to choose all the outer faces. To get the
number of embeddings, we must multiply this by the number of ways
to place the components inside the inner faces of other components.
For example, when c = 2, there are ft - 1 ways to place component 0
inside an inner face of component 1, 10 - 1 ways to place component
1 inside an inner face of component 0, and one way to place the
components so that neither occurs inside the other. This gives
(fo - 1) + (ft - 1) + 1 .
HOMEWORK 2 SOLUTIONS 243

We claim that with c components this number is

c-l
(1 + '2Jli - l))C-l .
i=O

Each embedding determines a labeled forest whose vertices are the

components. A component i is a child of another component j in
this forest if it occurs inside an inner face of j with no intervening
components. The component i can be placed inside anyone of h - 1
inner faces of j; let us indicate this by labeling the edge (i,j) in the
forest with the factor h - 1. Thus the number we are seeking is the
sum over all labeled forests of the product of the edge labels on that
forest.
We modify an argument of Priifer that there are nn-2 labeled trees on
n nodes (see [62]). We establish a one-to-one correspondence between
labeled forests and sequences of length c - 1 from the set

{T,O, 1, ... ,c -I} (2)

as follows. Given a labeled forest, start with the null sequence and
repeat the following operation until there is only one vertex left. Prune
off the lowest numbered leaf i and append j to the sequence, where j
is the parent of i. If i has no parent, then append T to the sequence.
Then each labeled forest determines a sequence of length c - 1, and it
is not difficult to reconstruct the forest uniquely from the sequence.
For each sequence ao, ab . .. ,ac -2 of length c - lover the set (2), the
product of the edge labels on the labeled forest corresponding to that
sequence is

where g(i) = Ii - 1 and g(T) = 1. The number we are seeking is the

sum of all such products. This number is
c-l
(g(T) + g(O) + g(l) + ... + g(c _1))c-l (1 + LUi - l))c-l .
i=O

The total number of embeddings is this number times the number of

ways of choosing the outer faces of the components, or
c-l c-l
(1 + LUi - 1))c-l II Ii .
i=O i=O

3. Here is an algorithm that takes 5n probes of the adjacency matrix. Let

d(v) be the degree of vertex v. The main difficulty is to locate one of the
244 HOMEWORK 2 SOLUTIONS

interesting vertices (the body, tail, or sting); once we have done that, we
can locate all the other interesting vertices with 3n probes and check that
the graph is a scorpion. For example, if we have found a vertex v with
d( v) = n - 2, then that vertex must be the body if the graph is a scorpion.
By scanning the v th row of the matrix, we can check that d( v) = n - 2 and
determine its unique non-neighbor u, which must be the sting if the graph
is a scorpion. Then by scanning the uth row, we can verify that d(u) = 1
and find its unique neighbor w, which must be the tail; and with n more
probes we can verify that d( w) = 2.
We start with an arbitrary vertex v, and scan the vth row. If d(v) = 0 or
n -1, the graph is not a scorpion. If d(v) = 1, 2, or n - 2, then either v is
interesting itself or one of its 1 or 2 neighbors is, and we can determine all
the interesting vertices as above and check whether the graph is a scorpion
with at most 4n additional probes.
Otherwise, 3 :5 d( v) :5 n - 3, and v is boring. Let B be the set of neighbors
of v and let S = V - (B U {v}). The body must be in B and the sting
and tail must be in S. Choose arbitrary x E Band yES and repeat
the following: if x and y are connected, then delete y from S (y cannot
be the sting) and choose a new yES. If x and y are not connected, then
delete x from B (x is not the body unless y is the sting) and choose a new
x E B. If the graph is indeed a scorpion, then when this process ends, B
will be empty and y will be the sting. To see this, observe that B cannot
be emptied without encountering the sting, because the body cannot be
deleted from B by any vertex in S except the sting; and once the sting is
encountered, all remaining elements of B will be deleted.
Whether or not the graph is a scorpion, the loop terminates after at most
n probes of the adjacency matrix, since after each probe some vertex is
discarded.
If a property is such that we have to look at every entry in the adjacency
matrix, then that property is said to be evasive. Many monotone graph
properties have been conjectured to be evasive. Yao [110] has shown that all
monotone bipartite graph properties are evasive if we are given a bipartite
adjacency matrix representation. The question for general graphs remains
open. BolloMs discusses this issue in his book [13]. He gives a 6n-probe
solution to the scorpion problem there.
HOMEWORK 3 SOLUTIONS 245

Homework 3 Solutions
1. The structure (RegE, U,·, *,0, {t:}) is a Kleene algebra if it satisfies the
axioms of Kleene algebra. We therefore need to show, for any regular sets
A,B and G,
Au (BUG) (AUB) uG
AUB BuA
AuA A
Au0 0uA = A
A· (B·G) (A· B)· G
A· {t:} {t:}·A = A
0·A A·0 = 0
A· (BUG) A·BuA·G
(BUG) ·A B·AuG·A
A·B*·G supA· Bn·G. (3)
n~O

Note that the natural order on RegE is set inclusion ~,since

A~B +-+ AUB=B.

Most of the above properties are obvious. The only one we will verify
explicitly is (3). Recall the definition of the * operator in RegE:
B* = {t:}U{YIY2···Ynln~land YiEB, l~i~n}.
Recall also that, by definition,
BO {t:}
n
B +! B. Bn.
It follows by induction on n that

Bn = {YIY2··· Yn I Yi E B, 1 ~ i ~ n} .
To be in the regular set on the left side of equation (3), a string must be
of the form XYIY2 ... YnZ for some n ~ 0, where x E A, Z E G, and Yi E B,
1 ~ i ~ n. Here we allow the possibility n = 0, in which case the string
would be of the form xz. Thus the left side of (3) is equal to the set

This is the least upper bound of the sets A· Bn. G, n ~ 0, with respect to
set inclusion ~: it is an upper bound, since it includes all the A . Bn . G
as subsets; and it is the least upper bound, since any set that includes all
the A . Bn . G must include their union.
246 HOMEWORK 3 SOLUTIONS

2. Let REXPE = {regular expressions over ~}, let K be an arbitrary Kleene

algebra, and let I be an interpretation
I : REXPE --+ K.
The proof will proceed by induction on the structure of (3. There are three
base cases, corresponding to the regular expressions b E ~, 1, and O. For
b E ~, we have R(b) = {b} and
sup I(ax,) = I(abr).
xER(b)

The case of 1 is similar, since R(l) = {fl. Finally, since R(O) = 0 and
since the element OK: is the least element in K and therefore the supremum
of the empty set,
sup I(ax,) sup 0
XER(O)

There are three cases to the inductive step, one for each of the operators
+, ., *. We give a step-by-step argument for the case +, followed by a
justification of each step.
I(a)· (I((31) + I((32))' I(r) (4)
(I(a) . I((31)' I{-y)) + (I(a) . I((32) . I(r)) (5)
I(a(3n) + I(a(32,) (6)
sup I(ax,) + sup I(an) (7)
XER(th) YER(~2)

sup I(az,) (8)

zER(~1)UR(~2)

sup I(az,). (9)

ZER(~1+~2)

Equation (4) follows from the properties of the map I; (5) follows from the
distributive laws of Kleene algebra satisfied by K; (6) again follows from
the properties of the map I; (7) follows from the induction hypothesis on
(31 and (32; (8) follows from the general property of Kleene algebras that
if A and B are two sets whose suprema sup A and sup B exist, then the
supremum of Au B exists and is equal to sup A + supB (this requires
proof-see beloW); finally, equation (9) follows from the definition of the
map R interpreting regular expressions as regular sets.
The general property used in equation (8) states that if A and B are two
subsets of a Kleene algebra whose suprema sup A and sup B exist, then the
supremum sup A U B of A U B exists and
supAUB = supA+supB.
HOMEWORK 3 SOLUTIONS 247

To prove this, we must show two things:

(i) supA+supB is an upper bound for AUB; that is, for any x E AUB,
x :s; sup A + sup B; and
(ii) sup A + sup B is the least such upper bound; that is, for any other
upper bound y of the set A U B, sup A + sup B :s; y.

To show (i),

x E Au B -+ x E A or x E B
-+ x:S; sup A or x :s; supB
-+ x:S; sup A + sup B .

To show (ii), let y be any other upper bound for Au B. Then

"Ix E Au B x :s; y -+ "Ix E A x :s; y and "Ix E B x :s; y

-+ sup A :s; y and sup B :s; y
-+ sup A + sup B :s; y + y = y.

We give a similar chain of equalities for the case of the operator ., but omit
the justifications.

1(a) ·1(/31) . 1(/32) ·1(r)

1 (a/31 (/32' »
sup 1(ax(/32,»
XER({h)
sup 1((ax)/32,)
xER(!31)
sup sup I(axy,)
XER(!3,) yER({32)
sup I(axy,)
xER({31), yER(!32)
sup I(az,).
ZER(!31!32)

Finally, for the case *, we have

1(a/3*,) I(a) .1(/3)* ·1(r)

supI(a)· I(/3t· I(r)
n::O:O
supI(a/3n , )
n::O:O
sup sup I(ax,)
n::O:O xER({3")

sup I(ax,)
n::O:O, xER({3n)
248 HOMEWORK 3 SOLUTIONS

sup I(ax'Y)
XEU,,~O R(P")
SUp I(ax'Y).
XER(P*)

3. Suppose we are given a directed graph G = (V, E, £) with nonnegative edge

weights £. The quantity £(e) is called the length of e E E. Define the length
£(P) of a directed path p to be the sum of the edge lengths along pj thus
n
£(e1 e2··· en) = "L£(ei).
i=l

In the version of Dijkstra's algorithm of Lecture 5, we use the loop invariant

that the variable X contains the set of vertices whose minimal distance from
s has already been determined, and D(y) gives the minimum distance from
s to y through only elements of X. Here we have to keep track of the paths
themselves. To do this we will use pointers P(·). The new invariants are:

• for v E V, the path p(v) = v, P(v), P(P(v)), ... is a shortest path

from v back to s such that all vertices except possibly v lie in X, or
..1 if no such path existsj
• D(v) = £(p(v))j
• for any U E X, v ¢ X, D(u) :::; D(v).
Here is the algorithm:
HOMEWORK 3 SOLUTIONS 249

X:= {s}j
P(s) := nilj
for each v E V - {s} do
if (s, v) E E then
P(v):= Sj
D(v):= l(s,v)
else
P(v) := 1..j
D(v) := 00
end if
end forj
while X =J V do
let u E V - X such that D(u) is a minimumj
X:=XU{u}j
for each edge (u, v) with v E V - X do
if D(u) +l(u,v) < D(v) then
P(v) := Uj
D(v):= D(u) +l(u,v)
end if
end for
end while
250 HOMEWORK 4 SOLUTIONS

Homework 4 Solutions
1. (a) The algorithm is correct because each step is an instance of the blue
rule in the spanning tree matroid.
(b) Prim's algorithm is a variant of Dijkstra's shortest-path algorithm.
The implementation is very similar to the solution to Exercise 3 of
Homework 3. We maintain a Fibonacci heap containing the set V -T,
where V is the set of all vertices and T is the set of vertices in the
portion of the spanning tree chosen up to that point. The value D(v)
for the purposes of findmin, deletemin and decrement is the weight
of the minimum-weight edge connecting v to a vertex in T, or 00 if no
such edge exists. In addition, we maintain with each vertex v in the
heap a pointer P( v) to a vertex in T closest to v; i. e., a u E T such
that d(u,v) = D(v).
We initialize the values D(v) and P( v) after the first vertex u is chosen
by setting D(v) := d(u,v) and P(v) := u for each vertex v adjacent
to u and D(v) := 00 and P(v) := nil for each vertex v not adjacent
to u.
At each step, we find the element w of the heap such that D(w) is
minimum, delete it from the heap, and add it to T. We also add the
edge (w, P( w)) to the spanning tree. Then we update distances as
follows: for each edge (w,v), v rt T, if d(w,v) is less than D(v), we
set D(v) := dew, v) and P(v) := w.
It takes constant time for each edge or Oem) time in all to do the
updates. Using the Fibonacci heap, it takes O(nlogn) time amor-
tized over the entire sequence of operations to maintain the heap, find
the minima and delete them, and decrement the values D(v) when
necessary.

2. Let Ok be the k x k checkerboard graph:

010

The number of vertices is n = k 2 • We show that the smallest ~-~ separators

of Ok are of size at least ~ - ~ = n(vIn).
Consider an arbitrary partition of the vertices of Ok into A, B, and S such
that IAI, IBI ::; 2n/3 and there are no edges between A and B. If there is
HOMEWORK 4 SOLUTIONS 251

an element of 8 in every row or an element of 8 in every column, we are

done. Otherwise, there must be some row r and some column c with no 8
vertices. The row r must contain all A vertices or all B vertices, since if it
contained some of each, it would have to have an 8 vertex to separate them.
Without loss of generality assume it contains only A vertices. Similarly, c
contains only A vertices or only B vertices, and they must be A vertices,
since c intersects r. Thus there is an A vertex in every column and every
row, since every row intersects c and every column intersects r. If a column
or row has a B vertex, then it must also have an 8 vertex to separate it
from the A vertices. So any column or row containing a B vertex must also
contain an 8 vertex. Thus there are at most 181 columns containing a B
vertex and at most 181 rows containing a B vertex; hence at the very most,

However, since IAI ~ 2n/3,

IBI (IAI + 181)

n-
n
> 3- 181 .
Combining these inequalities, we get

and 181 must be at least as big as the positive root of this quadratic:
-1+~
181 > 2
-1+/¥
> 2
k 1
y'3 - 2
252 HOMEWORK 5 SOLUTIONS

Homework 5 Solutions
1. (a) For every edge (u,v) in G, compute the residual capacity from u to v
using the formula r( u, v) = c(u, v) - 1(u, v), where c is the capacity
function. Also compute the residual capacity r( v, u) in the opposite
direction. If r(u, v) is zero, then do not put the edge (u, v) into G f .
Otherwise, put the edge (u, v) into G f with capacity r( u, v). Do the
same for (v, u). All the relevant computations can be done in O(m)
time since we spend at most constant time for each edge.
(b) A minor modification of the algorithm of Exercise 3, Homework 3 does
it. The only difference is that we are seeking paths of maximum bot-
tleneck capacity instead of minimum length. Here is the algorithm:

X:= {s};
P(s) := nil;
for each x E V - {s} do
D(x) := r(s,x);
P(x):= s
end for;
while X i=- V do
let x E V - X such that D(x) is a maximum;
X:=XU{x};
for each edge (x, y) E E f such that y E V - X do
ifmin(D(x),r(x,y)) > D(y) then
P(y):= x;
D(y) := min(D(x), r(x, y))
end if
end for
end while

2. Let every edge in G have unit capacity and find a maximum flow 1* in G.
Then there exist k edge-disjoint paths from s to t if and only if 11* 12': k:
certainly if there exist k edge-disjoint paths, then 11* 1 2': k by pushing
one unit of flow along each path. Conversely, if 11*1 2': k, then we can
repeatedly find a path flow from s to t with unit flow as in the proof of
Lemma 17.4, then remove the edges along this path and repeat. With each
iteration the flow value decreases by one, so at least k paths are found.

3. Make G a directed graph by replacing each undirected edge {u, v} with two
directed edges (u, v) and (v, u). The capacities on these directed edges will
be the same as those on the corresponding original edge. Find a maximum
flow from s to t in this network and compute the residual graph of this
flow. Take A to be the set of vertices reachable from s in the residual
graph, and let B be the rest. By the Max Flow-Min Cut Theorem, this
HOMEWORK 5 SOLUTIONS 253

cut has minimum weight in the network. It is also a minimum cut for the
original undirected graph because any edge between A and B has the same
weight in both graphs.
254 HOMEWORK 6 SOLUTIONS

Homework 6 Solutions
1. Gale and Shapley were the first to investigate the stable marriage problem
and gave this solution in 1962 [36].
Let rg(b) be g's ranking of b, rb(g) be b's ranking of g. Let B be the set of
boys and G be the set of girls, n = IBI = IGI. If M is a partial matching,
let BM = {b 13g (b,g) E M} and G M = {g 13b (b,g) EM}. Let M(b) = 9
if (b,g) E M, undefined if no such 9 exists. Let M(g) = b if (b,g) E M,
undefined if no such b exists. Execute the following program:

M:=0j
whileIMI < n do
9 := arbitrary element of G - GM ;
b:= element of B with rg(b) maximum and either
(i) b ¢ BM
(ii) bE BM and rb(g) > rb(M(b));
if (i), set M:= M U {(b,g)};
if (ii), set M := (M - {(b, M(b)}) U {(b, g)}
end while

The following invariants are maintained by the while loop:

• M is stable;
• if rg(b) ~ rg(M(g)) then b E B M .

The algorithm halts in O(n 2 ) iterations of the while loop because the
quantity

increases by at least one each time.

2. Ford and Fulkerson solved this problem by reducing it to a network flow

problem and then applying the Max Flow-Min Cut Theorem [34].
In a bipartite graph G = (U, V, E), the size of any matching is at most the
size of any vertex cover, since all matched edges must have at least one
endpoint in the cover. To show that this bound is attained, we construct
a flow network H with vertices U U V U {s, t} and edges

{(s, u) I u E U} U E U {(v, t) I v E V} .

The edges of E are directed from U to V in H. We give the edges of E

infinite (or sufficiently large finite) capacity, and all other edges capacity
1. Let S, T be a minimum s, t-cut in H. This cut has finite capacity, since
HOMEWORK 6 SOLUTIONS 255

it is bounded by the capacity of the cut {s}, (U u V u {t}) - {s}, which is

lUI. Therefore, no edge in E can cross from S to T, since those edges have
infinite capacity. Thus each edge in E either

• has both endpoints in S,

• has both endpoints in T, or
• crosses from T to S.
In any of these three cases, the edge is incident to an element of the set

(TnU) u (snv) ,

so this set forms a vertex cover of G. Moreover, the capacity of the cut
S, T is the size of this set, which is also the maximum flow value in H by
the Max Flow-Min Cut Theorem. In Lecture 18 we argued that the size of
the maximum matching in G is the value of a maximum flow in H.

3. Suppose first that G has a matching in which every vertex of U is matched.

Let S be a subset of U. For every vertex s E S, the vertex that s is matched
to appears in N (S). Since no two vertices in S are matched to the same
vertex in V, we have IN(S)I ~ lSI.
Conversely, suppose G does not have a matching in which every vertex of
U is matched. By the Konig-Egervary Theorem, there exists a vertex cover
C of G containing fewer than lUI vertices. Let S = U - C. All vertices
adjacent to vertices S must be in V n C, otherwise C would not be a vertex
cover; i.e., N(S) ~ V n C. Then

IN(S)I < IV n CI
ICI-IU n CI since U and V are disjoint
< IUI-iunci
lSI since S is defined to be U - C.

Thus there exists an S ~ U such that IN(S)I < lSI.

Hall's theorem is sometimes called the Marriage Theorem because it tells
us whether all U vertices can be "married" to a V vertex of their own.

4. Let d be the degree of the vertices in the regular bipartite graph G =

(U, V, E). The total number of edges is

d· lUI = d· IVI ,
thus lUI = IVI; therefore any matching that uses all the vertices in U will
be a perfect matching in G. By Hall's Theorem, it suffices to show that
lSI:::; IN(S)I for any S ~ U. For an arbitrary subset S of U, consider the
subgraph of G induced by S U N(S). There are exactly d ·ISI edges in this
256 HOMEWORK 6 SOLUTIONS

subgraph, since every vertex in S has degree d. Similarly, this subgraph

has no more than d· IN(S)I edges, because no vertex in N(S) has degree
larger than d. Thus

d ·ISI < d· IN(S)I .

It follows that lSI ~ IN(S)I·

One of the reasons that matching theory is interesting is because of beauti-

ful min-max theorems like the Konig-Egervary Theorem and Hall's Theorem.
Lovasz and Plummer's book [75J provides extensive coverage of matchings for
those who want to learn more about them. Papadimitriou and Steiglitz [85J
and Lawler [70J also discuss important algorithmic and theoretical aspects of
matchings.
HOMEWORK 7 SOLUTIONS 257

Homework 7 Solutions
1. (a) We reduce the general CNFSat problem to the restricted problem in
which variables are allowed at most three occurrences to show that
the restricted problem is NP-hard. Given the CNF formula B, let x
be a variable with exactly m occurrences in B. Let xI, X2, ••. ,Xm be
m new variables. Replace the ith occurrence of x with Xi and append
the CNF formula

which is equivalent to the chain of implications

This will force all the Xi to have the same truth value in any satisfying
assignment, and there are exactly three occurrences of each Xi. Do
this for all variables in the original formula.
The restricted problem is in NP, since it is a special case of the unre-
stricted CNFSat problem. Therefore it is NP-complete.
(b) If a variable X appears only positively (only negatively), then we can
satisfy the clauses containing x by assigning x the value true (false),
thus we might as well eliminate those clauses. The new formula is
satisfiable iff the original one is.
Suppose then that the variable x appears both positively and nega-
tively. Since there are only two occurrences of x, there is one of each.
If the occurrences are in the same clause, then that clause is true un-
der any truth assignment, and we can eliminate it. If not, and if the
two clauses contain no other variables, then we have reached a con-
tradiction x 1\ oX and there is no satisfying assignment. Otherwise,
we apply the resolution rule of propositional logic: we combine the
two clauses containing x, but throw out x itself. For example, if one
clause is x V y V z and the other is oX V u V v, then the new clause is
y V z V u V v. Again, the new formula is satisfiable iff the original one
was.
We continue applying these rules until we see a contradiction x 1\ oX
or we eliminate all of the variables. In the latter case, the formula is
satisfiable.
The resolution rule is a widely used proof procedure for propositional
logic. It is known to require exponential time in the worst case when
there are no restrictions on the number of occurrences of variables
[47,101]. Resolution, suitably extended to handle first-order formulas,
forms the basis for many PROLOG implementations.
258 HOMEWORK 7 SOLUTIONS

2. If the graph is not strongly connected, there is no TSP tour. Otherwise,

we calculate the weight w* of an optimal TSP tour as follows. Let w( e)
be the weight of edge e and let d = max.,EE w (e) . There exists a tour of
weight at most n 2 d consisting of minimum-weight paths between pairs of
vertices (Ul' U2), (U2' U3), ... , (un' Ul) placed end to end. Starting with n 2d,
perform a binary search to find w*. This can be done in polynomial time,
because we have to make only O(log(n2 d)) = O(logn + log d) calls to our
subroutine that tells whether there exists a TSP tour of weight k, and log d
is the size of the binary representation of d.
Next we wish to determine the number of times each edge is traversed in
some optimal tour. Note that these numbers are not unique; different tours
may traverse an edge different numbers of times. Consider an operation
in which we replace the edge e = (u, v) with the graph Dk pictured below
right, where k is the number of extra vertices. In the example shown, k = 5.
U U

v v

We give each ofthe edges in Dk weight w(e)/2. Any tour in the new graph
gives rise to a tour in the old graph of the same weight. Conversely, any
tour in the old graph that traverses e at least k times gives rise to a tour
in the new graph of the same weight. Thus the weight of an optimal tour
in the new graph is at least w*, and strictly greater than w* if all optimal
tours in the old graph traverse e fewer than k times. Since no optimal tour
of the old graph traverses e more than n times, if k > n then the weight of
the optimal tour in the new graph must be strictly greater than w*.
Now, for each edge e in turn, we replace e with D k , where k is as large as
possible such that there still exists a tour of weight w*. We discover k by
binary search in the interval 0 ~ k ~ n. When we are done, there is a tour
of weight w* in the resulting graph that traverses each edge exactly once (if
not, some Dk could have been replaced by Dk+l). We find an Euler circuit
in this graph, which will give rise to a TSP tour in the original graph of
optimum weight w*.

3. Let B be a CNF formula. We wish to produce an undirected graph G =

(V, E), integer k, and distinguished vertices Si, t i , 1 ~ i ~ k, such that there
exist k vertex-disjoint paths connecting the Si and ti iff B has a satisfying
truth assignment.
HOMEWORK 7 SOLUTIONS 259

Let 0 be the set of clauses, let X be the set of variables, and let L be the
set of occurrences of literals in B. Let the set of vertices be

v = L U {Se, te ICE O} U {S"" t", I x E X}

and take k = 101 + IXI. For CEO, connect all occurrences of literals in C
to Se and te' For x EX, connect all the positive occurrences of x in B in
a single path, connect the negative occurrences of x in a single path, and
connect one endpoint of each of these two paths to s'" and the other to t",.
For example, consider the formula

B = (x V fj V z) 1\ (x V y V z) 1\ (x V y V z)
'----v----' '----v----' '----v----'
C d e

with variables X = {x, y, z} and clauses 0 = {c, d, e}. The construction

produces the following graph:

/'''' I""r--. I""r--.

S'".t ~

Sy.t ~

.t ~

'-.,.-1
"...... "......
If B has a satisfying assignment, then for each CEO, take the path from
Se to te of length two through some true literal of c, and for each x EX,
take the path from s'" to t", through the false literals. These k paths are
vertex-disjoint. Conversely, suppose there are k vertex-disjoint paths. The
path from s'" to t"" x E X, must go through either all and only the positive
occurrences of x or all and only the negative occurrences of x; any deviation
would necessarily go through some Se or te' Assign x true if the path from
s'" to t", goes through the negative occurrences of x and false if it goes
through the positive occurrences of x. Since the paths are vertex-disjoint,
the paths from Se to t e , CEO, go through only true literals. Thus the
truth assignment satisfies all clauses.
The problem is in NP since the disjoint paths can be guessed and verified
in polynomial time.
260 HOMEWORK 8 SOLUTIONS

Homework 8 Solutions
1. This problem is in coNP because its complement is in NP: we can guess
a value for each variable and verify in polynomial time that the given
expression does not vanish. We show coNP-hardness by showing that its
complement is NP-hard using a reduction from CNFSat. Given a Boolean
formula, we transform it into an algebraic expression that vanishes mod
p for all variable assignments iff the original formula is unsatisfiable. We
simulate the Boolean values true and false with 1 and 0 in Zp, respectively.
If x is a variable of the Boolean formula, replace it with xp - 1 . Replace each
expression -,A by 1 - A, A /\ B by AB, and A V B by A + B - AB.
2. (a) The restricted problem remains in NP, so the difficult part is to show
NP-hardness. We do this by reducing the undirected Hamiltonian
circuit problem to TSP with the triangle inequality. Given an undi-
rected graph G = (V, E), we will construct a symmetric distance
function d : V x V --t N satisfying the triangle inequality such that
G has a Hamiltonian circuit iff it has a TSP tour of length n. Let

d(u v)
,
= {I2 E
if (u,v) E,
if(u,v)¢E.
Then d obeys the triangle inequality trivially. A TSP tour in G that
has length n must contain only edges of length 1. Thus it corresponds
directly to a Hamiltonian tour in G.
(b) Actually, it is possible to find in polynomial time a tour that is no
worse than 3/2 times the optimal tour by using an algorithm known
as Christofides 'heuristic. Our solution will only be guaranteed to be
no more than twice the optimal solution, but it is important to un-
derstand how our solution works before looking at Christofides' algo-
rithm, which uses matching. Papadimitriou and Steiglitz [85] discuss
Christofides' heuristic for those interested in finding out more about
it.
We will assume that distances are symmetric. First, we find a mini-
mum spanning tree T. Next, we create a directed graph G by using
two copies of each edge of T, one in each direction. Finally, we find
an Euler circuit in G, which gives a TSP tour of weight twice that of
the minimum spanning tree. Since every TSP tour contains a span-
ning tree of the original graph, the length of any TSP tour is at least
as large as the weight of the minimum spanning tree. Therefore, the
length of our Euler circuit is no more than twice the length of the
optimal TSP tour.
Since the triangle inequality holds, we can convert the Euler circuit
to a TSP tour of no greater weight in which vertices are visited only
once: we merely skip over vertices previously visited.
HOMEWORK 8 SOLUTIONS 261

3. Recall that if G = (V, E) is not acyclic, its transitive reduction or Hasse

diagram is not necessarily unique. The problem is in NP, since we can
just guess a transitive reduction, verify that it is antitransitive (i. e., that
if (u, v) and (v, w) E E then (u, w) fj. E), take its transitive closure, and
verify that this is the same as the transitive closure of E.
We show that the transitive reduction problem is NP-hard by exhibiting
a reduction from the directed Hamiltonian circuit problem. The reduction
from the vertex cover problem to the directed Hamiltonian circuit problem
given in Lecture 24 produces a strongly connected graph, whether or not
it has a Hamiltonian circuit. Thus the problem of determining whether
a given strongly connected graph has a Hamiltonian circuit is also NP-
hard. We now argue that a strongly connected graph H has a Hamiltonian
circuit if and only if it has a transitive reduction with at most n edges.
Note that the transitive closure of such a graph is the complete graph.
If H has a Hamiltonian circuit, then the Hamiltonian circuit itself serves
as a· transitive reduction, and it has exactly n edges. Conversely, any
transitive reduction of H must contain at least n edges, since it must enter
every vertex at least once, since H is strongly connected. If it contains
exactly n edges, then it enters every vertex exactly once, thus it must be a
Hamiltonian circuit.
262 HOMEWORK 9 SOLUTIONS

Homework 9 Solutions
1. We will use the concurrent-read exclusive-write (CREW) PRAM model
with unit cost for integer operations and comparisons.
Represent the dag G as an adjacency matrix A. Compute its reflexive
transitive closure G* either by computing A* = (I V A)n in NC using
parallel prefix, or more efficiently, using the relationship between matrix
multiplication and transitive closure discussed in Lecture 5. Then sort the
vertices by indegree in G* using the algorithm of Miscellaneous Exercise
27. This gives a topological sort, since if there is a path from u to v in G,
then vertex u has smaller indegree than v in G*.

2. If G has an odd cycle, then it must have an odd simple cycle (one with no
repeated vertices), because any odd cycle that is not simple is composed
of two smaller cycles, one of which must be odd. Therefore, to check for
an odd cycle, we need only check for a path of odd length at most n from
a vertex back to itself. The kth power of the adjacency matrix A of G tells
us the paths of length k in G. Using parallel prefix, we can compute all
the odd powers of A up to n in NC and see if any of them contain a 1 on
the main diagonal.
This algorithm is NC, but it is not very efficient in its use of processors.
We can save a factor of n processors by observing that we only have to
check the diagonal of Ak for some odd k greater than n - 1. If there is an
odd cycle of shorter length, we can extend it to one of length k by retracing
an edge backwards and forwards. Thus we can use matrix powering instead
of parallel prefix.
Another approach would compute the * of a matrix A over a Kleene algebra
consisting of four elements 1., 0, 1, and T, where the operations + and·
are given by

I + Ill. I 0 I 1 I T I I " 1. I 0 I 1 I T I
1. 1. 01 T 1. 1. 1. 1. 1.
0 0 0 T T 0 1. 0 1 T
1 1 T 1 T 1 1. 1 0 T
T T T T T T 1. T T T

We set
if i = j
if (i,j) E E
otherwise.

The element 0 in position ij of A* means that there is an even-length path

between i and j; 1 means there is an odd-length path; T means there are
HOMEWORK 9 SOLUTIONS 263

both (then the graph is not bipartite); and 1- means i and j are in different
connected components.
Here is a method due to Shiloach and Vishkin [93] that is much more
efficient in its use of processors. First, find a spanning tree of G. This can
be done in O(logn) time using O(n + m) processors on a CRCW PRAM.
Assign a parity 0 or 1 to each vertex according to its distance from the
root; this too can be done using O(n + m) processors in parallel, using
the technique of pointer doubling (see Miscellaneous Exercise 25). Finally,
check every edge of G to make sure that an edge does not join two vertices
of the same color.
3. (a) The system is described by the following matrix-vector equation, il-
lustrated here for the case k = 5.
0 1 0 0 0 0 Xn-5 Xn -4
0 0 1 0 0 0 Xn -4 Xn -3
0 0 0 1 0 0 Xn-3 Xn -2
0 0 0 0 1 0 Xn-2
= Xn-l
(10)
a5 a4 a3 a2 al 1 Xn-l Xn
0 0 0 0 0 1 C C

Xo Co
Xl CI
X2 C2
(11)
X3 C3
X4 C4
C C

Raising the (k + 1) x (k + 1) matrix on the left hand side of (10) to

the nth power and using (11), we obtain
n
0 1 0 0 0 0 Co Xn
0 0 1 0 0 0 CI Xn+l
0 0 0 1 0 0 C2 Xn+2
0 0 0 0 1 0 C3 Xn+3
a5 a4 a3 a2 al 1 C4 Xn+4
0 0 0 0 0 1 C C

It therefore suffices to compute the nth power of the matrix in (10).

Represent this matrix as the sum C + U, where
0 1 0 0 0 0
0 0 1 0 0 0
0 0 0 1 0 0
C
0 0 0 0 1 0
a5 a4 a3 a2 al 0
0 0 0 0 0 1
 Note that UC = U and U 2 = 0; from this it follows that
(C + u)m em + Cm-1U +Cm- 2 U + ... + CU + U
Cm+Dm' (12)
where
m-l
Dm = O~: Ci)U .
i=O

The matrix C is a block diagonal matrix consisting of a k x k compan-

ion matrix in the upper left and a 1 x 1 identity matrix in the lower
right, thus Miscellaneous Exercise 22 applies.
Given cm and Dm, we can obtain C 2m, cm+!, D 2m , and Dm+! in time
O(k2). For the first two we use Miscellaneous Exercise 22. For the
last two, we have

The product C mDm is essentially a matrix-vector product, since all

columns of Dm except the last are zero.
Thus we can compute Dn and C n with at most log n matrix operations,
each taking time O(k2) (the sequence of operations is determined by
the binary representation of n). The desired power (C + u)n is given
by (12).
For a different approach to this problem, see [109, 86, 45].
(b) With O(kOt) processors, we can multiply two (k+ 1) x (k+ 1) matrices
in time o (log k) using a parallel version of Strassen's matrix multi-
plication algorithm. Thus the nth power of the matrix in (10) can be
computed in time o (log k log n) by repeated squaring.
Here is how we parallelize Strassen's algorithm. Recall that Strassen
multiplies 2 x 2 matrices as follows:
HOMEWORK 9 SOLUTIONS 265

where

81 (b-d)·(g+h)
82 (a + d) . (e + h)
83 (a - c) . (e + f)
84 h·(a+b)
85 a· (f - h)
86 d·(g-e)
87 e· (c + d) .
We can first compute the quantities b - d, g + h, a + d, e + h, a - c,
e + f, a + b, f - h, g - e, and c + d in parallel, then compute 81, ... , 87
in parallel from these, and finally the four entries of the product from
the 8i in parallel.
Now we apply this technique inductively. Given a pair of k x k ma-
trices, we wish to build an NC circuit to compute their product. We
break each matrix up into four submatrices of size roughly ~ x ~, and
assuming that we have already constructed circuits to compute the
sum and product of ~ x ~ matrices, we can use those circuits in the
calculation of the k x k product exactly as in the 2 x 2 case described
above.
Let P(k) and T(k) be, respectively, the number of processors (size
of the circuit) and the time (depth of the circuit) necessary to to
multiply two k x k matrices by this method. These quantities satisfy
the recurrences

P(k) 7P(~) + 0(k2)

k
T(k) T("2) + 0(1)
since we need 0(k2) processors and 0(1) time to add two k x k ma-
trices. These recurrences give
P(k) 0(k1og7 ) = 0(k 2 .8 1...)
T(k) O(logk) .

For more details, see [44].

(c) Let y be an indeterminate and consider the generating function
00

x(y) = LXiyi
i=O

where the Xi are the solution to the recurrence. Multiplying x(y) by

yi shifts the coefficients i positions; using this trick, we can encode
266 HOMEWORK 9 SOLUTIONS

the linear recurrence as a single equation involving shifts of x(y) as

follows. Let

p(y) al + a2Y + a3y2 + ... + akyk-l

q(y) eo + ClY + ~y2 + ... + Ck_lyk-l
r(y) = (p(y) - akyk-l)(q(y) - Ck_lyk-l) mod yk .

(The coefficients of r(y) can be computed in time O(log k) with 2k

processors using FFT.) Then

x(y) = alY(x(y) - (eo + ClY + ... + Ck_2yk-2))

+ a2y2(X(Y) - (eo + ClY + ... + Ck_3yk-3))
+ a3y3(X(Y) - (eo + ClY + ... + Ck_4yk-4))
+ ...
+ ak_lyk-l(x(y) - eo)
+ akykx(y)
+ cyk(1 + y + y2 + ... )
+ eo + ClY + c2y2 + ... + Ck_lyk-l
cyk
yp(y)x(y) - r(y) + -1- + q(y) ,
-y
therefore
(q(y) _ r(y))(1 _ y) + cyk
x(y)
(1 - y)(1 - yp(y))
u(y)
(13)
1- yv(y)
where

u(y) = (q(y) - r(y))(1 - y) + cyk

v(y) = 1 + p(y) - yp(y) .
Expanding the denominator of (13) in an infinite series, we get
00

x(y) = u(y) Lyiv(y)i ,

i=O

and since we are only interested in computing the first n terms, we

might as well truncate the series and compute instead
n-l
x(y) = u(y) L yiV(y)i (14)
i=O
u(y)(1 _ynv(y)n)
(15)
1- yv(y)
HOMEWORK 9 SOLUTIONS 267

We take Fourier transforms and use componentwise operations. In

particular, to get the transform of ynv(y)n, we raise the transform of
yv(y) to the nth power componentwise, and to get the transform of
Ef~Ol yiV(y)i, we divide the transform of 1 - ynv(y)n by the transform
of 1 - yv(y) componentwise. There is one glitch: suppose that at
a root of unity wJ, we find that wiv(wi ) = 1, so that we cannot do
the division in (15) at the lh component. In that case, we use (14)
instead, observing that
n-l
:E wiiv(wi)i = n.
i=O

We need tvth roots of unity and a multiplicative inverse of N, where

N exceeds the degrees of all polynomials involved, so that there will
be no wrap; since u(y) and v(y) are each of degree at most k, the
numerator of (15) is of degree at most kn+k+n, thus N > kn+k+n
suffices.
268 HOMEWORK 10 SOLUTIONS

Homework 10 Solutions
1. (a) As shown in Lecture 36, the expected value of the random variable
£(Xn+l I Sn) is

This yields the recurrence

£SO 0
£Sn+l £(Sn + Xn+l)
£Sn +£Xn+1
£Sn + £(£(Xn+l I Sn))
> £Sn + £(E(m - Sn))
Em + (1 - E)£Sn
whose solution gives

£Sn > m(l - (1 - Et) .

(b)
m
£Sn Li· Pr(Sn = i)
i=O
m-l
m· Pr(Sn = m) + L i . Pr(Sn = i)
i=O
m-l
:'5 m· Pr(Sn = m) + L (m - 1) . Pr(Sn = i)
i=O
m· Pr(Sn = m) + (m - 1) . (1 - Pr(Sn = m))
m -1 + Pr(Sn = m) .
Combining this inequality with (a), we obtain

Pr(Sn = m) ;::: 1 - m(l - Et .

(c) Using (b),

1· Pr(Sn < m) + O· Pr(Sn = m)

1- Pr(Sn = m)
< m(l- Et .
Also, by definition of f,
HOMEWORK 10 SOLUTIONS 269

Then for any l,

L £f(Sn)
00

£R
n=O
i-I
L 1 + L m(l -
00

< E)n
n=O n=i

L (l- Et
00

l+m(l-E)i
n=O
m i
l+ -(1- E) .
10

Taking

m - log 1
rlOg
-log(l - E)
10

gives the desired bound.

2. Let au = IAul. It will suffice to show that for any subset B of Zp of size
k '5: d,

Pr( 1\ Xo + XIU + X2U2 + ... + Xd_lUd - 1 E Au) = II au .

uEB uEB P
But
d-l
Pr( 1\ L Xi Ui E Au)
uEBi=O
1 d-l .
..,d
IF
I{(xo, ... , Xd-l) I 1\ L
uEBi=O
Xi U ' E Au}1
1 d-l .
..,d L I{(xo, ... , Xd-l) I 1\ L Xi U ' = zu}1 .
l ' ZuEAu, uEB uEB .=0

Consider the k x d linear system

Xo + XIU + X2u2 + ... + Xd_lUd-1

This can be represented in matrix form as

Ax = z
where A is a k x d submatrix of a d x d Vandermonde consisting of all rows
(1 , u, 2
U, •.. , U
d-l)
, uEB.

Since the Vandermonde is nonsingular, A is of full rank k. Its kernel is

therefore a subspace of Z; of dimension d - k, thus the affine subspace of
270 HOMEWORK 10 SOLUTIONS

solutions to Ax = z also has dimension d - k. In Zp, any such subspace

has pd-k elements. Thus
1 d-l .
...d E I{(xo, ... ,Xd-l) I 1\ ~ Xi U ' = zu}1
l' z"EA.. , uEB uEB .=0
1 ~ d-k
- ~ P
pi zuEA.. , uEB

E
pd-k
1
pel zuEAu1 uEB

1
kIIau .
p uEB

3. The solution to this problem is very similar to the analysis of Luby's algo-
rithm given in class. Recall from there that a vertex is good if
1 1
E -
UEN(v) d(u)
>-.
- 3

Lemma A For all good v, Pr(v E U) ;::: ~.

Proof If v has a neighbor u of degree 2 or less, then

Pr(v E U) > Pr(v = t(u))

1
> 2'
Otherwise d(u) ~ 3 for all u E N(v), and as in the analysis of Luby's
algorithm, there must exist a subset M(v) ~ N(v) such that

~< E_l_<~
3 - UEM(v) d(u) - 3

Then

Pr(v E U)
> Pr(3u E M(v) v = t(u))
> E
Pr(v = t(u)) - E Pr(v = t(u) 1\ v = t(w))
UEM(v) u,w E M(v)
U~W

(by inclusion-exclusion)
> E Pr(v = t(u)) - E Pr(v = t(u)) . Pr(v = t(w))
UEM(v) u,w E M(v)
U~W
HOMEWORK 10 SOLUTIONS 271

(by pairwise independence)

111
;::: UE~V) d(u) - U'W~(V)
d(u) . d(w)
(L _1 ). (1 - L _1_)
uEM(v) d(u) wEM(v) d(w)
1 1 1
> -. - -
3 3 9
D

Lemma B For all v, Pr(v is matched I v E U) ;::: ~.

Proof There are several cases, depending on the number of H -neighbors of

v and the number of H-neighbors of each H-neighbor of v. The situation
minimizing the likelihood of v being matched is

• u• v• w• •

There are eight possibilities for the choices of favorites of u, v, w, all equally
likely. Of these, four give matchings for v. Thus
1
Pr(v is matched I v E U) ;::: "2'
D

Combining Lemmas A and B, the probability that any particular good

vertex is matched is at least fs.
The remainder of the argument is exactly
like the analysis of Luby's algorithm given in class.
Note that the proof of Lemma A required only pairwise independence and
the proof of Lemma B required only 3-wise independence, thus using Ex-
ercise 2 the algorithm can be made deterministic.
272 SOLUTIONS TO MISCELLANEOUS EXERCISES

Solutions to Miscellaneous Exercises

1. The set Imax is closed under subset, so axiom (i) of matroids is satisfied.
To show (ii), let I, J E Imax such that III < IJI; we wish to find x E J - I
such that {x} U I E Imax.
Let i and J be elements of M extending I and J, respectively. Consider
the set

E = (J U (8 - J)) - I .

The cardinality of E is greater than that of 8 - J. By Exercise 1a of

Homework 1, E is dependent in the dual, therefore contains a cut C. Now
C must intersect every maximal independent set including J, so it must
contain an element of J - I. Let x be such an element of minimal weight.
We argue now that for any element y E C - J, the weight of y is at least as
great as that of some element of C n J. This will say that x is of minimal
weight in C, which will allow us to apply the blue rule. Let D be the
fundamental cycle of y and J. By Lemma 3.7, C n D contains an element
z of J, and by Lemma 3.8, the colors of y and z can be exchanged in the
coloring J, 8 - J to obtain an acceptable coloring. But the weight of z
cannot exceed that of y, otherwise J was not of minimal weight.
At this point we have given a cut C disjoint from I such that CnJ contains
an element x of minimal weight among all elements of C. If we color I blue,
then we can apply the blue rule with x and C. Since I ~ i EM, it follows
from Lemma 3.9 that IU {x} is also contained in an element of M, therefore
I U {x} E Imax.

2. Determine for each e E E the sizes of the two connected components ob-
tained by deleting e. This can be done in linear time by depth-first search,
computing the values recursively. Orient the edge e in the direction of the
smaller component. The resulting directed graph is a directed tree, since
no vertex has indegree greater than 1: if (8, u) and (t, u) were both oriented
toward u, and if 181, ITI, and lUI were the subtrees pictured,

then

181 > ITI + lUI

ITI > 181 + lUI
SOLUTIONS TO MISCELLANEOUS EXERCISES 273

from which it would follow that lUI = 0, a contradiction.

Since we have a directed tree, there is a unique root r. The desired edge
is the one from r to its largest subtree. To see this, let A, B, and C be the
maximal proper subtrees of r, and let A be the one of maximum size. By
the orientation of the edge from r to A,
2n+ 1
IAI <- ?:!:.
2 <
- 3
Now IBI :::; IAI and ICI :::; IAI, therefore IBI + ICI :::; 21AI and

n-l IAI + IBI + ICI

> IBI + ICI + IBI + ICI
2
3UBI + ICI)
2
It follows that
2n+ 1
IBI+ICI+l :::; -3-'

3. There are several reasonable approaches to this problem. Here is one in-
volving Kleene algebra. Consider the structure

K = (RU{oo,-oo}, min, +, *, 00, 0)

where we extend the usual + on R to R U {oo, -oo} by

oo+a a+ 00 = 00, a E R U { 00, -00 }

-oo+a a + (-(0) = -00, a E R U { -00 }

and define * by
a* = {O,-00,
~f a ~
If
0,
a < O.

A routine check of the axioms verifies that this structure is a Kleene algebra.
Let G be a directed graph with n vertices and real edge weights w, possibly
negative. Form the n x n matrix A with Auv = w(u, v). If there is no edge
(u, v), set Auv = 00. As shown in Lecture 7, the family ofnxn matrices over
K is again a Kleene algebra, and we can calculate A * in time proportional
to the time needed to multiply two n x n matrices over K.
We claim that A~v is the weight of the minimum-weight path from u to v,
or -00 if there exists a path from u to v but no path is of minimum weight.
As with the min, + algebra discussed in Example 6.6, it can be argued by
274 SOLUTIONS TO MISCELLANEOUS EXERCISES

induction that A:v gives the weight of the minimum-weight path of length
k from u to v. Since A * = infk A k, if there exists a minimum-weight path
from u to v, and that path is of length k, then A:v = A:v.
It remains to argue that if there exists a path from u to v but no minimum-
weight path, then the weights of paths between u and v are unbounded be-
low, so that A:v = -00. This argument is necessary, since it is conceivable
that the weights of the paths from u to v approach some real lower limit
without ever achieving it. We show that this cannot happen: if there is a
path from u to v but no minimum-weight path, then there is a path from
u to v that traverses some cycle of strictly negative weight, which can be
traversed arbitrarily many times.
Under our assumption, there exists an infinite sequence Po, PI. ... of paths
from u ~to v such that Pi is a shortest (in terms of number of edges) path
of weight strictly less than that of PO,Pl, ... ,Pi-l. The number of edges in
these paths is unbounded, since for each k there are only finitely many paths
with k edges. Let Pi be the first path in the list with at least n edges; then
some vertex x must be repeated on Pi. The cycle that is traversed between
the two occurrences of x on Pi must be of strictly negative weight, otherwise
that cycle could be cut out of Pi to give a path of fewer edges and weight
strictly less than that of Po, Pl, ... ,Pi-l, contradicting the minimality of Pi.
Another approach to this problem is to identify the vertices contained in
negative-weight cycles and treat them separately. The solution to Miscella-
neous Exercise 17(a) would presumably be useful in this regard. See [100]
for more details about this approach.
4. (a) Call a schedule for a set of jobs A safe if no deadlines are violated. If
A has a safe schedule, then so does any subset: simply delete the jobs
not in the subset.
Let A and B be two independent sets with IAI < IBI. Consider sep-
arate safe schedules for A and B. Assume without loss of generality
that jobs are scheduled as early as possible with no gaps in the sched-
ules. Let j be the job occurring latest in the schedule for B that is
not in A. Let C be the set of jobs occurring after j in the schedule for
B. Then C ~ A. Consider the following schedule for AU {j}: first
schedule all the jobs in A - C in the same order as in the schedule
for A, then schedule j, then schedule C in the same order as in the
schedule for B. This schedule is safe, since all elements of A - Care
scheduled no later than they were in A, and all elements in {j} U C
are scheduled no later than they were in B.
(b) We use the greedy algorithm with the jobs sorted by penalty in de-
creasing order. The greedy algorithm produces a maximal indepen-
dent set of maximum weight; these jobs can be scheduled safely. The
remaining jobs are all scheduled after their deadlines and incur a
SOLUTIONS TO MISCELLANEOUS EXERCISES 275

penalty, but this penalty is a minimum. Since all maximal inde-

pendent sets are of the same cardinality, we can do no better than
this.
The sorting phase takes 0 (n log n) in general, or linear time if the
penalties are small enough that bucket or radix sort can be used. The
remainder of the algorithm can be implemented in time O(na(n)),
where a(n) is the inverse of Ackermann's function, as follows.
Suppose that we are at some intermediate stage of the algorithm and
have selected an independent set of jobs A. For dEN, define

J.LA(d) = the maximum number of jobs with

deadline d that could be added to A
without sacrificing independence.
For example, J.L0(d) = d. Then for any A,

o (16)
J.LA(d + 1) (17)
< J.LA(d) + 1 . (18)

The inequality (17) holds because if k jobs with deadline d can be

safely added to A, then k jobs with any later deadline can be safely
added to A. The inequality (18) holds because in any safe schedule
for A and k additional jobs of deadline d + 1, k - 1 of the additional
jobs must finish before time d, thus there is a safe schedule for A and
k - 1 additional jobs of deadline d.
Properties (16), (17), and (18) say that the disjoint sets

J.L7/(k) = {d I J.LA(d) = k}
are intervals (contiguous sequences of natural numbers), and if the set
J.L7/(k) is nonempty, then J.Li(i) is nonempty for any 0:::; i :::; k.
We will use the union-find data structure to maintain the disjoint sets
J.LA1(k). Consider a new job j ¢ A with deadline dj • Then Au {j}
is independent iff J.LA(dj ) > 0 iff dj ¢ J.LA1(O). Also, if Au {j} is
independent, then

thus

k < J.LA(dj )-1

k> J.LA(dj )
otherwise.
276 SOLUTIONS TO MISCELLANEOUS EXERCISES

The sets J.lj/(k) will be linked in a list f in order of increasing k.

Initially, J.l7/(k) = {k}, 0 ~ k ~ n. To test for independence of
Au {j}, where A is independent, we ask whether the set find (dj ) has
a predecessor on the list f. If not, J.lA(dj ) = J.lA(O) = 0 so AU {j} is
not independent. To insert the element j, we form the union of the
set find (dj ) and its predecessor on the list f.
5. The problem is in coNP, since its complement is in NP: we can guess a
string of length n and check in polynomial time that it is not covered by
any of the patterns.
The problem is also hard for coNP, as the following reduction from (the
complement of) CNFSat shows. Suppose we have a CNF formula B with
n Boolean variables Xl, ... , X n • Convert each clause c to a pattern O'c of
length n as follows:
• if Xi does not appear in c, put * in position i of O'c.
• if Xi appears positively in c, put a 0 in position i of O'c.
• if Xi appears negatively in c, put a 1 in position i of O'c.
A string of length n over {O, l} represents a truth assignment to the vari-
ables Xl, ... , Xn by assigning true to Xi if 1 appears in position i in the
string, false if 0 appears in position i. Then O'c covers exactly those strings
corresponding to truth assignments that do not satisfy c. Therefore every
string is covered by some O'c iff every truth assignment falsifies some clause,
i. e. iff B is unsatisfiable.

6. The problem is in NP, because we can guess a folding and compute its
length in polynomial time. To show NP-hardness, we reduce the partition
problem to it. Given an instance of the partition problem consisting of
the weight function w : {l, 2, ... , n} ~ N, construct a ruler with n + 4
segments of length (in order)
N N
N, 2' w(l), w(2), ... , w(n), 2' N

where N is very large (actually N ;::: Ei=l w(i) suffices), and let k = N.
In order to fit, the endpoints of the two end segments of length N must
line up vertically, and the two segments next to them of length ~ must be
folded back in. Thus we will get a fit if and only if the remainder of the
ruler can be folded so that the inner endpoints of the ~ segments line up
vertically.
0
: ooJ :
0
•

N
.
SOLUTIONS TO MISCELLANEOUS EXERCISES 277

This can occur if and only if there exists a subset S C {l, 2, ... ,n} such
that

Lw(i) = LW(i);
iES i~S

the sets S and {I, 2, ... ,n} - S correspond to the segments in the ruler
pointing left and right, respectively.

7. Given a Boolean formula in CNF, perform the following operation on long

clauses until every clause has at most three literals. First replace the clause

(19)

with

(20)

where y is a new variable. The two formulas are equisatisfiable, and the
number of satisfying truth assignments is the same, because the truth as-
signment to y is forced by the truth assignment to Xl and X2. The rightmost
clause of (20) has one fewer literal than (19).
Next, replace the new clause

with the equivalent formula

This procedure gives a formula with at most three literals per clause.
It is possible to get exactly three distinct literals per clause as follows. Let
X, y, and z be three new variables. Replace each deficient clause (u V v)
with (u V v V x) and each deficient clause (u) with (u V x V y), and add
the clauses (x), (y) and (z). The number of satisfying assignments is the
same, since the new variables have to be true in any satisfying assignment.
All clauses have exactly three literals except the three new ones. It now
suffices to show how to express the conjunction X y z in 3CNF. But

~~y~ - xy~VxyzVxy~VxyzVxy~VxyzVxy~,

and a 3CNF representation of X y z can be obtained by negating the right

hand side and applying DeMorgan's law.

8. In the new representation, there will be a doubly linked list V of vertices.

By "Given u, ... " we will mean, "Given a pointer to the list element for
vertex u on the list V, ... " Each vertex u will point to a circular linked
278 SOLUTIONS TO MISCELLANEOUS EXERCISES

list adj(u) of edges e such that t(e) = u. By "Given e, ... " we will mean,
"Given the list element for e on the list adj(t(e)), ... " The order on the
circular list adj(u) will give the order (). The edge e will point to ()(e),
t(e) and e; that is to say, the list element for e on adj(t(e)) will contain
pointers to the list element for () (e) on adj (t ( e)), the list element for t ( e )
on V, and the list element for e on adj(t(e)) = adj(h(e)).
Given e, in constant time we can compute ()(e), e or t(e) by following a
single pointer; and we can compute h( e) by following a pointer to e and
then following the pointer there to t(e) = h(e). We can delete a given
edge e in constant time by unlinking its list element from adj(t(e)) and
unlinking the list element of e from adj (h( e)). We can delete a vertex u by
first deleting all the edges on adj (u) as above and then unlinking u from
V.
We now show how to obtain the new representation from the old one in
linear time. The old representation consists essentially of the list V, for
each u on V a pointer to an adjacency list adj(u) containing all edges e
with t(e) = u, and for each e on adj(t(e)) a pointer to h(e) on V. To
calculate the pointers from e to t(e) in linear time, for each u scan the list
adj (u) and append to each list element a pointer back to u.
It remains to calculate the pointers from e to e. First produce for each
vertex u an auxiliary adjacency list aux(u) with a list element for each e
with t(e) = u and a pointer to e. The lists aux(u) will contain the desired
pointers but will not be in the correct order. The lists aux(u) are produced
in linear time by initializing all aux(u) to the empty list, then scanning
through all the lists adj (u) and for each e encountered appending a pointer
to e to the front of the list aux(h( e)).
At this point each u points to two lists, adj(u) and aux(u), each with one
entry for each edge e with t(e) = u. The former list is in the correct order
() and the latter contains the - pointers. We wish to consolidate them into
a single list with both properties. For each u, execute the following two
steps:

(a) Scan the list aux(u). For each e on the list, save the pointer to e in
the list element for h(e) on V. The pointer to h(e) is available as t(e).
(b) Scan the list adj(u). For each e on the list, pick up the pointer to e
from the list element for h(e) on V.

This procedure takes linear time, since each vertex and edge is visited a
constant number of times.

9. Since - and () can be computed in constant time, the permutation ()* = ()o-
can be computed in constant time. Construct a doubly linked list L of
pointers to the list elements of all (directed) edges in the adjacency list
SOLUTIONS TO MISCELLANEOUS EXERCISES 279

representation of G. While constructing L, store with each list element in G

corresponding to an edge e a pointer to the list element in L corresponding
to e. Repeat the following loop until L is empty. Let e be an arbitrary
edge on L. Starting from e, successively compute ()*, deleting each edge
in succession from L and inserting it on a circular list C. Stop when we
get back to e. Then C contains all edges in the cycle of ()* containing e.
Create a new vertex u in V*, set t*(e) = u for each edge e in C, and make
C the adjacency list of u. When L is empty, set h*(e) = t*(e) for each
edge e. The pointers giving - are available from G.

10. As in Lecture 14, let nand n* be the number of vertices and faces of
G, respectively; let m = IEI/2, the number of undirected edges; let c
be the number of connected components (orbits of E under the subgroup
generated by () and -); and let ()* = () 0 - . Note that the subgroup
generated by () and - is the same as the subgroup generated by () and ()*,
since - = (}-l 0 ()*.
Write () as a product of disjoint cycles. Multiplying () on the left by an
involution (a b) acts on () as follows: if a and b are in different cycles of
(), then those two cycles are merged, and if a and b are in the same cycle,
then that cycle is split. All cycles of () not containing a or b are left intact.
For example,

(1 5) 0 (1 2 3 4) 0 (5 6 7 8) (1 2 3 4 5 6 7 8)
(1 5) 0 (1 2 3 4 5 6 7 8) (1 2 3 4) 0 (5 6 7 8) .

Here (ao al ... an-l) is the permutation that maps ai to a(i+1)modn' 0 :::;
i < n, and fixes all other elements of E.
Let ()' = (a b) 0 (). In terms of the graphs

G (E, (), -)
G' (E, ()', -) ,

if the edges a and b have a common tail in G (i. e., if a and b are in the
same cycle of ()), then that tail is split into two vertices in G' as shown.

If a and b have different tails (i. e., if a and b are contained in different
cycles of ()), then the tails are merged in G'.
280 SOLUTIONS TO MISCELLANEOUS EXERCISES

Note that

(0')* = (0*)' = (a b) 00* ,

so that these comments apply to the duals G* and 0'* as well.

Write 0 as a product of disjoint cycles

o = 00 0 01 0 ••• OOp_l •

Each Oi can be expressed as a product of 10il - 1 transpositions:

Thus 0 can be expressed as a product of

p-l
L:(IOil - 1) = 2m - p
i=O

transpositions. Let O'i denote the product of the rightmost i transpositions

in this list, and let Gi be the graph (E, O'i, -). Then 0'0 is the identity,
which has 2m singleton cycles, and 0'2m-p = 0, which has p cycles, so
multiplication by the ith transposition taking O'i to O'i+l must combine two
cycles into one. Thus Gi+l has one fewer vertex than Gi ; i.e., n decreases
by one in each step.
Let the ith transposition be (a b). Either

(i) a and b belong to different connected components of G i ;

(ii) a and b belong to the same component but different cycles of 0';; or
(iii) a and b belong to the same cycle of 0'7-

In case (i), a and b belong to different cycles of 0';, so c and n* each

decrease by one and X(Gi+l) = X(G i ). In case (ii), n* decreases by one
and c remains the same, in which case X(Gi+l) = X(G i ) + 2. In case (iii),
a and b belong to the same component of Gi and n* increases by one. In
this case, we claim that c remains the same, thus X(Gi+l) = X(Gi ). To see
that c does not increase, it suffices to show that for any dEE there exists
an ", in the subgroup generated by O'i+1 and - such that ",(d) = O'i(d); thus
each orbit of the subgroup generated by O'i and - is contained in an orbit
of the subgroup generated by O'i+l and - .
SOLUTIONS TO MISCELLANEOUS EXERCISES 281

If O'i(d) f/. {a,b}, then

(a b) oO'i(d)
O'i(d) ,

so in this case we can take 1/ = O'i+1. Suppose now that O'i(d) = aj the case
O'i(d) = b is symmetric. Since a and b are in the same cycle of O'i+l, there
exists a k such that O'f+1(b) = a. Let 1/ = O'f-tr Then

1/( d) O'f+1 (O'i+l (d))

O'f+1 ((a b) (O'i(d)))
0'~t-1 (b)
= a

The reverse inclusion, which implies that c does not decrease, follows from
a dual argument. (It is the dual argument that uses assumption (iii).)

11. We prove the harder direction (-+) j the direction (+-) follows from a
straightforward induction on the number of faces.
Let O'i and G i be as in the solution to Miscellaneous Exercise 10. In that
solution it was argued that x( Gi+l) ;::: X( Gi ) ;::: 0 for all i. Since G2m - p = G
and X( G) = 0, we have X( Gi ) = 0 for all i.
We proceed by induction on i. For the basis, 0'0 is the identity map and
Go is the graph consisting of m connected components, each consisting of
two vertices and an undirected edge. This certainly has a plane embedding
consistent with 0'0.
Now suppose G i has a plane embedding consistent with O'i. Let (a b) be
the ith transposition, so that O'i+1 = (a b) OO'i. The tails of a and b in G i
are merged in Gi +1. Either

(i) a and b lie in the same face of G i , or

(ii) a and b lie in different faces of G i .

In case (i), the tails of a and b can be merged across the common face
of a and b. It is easily checked that the resulting embedding of Gi+l is
consistent with O'i+1.
In case (ii), both n and n* decrease by one in passing from G i to Gi+l> so
c must also decrease by one to maintain X(Gi+l) = o. Thus a and b are
in different connected components of Gi . By embedding on the sphere and
changing the position of the North Pole, we can arrange the embedding of
Gi so that a and b occur on the outer faces of their components, then merge
the tails of a and b to obtain a plane embedding consistent with O'i+l.
 282 SOLUTIONS TO MISCELLANEOUS EXERCISES

12. Instead of maximal cliques, take the complement graph and consider the
maximal independent sets. Given a Boolean formula, construct a graph
with a black vertex for each literal and a red vertex for each clause. Con-
nect complementary literals and connect each clause to the literals it con-
tains. Any maximal independent set M containing no red vertex contains
exactly one of each pair of complementary literals and thus gives a truth
assignment; moreover, it is a satisfying assignment, since every red ver-
tex is connected to a vertex in M (otherwise M would not be maximal).
Conversely, any satisfying assignment gives a black maximal independent
set.

13. Given a partition problem (S, w), where S is the set of items, n = lSI, and
W : S - t Z the weight function, let f be an upper bound on the absolute
values of weights of elements of S. Then for any subset R ~ S,

Iw(R)1 = L Iw(a)1 :::; flRI·

aER

Thus, although there are 21RI subsets of R, there are only 2iIRI + 1 weights
these subsets can take on.
The following algorithm is quite reasonable if f is sufficiently small. We
calculate recursively the set of all possible weights of subsets of R ~ S.
If R = {a}, the possible weights are 0 and w(a). If IRI ~ 2, partition R
into two disjoint sets Rl, R2 of roughly equal size and recursively produce
the data for RI and R2 . For each pair of weights WI and W2 in the sets
computed for RI and R 2 , respectively, calculate WI + W2 and record it in
the set for R. Since WI is the weight of some subset of RI and W2 is the
weight of some subset of R 2 , WI + W2 is the weight of their union, which is
a subset of R; moreover, every subset of R is obtained as such a union.
Since the weights of subsets of ~ lie between -fl~1 and fl~l, the calcula-
tion of all the weights WI + W2 requires at most O( fIRII· flR 2 1) operations.
This gives rise to the recurrence

with solution

Thus for partition problems with f = fen) a polynomial in n, T(n) is also

a polynomial in n.

14. Try k = 2 [log nl , the smallest power of 2 greater than or equal to n. Re-
call that in the representation over Z2[X]/Xn , the binary-to-Gray operation
amounts to multiplication by x + 1. We wish to show that (x + l)k = 1
SOLUTIONS TO MISCELLANEOUS EXERCISES 283

and for all 0 $; f < k, (x+ 1)l =f 1; in other words, the order of x+ 1 in the
group of invertible elements of Z2[X]/X n is k. This will suffice to prove our
result, since for any p, applying the binary-to-Gray operation k times gives
(x + 1)kp = p, and for any 0 < f < k, (x + 1)l(x + 1)k-l = 1 =f (x + 1)k-l.
To show that (x + 1)k = 1, note that in Z2[Xl/X n , squaring is a linear
operation:

since 2 = 0 (mod 2). Thus

(x + 1?r10gn l
(... ((x + 1)2)2 ... ?
x2rlOgnl + 1
1,
since 2rlognl 2: n and therefore x2POgnl = 0 mod xn. To show that no
smaller power works, we use the fact that the order of x + 1 must divide
k, therefore it must be a power of 2. But for m < flog n1 we have 2m < n,
therefore

15. (a) Consider the weighted 4-node widget A we used in Lecture 27 with
the following adjacency matrix:

01
[o~1 -1
~
0
-1
o
o
12 0
1
0
The input nodes of the widget are 1 and 3 and the output nodes are 2
and 4. Note that A34 = 1 and everything else in the row and column
containing A34 is O. This says that every cycle cover of nonzero weight
must contain the edge from 3 to 4 of weight 1. We might just as well
collapse 3 and 4 into one node. The resulting widget is

Tl
11
[ 1 1
(21)
2 2
1 -1

with input nodes 1 and 3 and output nodes 2 and 3. The desired be-
havior is summarized by the following equations, analogous to those
presented in the lecture for the four-node widget. As before, A(i;j)
 284 SOLUTIONS TO MISCELLANEOUS EXERCISES

denotes the submatrix of A obtained by deleting row(s) i and col-

umn(s) j.
perm A(3j 3) = perm A(2j 1) = perm A(2, 3j 1,3) = 1
perm A(3j 1) = perm A(2j 3) = perm A = 0 .
A quick calculation shows that all these properties are satisfied by
(21).
(b) To be used in this construction, any widget must have two distinct
input vertices and two distinct output vertices, because there are good
cycle covers containing two input edges and two output edges. Thus
in any two-node widget, both nodes are input nodes and both are
output nodes. The relevant equations are then
perm A(lj 1) = perm A(2j 2) = perm A(l, 2j 1,2) = 1
perm A(2j 1) = perm A(lj 2) = perm A = 0 .
The first line implies that Au = A22 = 1. The first two equations
of the second line imply that A12 = A21 = O. Thus A must be the
identity matrix. But then perm A = 1, so the last equation is violated.
16. (a) We first apply depth- or breadth-first search to determine whether the
graph is 2-colorable (say with cyan and magenta) and find the con-
nected components. If it is not 2-colorable, then no schedule exists.
If it is, then we must decide for each connected component whether
to schedule the cyan vertices of that component at time 0 and the
magenta vertices at time 1 or vice versa so that there are at most m
vertices in all scheduled at anyone time. This is a partition prob-
lem with small weights and can be solved in polynomial time by the
method of Miscellaneous Exercise 13.
(b) The problem is equivalent to the following graph coloring problem:
given an undirected graph, can the vertices be colored with t col-
ors so that no two adjacent vertices receive the same color and each
monochromatic set is of cardinality at most m? The ordinary k-
colorability problem discussed in Lecture 21 reduces to this problem
trivially by taking m = n. Therefore the problem is NP-hard. It
is also easily seen to be in NP, since a solution can be guessed and
verified in polynomial time.
17. (a) The problem of detecting negative cycles is made easier by the follow-
ing lemma.

Lemma A vertex u is contained in a negative-weight cycle iff some

vertex in the strong component of u is contained in a simple negative-
weight cycle.
 SOLUTIONS TO MISCELLANEOUS EXERCISES 285

Proof.
(-+) If the negative-weight cycle containing u is simple, we are done.
Otherwise there is a repeated vertex x on the cycle, and x is in the
strong component of u. The cycle can be decomposed into two strictly
smaller cycles containing x, at least one of which must have negative
weight. By induction, there is a simple negative-weight cycle contain-
ing an element of the strong component of x, which is also the strong
component of u.
(-) Let x be a vertex in the strong component of u contained in a
simple negative-weight cycle. Combining the cycle through u and x
with sufficiently many trips around the negative-weight cycle through
x, we obtain a negative-weight cycle through u. 0

Every simple cycle of negative weight is of length at most n. Thus we

can test for the existence of such a cycle by testing for the existence
of any negative-weight cycle of length at most n. We can do this
in polynomial time by examining the diagonal elements of (1 + c)n,
where C is the weighted adjacency matrix and 1 is the identity matrix
over the min,+ Kleene algebra.
(b) The problem is in NP, since we can guess a simple path and verify
that it has negative weight in polynomial time.
To show NP-hardness, we reduce the Hamiltonian circuit problem to
this problem. Given a graph G = (V, E) with IVI = n, pick a vertex
u and split it into two vertices v, t with no edge between. Each of
v, t is connected to the other vertices of G in the same way u was.
Let s be a new vertex and add an edge of weight n - 1 from s to v.
Weight the remaining edges -1. The new graph has n + 2 vertices.
Any path from s to t must begin with the edge from s to v of weight
n - 1, therefore must traverse at least n other edges in order to be of
negative weight. In order to be simple, it can traverse at most n other
edges. Thus a simple negative weight path from s to t is of length
exactly n + 1 and contains a simple path from v to t of length n. This
gives rise to a Hamiltonian circuit in the original graph.
18. (a) Every maximal matching M can be extended to an edge cover C by
adding an extra edge for each unmatched vertex. Each such extra
edge must connect the unmatched vertex to a matched one, otherwise
M was not maximal. Thus ICI + IMI = IVI.
Conversely, every minimal edge cover C contains a matching M by
choosing one edge from each connected component of C. Each com-
ponent of C consists of a vertex with edges radiating out from it; if a
component had more than one vertex of degree greater than one, we
could remove an edge and still have a cover. The number of compo-
nents of C is IMI, and again, ICI + IMI = IVI·
286 SOLUTIONS TO MISCELLANEOUS EXERCISES

We have shown that for every maximal M there is a C with IOI+IMI =

IVI and for every minimal C there is an M with 101 + IMI = IVI. Thus
an edge cover of minimum cardinality can be obtained by extending
a matching of maximum cardinality as described above.
(b) Find a maximum matching and take the vertex cover to be the set of
matched vertices. This is a vertex cover, since any edge not covered
could have been added to the matching. It is at most twice the size
of a minimum vertex cover, since every vertex cover must contain at
least one endpoint of each matched edge.
These algorithms can be implemented in time O(m..fii) using the algorithm
of Micali and Vazirani [80, 105].
19. As shown in Lecture 26, G has a cycle cover iff the permanent of its ad-
jacency matrix is nonzero. Let G' be a bipartite graph whose bipartite
adjacency matrix is the same as the (nonbipartite) adjacency matrix of G.
Then G has a cycle cover iff G' has a perfect matching, so we can use any
one of the fast algorithms given in class for maximum matching.
We can also go directly from an adjacency list representation of G to an
adjacency list representation of G' in linear time without constructing the
common adjacency matrix: duplicate the entire adjacency list representa-
tion of G and make the pointers in the edge lists in each copy to point to
the other copy.
20. First find a maximum matching M in time O( m..fii) using the Hopcroft and
Karp algorithm. If there is a deficient set, then Hall's Theorem says that
there is at least one free vertex x E U. Starting from x, build a Hungarian
tree of all vertices reachable from x along alternating paths. Cut each path
off when a vertex that has been seen before is encountered. Let R be the
set of vertices reachable from x in the Hungarian tree. Let D = Un R. We
will show that D is a minimal deficient set.
First we claim that every element of R besides x is matched. There are
certainly no free vertices in R n U except x, since each such vertex is first
seen immediately after traversing an edge in M. If there were a free vertex
v in R n V, then the path from v back to x would be an augmenting path,
contradicting the maximality of M. Moreover, for every matched vertex in
R, its mate is also in R. Thus IN(D)I = IDI-1 and D is deficient.
To show that D is minimal, we show that for any element y ED, there is a
matching in which all elements of D except y are matched; thus no proper
subset of D is deficient. If y = x, we can take the matching M. Otherwise,
y is matched in M. Change the status of all edges on the alternating
path from y back to x through the Hungarian tree. This unmatches y and
matches x. All other elements of D remain matched.
21. First we extend Menger's Theorem slightly.
SOLUTIONS TO MISCELLANEOUS EXERCISES 287

Lemma Let S be any set of k vertices of a connected undirected gmph

G = (V, E). The following are equivalent:

(i) G is k-connected;
(ii) any pair of vertices is connected by at least k vertex-disjoint paths;
(iii) for any vertex s E S and any vertex v E V, s and v are connected by
at least k vertex-disjoint paths.

Proof. The implication (i) ---* (ii) is given by Menger's Theorem and (ii) ---*
(iii) is trivial.
To show (iii) ---* (i), let U be any set of k -1 vertices. At least one element
s E S is not in U, and for any other vertex v not in U, by (iii) there is a
path from s to v avoiding U. Thus the removal of U does not disconnect
G. 0

We will show how to test whether a given s and t are connected by k

vertex-disjoint paths in time O(km). By the lemma, we only need to do
this for kn pairs of vertices. This gives an overall time bound of O(k 2 mn).
To test whether s and t are connected by k vertex-disjoint paths, we adapt
the max flow algorithm of Edmonds and Karp. First we replace each edge
with two directed edges, one in each direction, then give them all capacity
1. Then we split each vertex v into two vertices v' and v" with an edge
from v'to v" of capacity 1. All edges that were directed into v are directed
into v' and all edges that were directed out of v are directed out of v".

before after
The value of an integral max flow from s to t in this graph will be the
maximum number of vertex-disjoint paths from s to t. This follows from
the Max Flow-Min Cut Theorem and the splitting of vertices that prevents
more than one unit of flow to pass through any interior vertex.
However, we do not need to find a max flow, but only to check whether it
is at least k. This can be done by performing k augmenting steps of the
Edmonds-Karp algorithm, calculating new level graphs as necessary. The
time to calculate all the level graphs is at most O(km) and the time to do
all the augmenting steps is at most O(km).
 288 SOLUTIONS TO MISCELLANEOUS EXERCISES

22. Let ei be the row vector with a 1 in position i and 0 elsewhere. For
1 :5 i :5 k, the ith row of Cp is the first row of C;; that is,

eiCp = eIC;.
Then for any m ;::: 1, the ith row of C; is the first row of C;+i-l:

eipem eip
c epm - l
e I eie
p P
m- l

eI em +
p
i- l
.

For any row vector x = (Xl, ... ,Xk), xCp can be computed in time O(k):

xCp = (-aoXk' Xl - alXk, X2 - a2Xk, ... ,Xk-l - ak-IXk) . (22)

Thus we can compute any product ACp in time O(k2). Now given a power
C; of Cp , we can square it in time O(k2) as follows. First compute the
row vector

elc;m = (eIC;)C;.
This takes time O(k2) and gives the first row of C'j,m. Compute the remain-
ing rows of C'j,m by successively multiplying by Cp on the right. This takes
time O(k2) by (22). We can compute C; with at most logn operations of
squaring and multiplying by Cp ; the sequence of operations is determined
by the binary representation of n.
23. Let r = rank A and let A' be an n x r submatrix of A of full rank r.
Let B be an n x (n - r) matrix spanning ker A. As argued in Lecture
40, rank (RA)2 = rank RA = rank A iff the matrix [RA'IB] formed by
juxtaposing RA' and B is nonsingular. Thus

Pr(rank (RA? = rank RA = rank A) = L Pr(RA' = S) ,

SES

where the sum is over the set S of all n x r matrices of full rank r such
that [SIB] is nonsingular.
We claim that RA' is a random l n x r matrix. To see this, let D be any
nonsingular n x n matrix agreeing with A on the columns A'. Then

RA' = (RD)',

where (RD)' denotes the n x r submatrix of RD obtained by deleting the

same columns that were deleted from A to get A'. Since the map R I--t RD
1 A random matrix is a matrix with each entry chosen independently and uniformly at
random from the field. If the matrix is k x m, then all qkm possible matrices are equally
likely.
 SOLUTIONS TO MISCELLANEOUS EXERCISES 289

is a bijection and R is a random matrix, so are RD and (RD)'. Therefore

for any n x r matrix S,
1
Pr(RA' = S) Pr((RD)' = S) =

We now calculate the size of S. Note that a subspace of k n dimension m

has qm elements, since every element is a linear combination of m basis
elements, and there are qm ways to choose the coefficients of the linear
combination. We wish to count the number of ways of choosing an n x r
matrix S of full rank whose columns avoid the subspace of dimension n - r
spanned by the columns of B. There are qn - qn-r ways to choose the first
column of S to avoid this subspace; once that column is chosen, there are
qn _ qn-r+1 ways of choosing the second column to avoid the linear span of
B and the first column already chosen; and so on. After all but one column
are chosen, there are qn - qn-1 ways to choose the last column. Thus there
are in all

II (qn _ qn-i)
r

i=l

ways of choosing S, and this number is lSI. Combining all the above
equations, we have

Pr(rank (RA)2 = rank RA = rank A)

L Pr(RA' = S)
SES
lSI
qnr
1
II(1- i)
r
.
i=l q

24. (a) To show that the problem is coNP-hard, we give a reduction from
the pattern covering problem of Miscellaneous Exercise 5. Let P be
a given set of patterns p E {O, 1, *In. We show how to construct in
polynomial time a set of terms T such that T is a cover of the ground
terms over {f,a,b} iff P is a cover of {O, l}n.
Let

Fn(X1' ... ,xn ) = f(X1' f(X2' ... f(Xn-b xn) ... )) .

Let 0' = a and l' = b. We will encode a string d 1 d2 ••• dn E {O, l}n
by the term Fn (d~, ... , d~). Let S be the set of all terms of this form;
i.e.,
290 SOLUTIONS TO MISCELLANEOUS EXERCISES

We will take T = To U T I , where To will cover exactly the terms not

in S, and TI will cover all terms in S iff P is a cover of {O, l}n. The
set To consists of all terms of the form
• Fi(xI,'" ,xi-I,a), 1 ~ i ~ n-1
• Fi(XI, ... , Xi-I, b), 1 ~ i ~ n - 1
• Fn(xI, ... , Xi-I, f(y, z), Xi+1," . ,xn), 1 ~ i ~ n.
The terms (a) and (b) cover all ground terms not covered by Fn , and
the terms (c) cover all ground terms covered by Fn that are not in S.
Now, for each pattern P = PIP2 ... Pn E {O, 1, *}n, let tp be the term
Fn(P~" .. ,p~), where
a, if Pi = 0,
{ b, if Pi = 1,
Xi, if Pi = * .
The set of ground terms in S covered by Fn(P~"" ,p~) is exactly the
set of all ground terms Fn(d~, .. . ,d~) such that d I d 2 .. • dn E {O, l}n
is covered by p. We therefore take
TI = {tp I pEP} .
(b) We would like to guess a ground term and verify in polynomial time
that it is not covered by T. The major difficulty here is that there
are infinitely many ground terms. We need to know that if there
exists a ground term that is not covered by T, then there is one of
polynomial size. This will allow us to guess that term by a sequence
of polynomially many nondeterministic binary choices.
For convenience, we view terms as functions labeling the nodes of the
infinite binary tree with f, a, b, variables in X, or 1... Formally, a term
t is a map
t : {L, R} * -t {J, a, b} U X U {-l}
such that for all 0: E {L, R} *, the following are equivalent:
• t(o:) =f
• t(o:L) f:.1..
• t( o:R) f:. 1..
and such that t(o:) f:. 1.. for at most finitely many 0:. For example, the
term f (J (a, b) , b) is represented by the map
E t-t f
L t-t f
LL t-t a
LR t-t b
R t-t b
everything else t-t 1...
SOLUTIONS TO MISCELLANEOUS EXERCISES 291

Let tja denote the subterm of t rooted at a:

tja«(3) = t(a(3).
Now let T be the given set of terms. Let

At {a I t(a) i: .1}
A UAt
tET
A Au {aL, aR I a E A} .

The set At is a set of paths, but it can be thought of as the binary

tree obtained by ignoring labels on the nodes of t. The set A can be
thought of as the tree obtained by superimposing the trees At, t E T,
on one another. The set A can be thought of as the tree obtained
from A by sprouting two new shoots out of each leaf.
Assume ITI ~ 2 (the only singleton cover is {x}). Let n = L:tET lAd
(a measure of the size of the problem). Then IAI < nand IAI-IAI =
IAI + 1 ::; n. Let M be the set of ground terms t such that At is the
complete binary tree of depth log log 2n. There are at least 2n terms
in M, one for each assignment of a and b to the log 2n leaves, and
each term in M is of size 2 log 2n.
We claim now that if T covers all ground terms of size at most n +
2n log 2n, then it covers all ground terms. To see this, suppose that
T covers all ground terms of size at most n + 2n log 2n, and let t be
an arbitrary ground term. Associate with each a E A - A a unique
term U a E M such that U a i: tj (3 for any (3 E A. Since IMI ~ 2n,
IAI ::; n, and IAI - IAI ::; n, there are enough terms in M to do this.
Let t' be a new term obtained from t by replacing all subterms tja
for a E A - A with U a . In other words,
• for a E A, set t'(a) = t(a);
• for a E A - A such that t(a) i: .1, set t'(a(3) = u a «(3) for all
1(31 ::; log log 2n;
• for all a not assigned in (a) or (b), set t'(a) =.1.
From the construction of t', it is clear that

IAt,1 ::; IAI + IA - AI· 2log2n ::; n + 2nlog2n ,

so by assumption t! is a substitution instance of some term 8 E T.
We claim that t is a substitution instance of 8 as well. Certainly, if
all the variables of 8 are distinct, then t is a substitution instance
of 8, since t and t' agree on all elements of A. Now suppose for a
contradiction that there exist strings a and (3 such that 8(0.) = 8«(3) E
 292 SOLUTIONS TO MISCELLANEOUS EXERCISES

X (thus 0.,(3 E A) and tla #- tl(3. Then there exists a string "I such
that

t(a"l) = tla("f) #- tl(3("f) = t((3"1).

We may assume without loss of generality that neither t(a"l) nor
t((3"1) = .1; otherwise, we can find a prefix of "I such that this is
true, and take "I to be that prefix instead. We have three cases:
• If both 0."1,(3"1 E A, then t'(a"l) #- t'((3"1), since t and t' agree on
A. This contradicts the fact that t' is a substitution instance of
s.
• If 0."1 ¢ A and (3"1 E A, let "I' be a prefix of "I such that 0."1' E A-A.
Then (3"1' E A. Either tl(3"1' is entirely contained in A (in the sense
that for all 8 E A t //3"(', (3"1'8 E A), in which case t'I(3'Y' = tl(3"1';
or there exists a 8 such that (3"1'8 E A - A and t((3"1'8) #- .1, in
which case t' 1(3"1'8 = U/3"('6. In either case t'la"l' = u"""(' #- t' I (3"1',
again contradicting the fact that t' is a substitution instance of s.
• If 0."1 ¢ A and (3"1 ¢ A, let "I' be a prefix of "I such that 0."1' E A-A
and (3"1' E A (or vice versa-assume the former). If (3"1' E A, then
we revert to the previous case. Otherwise, both 0."1', (3"1' E A-A.
Then

t' (0."1') = U"""(' #- U/3"(' = t' ((3"1') ,

again contradicting the fact that t' is a substitution instance of s.
Since all three cases lead to a contradiction, we conclude that t is a
substitution instance of s. Since t was arbitrary, T is a cover.
Thus to determine whether there exists a ground term not covered
by T, we need only guess one of size at most n + 2n log 2n and check
that it is not covered by any sET. This can easily be done in
nondeterministic polynomial time.

25. This problem can be solved with n processors in O(logn) time. We asso-
ciate a processor with each vertex. The processor associated with vertex
v will calculate a pointer next(v) to the successor of v in the preorder
traversal. If v is not a leaf, then next (v) is its leftmost child. If v is a leaf,
then next(v) is the leftmost right sibling of d(v), where d(v) is the lowest
ancestor of v that is not the rightmost child of its parent. If no such d( v)
exists, then v is the last vertex in preorder and has no successor.
To compute the next pointers of leaves in logarithmic time, we use the
technique of pointer doubling. Initially, each vertex v sets
parent (v) if v is the rightmost child of its parent;
d( v):= { v if v is not the rightmost child of its par-
ent or v is the root.
 SOLUTIONS TO MISCELLANEOUS EXERCISES 293

Each vertex v then iterates the operation d( v) := d( d( v)) log n times. This
must be done synchronously in parallel. At this point d(v) = d(v) if d(v)
exists, or the root if not. If so, the leaf v sets next (v) to the leftmost right
sibling of d(v).
We now have a list next of all vertices in the correct order. It remains
to compute the preorder number of v for each v. This is the number
of vertices appearing on the list next before v. This can be done in log n
stages with parallel prefix addition, using pointer doubling (i. e., next (v) :=
next(next(v))) to calculate the address to send the next message in each
stage.
26. (a) To test whether G is outerplanar and to find an outerplane embed-
ding if one exists, we add a new vertex v and an edge from v to all
other vertices, then use the Hopcroft-Tarjan planarity test [52] to test
whether the resulting graph G' is planar and find a plane embedding
if so. This can be done in linear time. If G is outerplanar, then G can
be embedded with all vertices on the outer face, so embedding v in
the outer face allows v to be connected to all other vertices without
crossing; thus G' is planar. Conversely, if G' is planar, then it can be
embedded with v adjacent to the outer face; then deleting v and its
incident edges gives an outerplane embedding of G.
(b) There always exists a l-~ separator of size 2. To find it, we first find
an outerplane embedding as in part (a).

o
We then triangulate the interior faces. This can be done by traversing
each interior face, adding an edge from the first vertex on the face
to every other vertex on the face it is not already connected to. (We
know from part (a) which face is the exterior face: it is the one that
contained v.)

We then compute the plane dual of G using Miscellaneous Exercise

9, but we omit the vertex corresponding to the outer face of G and
all incident edges. The resulting graph is a tree T, because any cycle
would contain a vertex of G not on the outer face.
294 SOLUTIONS TO MISCELLANEOUS EXERCISES

Exercise 2 can then be used to find an edge e in T whose removal dis-

connects T into two disjoint subtrees with no more than 2/i1 vertices
each, where f is the number of vertices in T (= number of interior
faces of G). The desired separator consists of the endpoints of the
dual edge of e.
27. (a) Let the data elements be a1, ... , an- Assign n 2 processors to compare
every element with every other element. For all i,j, 1 ~ i,j ~ n, let
A. . = {I if either ai < aj or (ai = aj and i < j)
OJ 0 otherwise.
The n x n matrix A can be produced by the n 2 processors in one step.
The matrix A determines the sorted order: for all i, the number of l's
in the ith row of A is the position of i in sorted order. Computing the
ith row sum of A takes 0 (log n) time and 0 (n) processors in parallel, or
o (log n) time and O(n 2 ) processors to compute all the row sums. Once
the position of an element in sorted order is computed, that element
is stored in the proper element of the output array. This takes one
step with n processors, assuming random access to the output array.
(b) We use parallel mergesort. Each of n processors is assigned to a
different input element. The set of elements is split into two sets
of roughly equal size which are then sorted recursively in parallel. We
then merge the two sorted arrays in O(logn) time with n processors
as described below. We obtain the recurrence
T(n)
giving a running time of
T(n) = O((logn)2).
We now show how to merge two sorted arrays in time O(logn). Let
S, T be the two sorted arrays of size m and n, respectively. We have
m + n processors at our disposal, each assigned to a different element.
First we find the medians x and y of Sand T, respectively. This takes
one step. Then compare x and y; say without loss of generality x ~ y.
Split each of Sand T into three arrays
{zESlz~x} {zETlz~x}
{zESlx<z~y} {zETlx<z~y}
{zESly<z} {ZETIY<z}
 SOLUTIONS TO MISCELLANEOUS EXERCISES 295

in one step. Note that each 8 i is at most half the size of 8 and each
1'; is at most half the size of T. For each 0 ~ i ~ 2 in parallel,
merge 8i and Ti recursively with the 18i l + 11';1 processors assigned
to 8i and 1';. Let Ui be the array obtained by merging 8i and Ti ,
o ~ i ~ 2. Now store Uo, Ul , and U2 in an array end-to-end. The
processor associated with the ith element of Uo stores its element in
position i of the output array; the processor associated with the ith
element of Ul stores its element in position IUoI + i of the output
array; and the processor associated with the ith element of U2 stores
its element in position IUol + lUll + i of the output array. This takes
constant time in parallel. We obtain the recurrence

giving a parallel time bound of

T(n) = O(logn)

for the merge.

Parallel sorting is a topic of intense current interest. There are much more
efficient NC algorithms known for sorting than the ones given here. To
mention a few: Ajtai, Komlos, and Szemeredi [5] give a sorting network
of depth O(logn) and O(n) linear width; Cole [20] gives a CREW PRAM
sorting algorithm that runs in time o (log n) on n processors; Bilardi and
Nicolau[12] give an EREW PRAM bitonic sorting algorithm that runs in
time 0 ((log n) 2 ) on n / log n processors.

28. (a) We first show that the product of two circulant matrices is again a
circulant matrix. A matrix C is circulant iff, when the columns are
rotated one position to the left and then the rows are rotated up, we
get C back; in terms of permutation matrices,

p-1CP = C,

where

0 0 0 1
1 0 0 0
p 0 1 0 0

0 0 1 0

Then AB is circulant if A and B are, since

P-1ABP = P-1APP-1BP AB.

296 SOLUTIONS TO MISCELLANEOUS EXERCISES

While we are at it, let us show that the inverse of a circulant matrix,
if it exists, is circulant:
p-l A-Ip = (p-l AP)-l = A-I.
We can easily compute the first row of AB in O(logn) time with n 2
processors, since each element of the first row is an inner product
and can be computed in O(log n) time with n processors. Since AB
is circulant, we need only rotate the- first row to get the other rows.
This takes constant time with n 2 processors.
(b) Let a = (ao, al, ... , an-I) and b = (b o, bI, ... , bn- l ). Let c(a) denote
the unique circulant matrix with first row a; thus c(a)ij = aj-i. In [3,
pp. 256-257], it is stated that the vector F;;I(Fna·Fnb) is the positive
wmpped convolution of a and b:
F;;I(Fna . Fnb) (23)
n-l n-l n-l n-l
= (L aib-i, L aibl-i, L ai~-i' ... , L aibn-I-i). (24)
;=0 ;=0 i=O i=O

(Subscripts in (24) are taken modulo n.) It can be shown by a direct

calculation that this is the first row of the matrix product c(a} . c(b};
thus
(25)
The vector F;;I(Fna . Fnb) can be computed in time O(logn) with n
processors by doing two Fourier transforms, a componentwise vector
product, and an inverse Fourier transform.
Since the proof of (24) is omitted from [3], we supply one here. Let f
and g be polynomials of degree at most n - 1 with coefficients a and
b, respectively. As shown in Lecture 35, under the Fourier transform,
multiplication of polynomials modulo xn - 1 becomes componentwise
vector product:
(26)
Modulo xn -1, we can equate monomials Xi and Xi mod n. This allows
us to take superscripts as well as subscripts modulo n. Doing so, we
get the following calculation:

L L aibjxi+j
n-In-l
fg mod xn-l
i=O j=O
n-In-l
L L aibk_i xk
i=O k=O
n-l n-l
L(L aibk_i)Xk .
k=O i=O
SOLUTIONS TO MISCELLANEOUS EXERCISES 297

Thus the coefficient of Xk in fg mod xn - 1 is E?~Ol aibk-i, the kth

element of the positive wrapped convolution of a and b. This and (26)
give (24).
Algebraically, what is really going on here is that the circulant matri-
ces form an n-dimensional subalgebra of the n 2 -dimensional algebra
of n x n matrices, and this subalgebra is isomorphic to the subalgebra
of diagonal matrices via the map
C f----' F;:lCFn .
Moreover, if d(a) denotes the diagonal matrix with diagonal a, then
(27)
This can be established by a direct calculation, using the property

Lw
n-l
j=O
ij = {'f' == °
n, 1 Z mo d n
0, otherwise
where w is a primitive nth root of unity: the i, gth element of F;:lc(a)Fn
is

-1 L L w-·(k-m)amwkl
n-l n-l .

n m=Ok=O
1 n-l
L L
n-l . .
amw·m ( - w(h)k)
m=O n k=O

{ E;;;:}o amw
im if i = e
° if i i e
which is also the i, gth element of d(Fna).
(c) The first row of the inverse of c( a) can be calculated by taking the
Fourier transform of a, inverting all the elements of the resulting vec-
tor, and transforming back. In other words,
c(a)-l = c(F;:l((Fna)')) ,
where b' is the vector obtained from b by inverting all the elements.
This follows immediately from the isomorphism c(a) f----' d(Fna) dis-
cussed in part (b) above, but in case you did not have the patience
to wade through all that, here is a more direct argument. If (Fna)'
exists, then by (25),
c(a) . c(F;:l((Fna)')) c(F;:l(Fna. Fn(F;:l((Fna)'))))
c(F;:l(Fna· (Fn a)'))
C(F;:l(l, 1, 1, ... ,1))
c(l,O,O, ... ,0))
I,
298 SOLUTIONS TO MISCELLANEOUS EXERCISES

thus c(a) and c(F;l((Fna)')) are inverses. Conversely, if the inverse

c(a)-l exists and b is its first row, then

C(F;;-l (1,1,1, ... , 1)) c(1,O,O, ... ,O))

I
c(a) . c(b)
c(F;l(Fna. Fn b)) ,

by (25). Therefore

Fna . Fnb = (1,1,1, ... ,1),

so (Fna)' exists and is equal to Fnb. The entire operation can be done
in time O(log n) with n processors using the fast Fourier transform.
Circulant matrices have numerous applications in geometry, differential
equations, and mechanics. To find out more about them, see Davis' book
[27].
29. For permutation a E Sn, define
n
t(a) II Ti,O"(i) .
i=l

Then

detT L (_1)si g n(0")t(a) .

O"ESn

Let En be the set of permutations in Sn with only even cycles.

Lemma

detT L (_1)sig n(0")t(a) .

O"EEn

Proof. We will show that the contributions of permutations a containing

odd cycles cancel each other out. Suppose a contains an odd cycle p, and
let T = ap-l. Then a = Tp = PT (disjoint cycles commute). Consider the
permutation Tp-l. Then

-t(Tp) ,
SOLUTIONS TO MISCELLANEOUS EXERCISES 299

since rp-l changes the signs of an odd number of factors of t(rp). For
example, if p = (13746) and r = (25), then p-l = (64731), and

t(rp)
t(rp-l)
-t(rp) .

Moreover, sign(rp) = sign(rp-l), since

which is even, thus rp and rp-l are either both even or both odd. Thus
the permutations containing odd cycles p and p-l can be paired up so that
their contributions (-1 )sign(u)t( 0') to det T cancel. This assignment can be
repeated for other permutations 0' not containing p but containing another
odd cycle. Thus we are left with the permutations containing even cycles
only. 0

(a) If the multivariate polynomial det T is not identically 0, then by the

Lemma there must exist a permutation 0' containing even cycles only
such that t( 0') =I- O. But then 0' gives a perfect matching by taking
alternate edges around the cycles. Conversely, let M be a perfect
matching. Assign Xuv = 1 for (u, v) E M and Xuv = 0 otherwise. Un-
der this substitution, there is exactly one 0' with t( 0') =I- 0, namely the
one corresponding to M, thus det T with this substitution is nonzero.
Therefore det T is not identically O.
(b) Select a random assignment a to the Xuv from a set of size 2n. By
Corollary 40.2, the probability that det T(a) = 0 is 1 if det T is iden-
tically 0 and at most 2~ if not. Thus with a probability of error at
most 2~ we can determine whether G has a perfect matching.
(c) For each edge in succession, test whether the graph with edge e re-
moved has a perfect matching using the above procedure. If so, then
delete e from G. With high probability, we are left with the edges of
a perfect matching.
Bibliography

[1] L. M. Adleman and M.-D. A. Huang. Primality testing and two-

dimensional Abelian varieties over finite fields. preprint, University of
Southern California, February 1988.

[2] A. V. Aho, M. R. Garey, and J.D. Ullman. The transitive reduction of

a directed graph. SIAM J. Comput., 1:131-137, June 1972.

[3] A. V. Aho, J. E Hopcroft, and J. D. Ullman. The Design and Analysis

of Computer Algorithms. Addison-Wesley, 1975.

[4] R. K. Ahuja, J. B. Orlin, and R. E. Tarjan. Improved time bounds for

the maximum flow problem. SIAM J. Comput., 18:939-954, 1989.

[5] M. Ajtai, J. Komlos, , and E. Szemeredi. An O(n log n) sorting network.

Combinatorica, 3:1-9, 1983.

[6] N. Alon, L. Babai, and A. Itai. A fast and simple randomized parallel
algorithm for the maximal independent set problem. J. Algorithms,
7:567-583, 1986.

[7] C. R. Aragon and R. G. Seidel. Randomized search trees. In Proc. 30th

Symp. Foundations of Computer Science, pages 540-545. IEEE, 1989.
[8] E. Bach. Analytic methods in the analysis and design of number theoretic
algorithms. MIT Press, Cambridge, Mass., 1985.
[9] P. W. Beame, S. A. Cook, and H. James Hoover. Log depth circuits
for division and related problems. In Pmc. 25th Con! Foundations of
Computer Science, pages 1-6. IEEE, October 1984.
[10] C. Berge. Two theorems in graph theory. Proc. National Acad. Sci.,
43:842-844, 1957.

[11] S. Berkowitz. On computing the determinant in small parallel time

using a small number of processors. Information Processing Letters,
18:147-150, 1984.

301
302 BIBLIOGRAPHY

[12] G. Bilardi and A. Nicolau. Adaptive bitonic sorting: an optimal parallel

algorithm for shared-memory machines. SIAM J. Comput., 18(2):216-
228, April 1989.

[13] Bela Bollobas. Extremal Graph Theory. Academic Press, 1978.

[14] J. A. Bondy and U. S. R. Murty. Graph Theory with Applications. North

Holland, 1976.
[15] A. Borodin, J. von zur Gathen, and J. Hopcroft. Fast parallel matrix
and gcd computations. Information and Control, 52(3):241-256, 1982.
[16] 1. Borosh and L. B. Treybig. Bounds on positive integral solutions of
linear diophantine equations. Proc. Amer. Math. Soc., 55:299-304, 1976.
[17] W. Brown and J. F. Traub. On Euclid's algorithm and the theory of
subresultants. J. Assoc. Comput. Mach., 18:505-514, 1971.
[18] A. L. Chistov. Fast parallel calculation of the rank of matrices over a
field of arbitrary characteristic. In Proc. ConJ. Foundations of Compu-
tation Theory, volume 199 of Lect. Notes in Comput. Sci., pages 63-69.
Springer-Verlag, 1985.
[19] V. Chvatal. Linear Programming. Freeman, 1980.

[20] R. Cole. Parallel merge sort. In Proc. 27th Symp. Foundations of Com-
puter Science, pages 511-516. IEEE, October 1986.

[21] J. H. Conway. Regular Algebra and Finite Machines. Chapman and

Hall, London, 1971.
[22] S. A. Cook. The complexity of theorem proving procedures. In Proc.
3rd Symp. Theory of Computing, pages 151-158. ACM, 1971.

[23] S. A. Cook. The classification of problems which have fast parallel algo-
rithms. In Karpinski, editor, Proc. 1983 Symp. Foundations of Compu-
tation Theory, volume 158 of Lect. Notes in Comput. Sci., pages 78-93.
Springer-Verlag, 1983.
[24] J. M. Cooley and J. W. Tukey. An algorithm for the machine calculation
of complex Fourier series. Mathematics of Computation, 19:297-301,
1965.

[25] D. Coppersmith and S. Winograd. Matrix multiplication via arithmetic

progressions. In Proc. 19th Symp. Theory of Computing, pages 1-6.
ACM, May 1987.
[26] L. Csanky. Fast parallel matrix inversion algorithms. SIAM J. Comput.,
5:618-623, 1976.
BIBLIOGRAPHY 303

[27] Philip J. Davis. Circulant Matrices. Wiley, 1979.

[28] E. W. Dijkstra. A note on two problems in connexion with graphs.

Numerische Math., 1:269-271, 1959.
[29] E. A. Dinie. Algorithm for solution of a problem of maximal flow in a
network with power estimation. Soviet Math. Doklady, 11:1277-1280,
1970.

[30] J. Edmonds and R. M. Karp. Theoretical improvements in algorithmic

efficiency for network problems. J. Assoc. Comput. Mach., 19:248-264,
1922.

[31] J. R. Edmonds. A combinatorial representation for polyhedral surfaces.

Notices Amer. Math. Soc., 7:646, 1960.
[32] J. R. Edmonds. Matroids and the greedy algorithm. Math. Progmm-
ming, 1:127-136, 1971.
[33] W. Feller. An Introduction to Probability Theory and its Applications,
volume 1. Wiley, 1950.
[34] L. R. Ford, Jr. and D. R. Fulkerson. Maximal flow through a network.
Canad. J. Math., 8:399-404, 1956.
[35] M. L. Fredman and R. E. Tarjan. Fibonacci heaps and their uses in
improved network optimization algorithms. In Proc. 25th Symp. Foun-
dations of Computer Science, pages 338-346. IEEE, 1984.
[36] D. Gale and L. S. Shapley. College admissions and the stability of
marriage. Amer. Math. Monthly, 69:9-14, 1962.
[37] Z. Galil. An O(V5/3 E 2/ 3) algorithm for the maximal flow problem. Acta
Informatica, 14:221-242, 1980.
[38] Z. Galil and E. Tardos. An O(n2 (m + n log n) logn) min-cost flow algo-
rithm. J. Assoc. Comput. Mach., 35:374-386, 1988.

[39] M. R. Garey and D. S. Johnson. Computers and Intmctibility: a Guide

to the Theory of NP-Completeness. w. H. Freeman, 1979.

[40] M. R. Garey, D. S. Johnson, and L. Stockmeyer. Some simplified NP-

complete graph problems. Theor. Comput. Sci., 1:237-267, 1976.
[41] A. V. Goldberg and R. E. Tarjan. A new approach to the maximum
flow problem. J. Assoc. Comput. Mach., 35:921-940, 1988.
[42] L. M. Goldschlager. The monotone and planar circuit value problems
are logspace complete for P. SIGACT News, 9(2):25-29, 1977.
304 BIBLIOGRAPHY

[43] R. Graham, D. Knuth, and O. Patashnik. Concrete Mathematics: A

Foundation for Computer Science. Addison Wesley, 1989.

[44] A. C. Greenberg, R. E. Ladner, M. S. Paterson, and Z. GallI. Effi-

cient parallel algorithms for linear recurrence computation. Infor. Proc.
Letters, 15(1):31-35, 1982.
[45] D. Gries and G. Levin. Computing Fibonacci numbers (and similarly
defined functions) in log time. Infor. Proc. Letters, 11(2):68-69, 1980.

[46] D. Gries, A. J. Martin, J. L. A. van de Snepscheut, and J. T. Udding.

An algorithm for transitive reduction of an acyclic graph. Science of
Computer Programming, 12(2):151-155, July 1989.
[47] A. Haken. The intractability ofresolution. Theor. Comput. Sci., 39:297-
308,1985.

[48] F. Harary. Graph Theory. Addison-Wesley, 1972.

[49J G. H. Hardy and E. M. Wright. An Introduction to the Theory of Num-

bers. Oxford, 1979.
[50] J. Hartmanis and J. Simon. On the power of multiplication in random
access machines. In Proc. 15th Symp. Switching and Automata Theory,
pages 13-23, 1974.

[51] J. E. Hopcroft and R. M. Karp. An n 5 / 2 algorithm for maximum match-

ing in bipartite graphs. SIAM J. Comput., 2:225-231, 1973.

[52] J. E. Hopcroft and R. E. Tarjan. Efficient planarity testing. J. Assoc.

Comput. Mach., 21:549-568, 1974.
[53] O. Ibarra, S. Moran, and L. E. Rosier. A note on the parallel complex-
ity of computing the rank of order n matrices. Information Processing
Letters, 11:162, 1980.
[54] S. L. Johnsson. Communication efficient basic linear algebra computa-
tions on hypercube architectures. Technical Report YALEU jDCSjRR-
361, Yale University, September 1985.

[55] S. L. Johnsson and C.-T. Ho. Optimum broadcasting and personal-

ized communication in hypercubes. IEEE Transactions on Computers,
38(9):1249-1268,1989.

[56] N. Karmarkar. A new polynomial-time algorithm for linear program-

ming. Combinatorica, 4:373-395, 1984.
BIBLIOGRAPHY 305

[57] R. M. Karp. Reducibility among combinatorial problems. In R. E. Miller

and J. W. Thatcher, editors, Complexity of Computer Computations,
pages 85-103. Plenum Press, New York, 1972.
[58] R. M. Karp. On the complexity of combinatorial problems. Networks,
5:45-68, 1975.

[59] R. M. Karp and A. Wigderson. A fast parallel algorithm for the maximal
independent set problem. In Proc. 16th Symp. Theory of Computing,
pages 266-272. ACM, May 1984.
[60] L. G. Khachian. Polynomial algorithms in linear programming. Zhumal
Vychislitelnoi Matematiki i Matematicheskoi Fiziki, 20:53-72, 1980.
[61] S. C. Kleene. Representation of events in nerve nets and finite au-
tomata. In Shannon and McCarthy, editors, Automata Studies, pages
3-41. Princeton U. Press, 1956.

[62] D. E. Knuth. The Art of Computer Programming: Fundamental Algo-

rithms, volume 2. Addison Wesley, 1973.
[63] D. C. Kozen. On induction vs. *-continuity. In Kozen, editor, Proc.
Workshop on Logics of Programs 1981, volume 131 of Lect. Notes in
Comput. Sci., pages 167-176. Springer-Verlag, 1981.
[64] D. C. Kozen. On Kleene algebras and closed semirings. In Rovan, editor,
Proc. Math. Found. Comput. Sci. 1990, volume 452 of Lect. Notes in
Comput. Sci., pages 26-47. Springer-Verlag, 1990.
[65] D. C. Kozen. A completeness theorem for Kleene algebras and the
algebra of regular events. In Proc. 6th Symp. Logic in Comput. Sci.,
pages 214-225. IEEE, 1991.
[66] J. B. Kruskal. On the shortest spanning subtree of a graph and the
traveling salesman problem. Proc. Amer. Math. Soc., 7:48-50, 1956.
[67] R. Ladner.
The circuit value problem is logspace complete for P.
SIGACT News, 7(1):18-20, 1975.
[68] R. E. Ladner and M. J. Fischer. Parallel prefix computation. J. Assoc.
Comput. Mach., 27(4):831-838, 1980.
[69] S. Lang. Algebra. Addison Wesley, second edition, 1984.

[70] E. L. Lawler. Combinatorial Optimization: Networks and Matroids.

Holt, Rinehart, Winston, 1976.
[71] L. A. Levin. Universal sorting problems. Problems of Information
Transmission, 9:265-266, 1973.
306 BIBLIOGRAPHY

[72J D. Lichtenstein. Planar formulae and their uses. SIAM J. Comput.,

11(2):329-343, 1982.

[73J R. Lipton and R. E. Tarjan. Applications of a planar separator theorem.

In Proc. 18th Conf. Foundations of Computer Science, pages 162-170.
IEEE,1977.

[74J L. Lovasz. On determinants, matchings, and random algorithms. In

Budach, editor, Proc. Symp. on Fundamentals of Computing Theory,
pages 565-574, Berlin, 1979. Akademia-Verlag.

[75J L. Lovasz and M. D. Plummer. Matching Theory. North Holland, 1986.

[76J M. Luby. A simple parallel algorithm for the maximal independent set
problem. In Proc. 17th Symp. Theory of Computing, pages 1-10. ACM,
May 1985.

[77J V. M. Malhotra, M. Pramodh-Kumar, and S. N. Maheshwari. An O(V3)

algorithm for finding maximum flows in networks. Information Process-
ing Letters, 7:277-278, 1978.

[78J K. Mehlhorn. Data Structures and Algorithms 2: Graph Algorithms

and NP-Completeness. EATCS Monographs on Theoretical Computer
Science. Springer-Verlag, 1984.

[79J A. R. Meyer and R. Ritchie. The complexity of loop programs. In Proc.

National Meeting, pages 465-469. ACM, 1967.

[80J S. Micali and V. Vazirani. An O( y'iVf .

lEI) algorithm for finding max-
imum matchings in general graphs. In Proc. 21st Symp. Foundations of
Computer Science, pages 17-27. IEEE, 1980.
[81J G. L. Miller. Riemann's hypothesis and tests for primality. J. Comput.
Syst. Sci., 13:300-317, 1976.
[82J K. Mulmuley. A fast parallel algorithm to compute the rank of a matrix
over an arbitrary field. Combinatorica, 7(1):101-104, 1987.

[83J V. Va. Pan. Strassen's algorithm is not optimal. In Proc. 19th Symp.
Foundations of Computer Science, pages 166-176. IEEE, 1978.

[84J V. Va. Pan. How to multiply matrices faster, volume 179 of Lect. Notes
in Comput. Sci. Springer-Verlag, 1984.
[85J C. H. Papadimitriou and K. Steiglitz. Combinatorial Optimization: AL-
gorithms and Complexity. Prentice-Hall, 1982.
BIBLIOGRAPHY 307

[86] A. Pettorossi. Derivation of an O(k 2 10gn) algorithm for computing

order-k Fibonacci numbers from the O(k3 10gn) matrix multiplication
method. Infor. Proc. Letters, 11(4):172-179, 1980.
[87] J. A. La Poutre. Lower bounds for the union-find and the split-find
problem on pointer machines. In Proc. 22nd Symp. Theory of Comput-
ing, pages 34-44. ACM, 1990.
[88] W. Pugh. Skip lists: a probabilistic alternative to balanced trees.
Comm. Assoc. Comput. Mach., 33(6):668-676, June 1990.
[89] M. O. Rabin. Probabilistic algorithms for testing primality. J. Number
Theory, 12:128-138, 1980.
[90] J. Renegar. A polynomial-time algorithm based on Newton's method
for linear programming. Math. Programming, 40:59-93, 1988.
[91] R. L. Rivest and J. Vuillemin. On recognizing graph properties from
adjacency matrices. Theor. Comput. Sci., 3:371-384, 1976/77.
[92] J. T. Schwartz. Fast probabilistic algorithms for verification of polyno-
mial identities. J. Assoc. Comput. Mach., 27:701-717, 1980.
[93] Y. Shiloach and U. Vishkin. An o (log n) parallel connectivity algorithm.
J. Algorithms, 3:57-67, 1982.

[94] D. Sleator and R. E. Tarjan. Self-adjusting binary trees. In Proc. 15th

Symp. Theory of Computing, pages 235-245. ACM, 1983.
[95] D. D. Sleator. An O(nmlogn) algorithm for maximum network flow.
Technical Report STAN-CS-80-831, Stanford University, 1980.
[96] R. Solovay and V. Strassen. A fast Monte Carlo test for primality. SIAM
J. Comput, 6:84-85, 1977.

[97] V. Strassen. Gaussian elimination is not optimal. Numerische Math.,

13:354-356, 1969.
[98] E. Tardos. A strongly polynomial minimum cost circulation algorithm.
Combinatorica, 5:247-255, 1985.
[99] R. E. Tarjan. A class of algorithms that require nonlinear time to main-
tain disjoint sets. J. Comput. Syst. Sci., 18:110-127, 1979.
[100] R. E. Tarjan. Data Structures and Network Algorithms, volume 44 of
Regional Conference Series in Applied Mathematics. SIAM, 1983.
[101] A. Urquhart. Hard examples for resolution. J. Assoc. Comput. Mach.,
34(1):209-219, 1987.
308 BIBLIOGRAPHY

[102] P. M. Vaidya. An algorithm for linear programming which requires

O(((m + n)n2 + (m + n)1.5n )L) arithmetic operations. In Proc. 19th
Symp. Theory of Computing, pages 29-38. ACM, 1987.
[103] L. G. Valiant. The complexity of computing the permanent. Theor.
Comput. Sci., 8:189-201, 1979.
[104] L. G. Valiant and G. J. Brebner. Universal schemes for parallel com-
munication. In Proc. 13th Symp. Theory of Computing, pages 263-277.
ACM,1981.
[105] V. V. Vazirani. A theory of alternating paths and blossoms for prov-
ing correctness of the O(v'fVf .
lEI) general graph matching algorithm.
Technical Report 89-1035, Cornell University, September 1989.

[106] J. Vuillemin. A data structure for manipulating priority queues. Comm.

Assoc. Comput. Mach., 21:309-314, 1978.
[107] D. J. A. Welsh. Matroid Theory. Academic Press, 1976.

[108] H. S. Wilf. Algorithms and Complexity. Prentice-Hall, 1986.

[109] T. C. Wilson and J. Shortt. An O(logn) algorithm for computing gen-
eral order-k Fibonacci numbers. Infor. Proc. Letters, 10(2):68-75, 1980.
[110] A. C.-C. Yao. Monotone bipartite graph properties are evasive. SIAM
J. Comput., 17(3):517-520, 1988.

[111] R. E. Zippel. Probabilistic algorithms for sparse polynomials. In Ng,

editor, Proc. EUROSAM 79, volume 72 of Lect. Notes in Comput. Sci.,
pages 216-226. Springer-Verlag, 1979.
Index

o notation, 3, 4 Alon, No, 191

a(n), 49, 51, 275 alternating
<p, 46, 203 cycle, 101, 110
:::;~, 117 path, 101, 286
:::;~, 117 amortization, 40, 42, 58, 99
=~, 117 Anderaa, So 0o, 220
* operator, 29 Anderaa-Rosenberg conjecture, 220
#P, 138, 139 annihilator, 29
-complete, 141, 142, 232 antisymmetry, 23
2-3 tree, 58 Aragon, Co R., 65
2-colorability, 119, 284 arithmetic
2CNFSat, 118 circuit, 152
3-colorability, 120, 121, 126 integer, 160
3-dimensional matching, 126 articulation point, 20, 21
3CNFSat, 125, 140, 225, 231 associativity, 29, 153
4-colorability, 122 asymptotic complexity, 4
augmenting path, 88, 92, 94, 102,
acceptable 223, 286
coloring, 15, 272 AVL tree, 58
optimal, 16
total, 15 Babai, Lo, 191
extension, 15 Bach, E., 201
Ackermann's function, 49, 275 back edge, 20, 22, 94, 242
acyclic, 23 bad
addition, 160 cycle cover, 145
adjacency edge, 195
list, 3, 6, 10, 75, 231, 241, 242, vertex, 195
278, 286 balanced tree, 58, 65
matrix, 3, 6, 26, 27, 38, 142, basis, 4, 175, 176, 215
146, 240, 243, 262, 283, 286 benefit function, 128
bipartite, 141, 142, 144, 213, Berge, Co, 102
244, 286 Berkowitz' algorithm, 214
Adleman, Lo Mo, 202 Berkowitz, So, 171
affine subspace, 269 Bertrand's postulate, 199
Ajtai, Mo, 295 BFS, see breadth-first search
all-pairs shortest paths, 27, 33, 38, biased coin, 198
230 biconnected

309
310 INDEX

component, 20, 21 search, 19, 25, 78, 94, 95, 97,

graph, 20 99, 108, 119, 122, 284
Big Bang, 50
Bilardi, G., 295 calculus, 69
bin packing, 125, 130, 133 canonical element, 48
binary capacity, 84, 85, 94, 252
addition, 41 integer, 90
relation, 9, 30, 32 irrational, 91
representation, 154, 258, 264, 282, rational, 90
288 vertex, 98
tree, 58, 65, 153, 290 Carmichael number, 203, 204, 207
complete, 291 carpenter's rule problem, 230, 276
binomial carry, 160
heap, 40-44 cascading cuts, 45
tree, 41 Cayley-Hamilton theorem , 170 , 174,
bipartite 175
adjacency matrix, 141, 142, 144, characteristic, 74, 75
213, 244, 286 equation, 170, 175
graph, 71, 100, 119, 122, 141, Euler, 74, 231
142,213,224,227,233,235, field, 178, 187
244, 254, 262 polynomial, 47, 166-176, 178,
regular, 255 215, 233
matching, 100, 107, 141, 144, checkerboard, 250
213, 224, 235, 254 Chinese remainder theorem , 148, 204 ,
bitonic sorting, 295 207, 209
block diagonal matrix, 175, 264 Chistov's algorithm, 171-173, 178,
blocking flow, 96, 98 214
blue rule, 12, 14, 230, 250, 272 Chistov, A. L., 171, 178
Bollobas, B., 244 chord, 75
Boolean Christofides' heuristic, 260
circuit, 152 circuit, 14
formula, 111, 113, 134, 138 arithmetic, 152
matrix, 26, 28, 32 Boolean, 152
satisfiability, 112 Euler, 131, 219, 240
variable, 135 Hamiltonian, 131
Borodin, A., 178 uniform, 5, 152
bottleneck value problem, 152
capacity, 88, 90, 92, 93, 97, 223, circulant matrix, 235, 295-298
252 clause, 113
communication, 152 clique, 111, 113, 125, 140, 232
edge, 88, 93 maximal, 282
breadth-first closed semiring, 30
numbering, 78 CNF, see conjunctive normal form
CNFSat, 111, 113, 120, 121, 125,
INDEX 311

133,134,140,225,231,257, convolution, 186

258, 260, 276, 282 positive wrapped, 296
cocircuit, 14 Conway, J. H., 29
Cole, R., 295 Cook reducibility, 117
colorability, 284 Cook's Theorem, 134, 140
coloring, 111, 119 Cook, S., 112, 117, 134
communication bottleneck, 152 Cooley, J. M., 190
commutativity, 8, 29, 153 coset, 209, 210
companion matrix, 233, 264, 288 countable summation, 31
complete counting
binary tree, 291 problems, 138
graph, 71, 111, 232, 261 reduction, 139
complex cover
conjugate, 176 cycle, 142, 144, 233, 283, 284,
numbers, 176, 187, 215 286
complexity bad, 145
amortized, 40, 42, 58, 99 good, 145
asymptotic, 4 edge
class, 124, 125 minimal, 285
communication, 152 minimum, 232, 286
parallel, 152 exact, 125, 129, 133
composite, 201 pattern, 230, 276, 289
computation sequence, 134 term, 234, 289
concurrent vertex, 118, 125, 131, 140, 144,
read, 151 224, 232, 254, 255, 261, 286
write, 151 minimum, 286
conditional Cramer's rule, 172
expectation, 4, 192 CRCW, 151, 263
probability, 4, 192 credit invariant, 42, 61
configuration, 134 CREW, 151, 235, 262
congruent, 202 crew team, 128
conjugate, 176 cross edge, 22
transpose, 176, 215 Csanky's algorithm, 166-171, 178
conjunction, 113 Csanky, L., 166
conjunctive normal form, 111, 113, cut, 12, 14, 85
137, 257, 277 fundamental, 16
connected component, 11, 19, 74, maximum, 223
75, 78, 263, 272, 279, 284, minimum, 86, 100, 223
285 cycle, 11, 12, 14, 73, 79, 101
coNP,125 alternating, 101
-complete, 125, 226, 230, 234, cover, 142, 144, 233, 283, 284,
260,276 286
-hard, 125, 234, 289 bad, 145
conservation of flow, 84, 87 good, 145
312 INDEX

even, 298 distance, 25

fundamental, 16, 219, 239, 272 distributivity, 29, 137, 246
negative weight, 232, 274, 284 divide-and-conquer, 3, 38, 77, 189
odd, 119, 122, 227, 262, 298 division, 163
of a permutation, 279 dual
simple, 20, 101, 232, 262, 284 matroid, 13, 15, 16, 272
cyclic subgroup, 204 plane, 72, 74, 79, 231, 293
duality, 15
dag, 3, 9, 19, 108, 152, 227, 262 dynamic
Dantzig, G. B., 130 logie, 32
deadline, 230, 274 programming, 3
decision problem, 116, 139
decrennent, 40, 44, 99, 250 eager meld, 41
deficient set, 233 edge cover
minimal, 286 minimal, 285
degree, 211 minimum, 232, 286
total,212 Edmonds, J. R., 71, 92, 94-96, 98,
delete, 40, 44, 58, 65, 67, 69 287
deletennin, 40, 250 eigenspace, 174
DeMorgan's laws, 137,277 generalized, 174
dependent set, 13 eigenvalue, 4, 47,168,174,175
depth, 152 eigenvector, 47
depth-first dominant, 47
numbering, 19 elementary symmetrie polynomial,
search, 19,75,95,119,122,220, 169
242, 272, 284 ellipsoid method, 130
directed, 22 embedding
spanning tree, 19, 20 consistent, 220
det, see determinant outerplane, 234, 293
determinant, 4, 141, 166, 168, 179, plane, 71, 72,231,234,242,281
298 equational theory, 31
DFS, see depth-first search equivalence
diagonal matrix, 297 class, 21, 23, 172
Dijkstra's algorithm, 26, 44, 47, 93, relation, 20, 23
221, 223, 248, 250, 252 Eratosthenes
Dijkstra, E. W., 25 sieve of, 148
Dinie's algorithm, 96-98 ERCW, 151
Dinie, E. A., 96, 107 EREW, 151, 295
direct sum, 175 ERH, see extended Riemann hypoth-
directed DFS, 22 esis
discrete Fourier transform, see Fourier Euclidean
transform algorithm, 4, 149, 182, 185, 203
disjoint connecting paths, 225, 258 coordinates, 155
disjunction, 113 remainder sequence, 183
INDEX 313

space, 155 net, 85

Euler path, 92, 96, 97
characteristic, 74, 231 value, 86
circuit, 131, 219, 240, 258, 260 flume, 92
totient, 203 for loop, 50
Euler's theorem, 74, 76, 242 Ford, 1. R. Jr., 90, 254
evasive, 244 forest, 11, 14
exact cover, 125, 129, 133 formal power series, 172, 266
exclusive forward edge, 22
read, 151 four color theorem, 122
write, 151 Fourier transform, 186--190, 227, 266,
expectation, 4, 67, 192, 228, 268 267, 296
conditional, 4, 192 Fredman, M. L., 44
linearity of, 67-70, 192 free
expected edge, 101
time, 65, 67, 191, 228 vertex, 101, 286
value, 192 frond, 80
extended Riemann hypothesis, 202 Fulkerson, D. R., 90, 254
full rank, 182, 288
face, 72, 73, 242 functional composition, 189
factoring, 201 fundamental
factorization cut, 16
polynomial, 214 cycle, 16, 219, 239, 272
prime, 207, 208
Fermat's theorem, 202-204, 226 Gale, D., 254
FFT, see Fourier transform Garey, M. R., 112, 122, 133
Fibonacci Gaussian elimination, 141, 185
heap, 25, 40, 44-47, 61, 99, 250 gcd, see greatest common divisor
numbers, 46 generalized eigenspace, 174
sequence, 46, 167, 227 generating function, 227, 265
FIFO, 19 generator, 187
find, 48 golden ratio, 46
findmin, 40, 250 good
finite cycle cover, 145, 284
automaton, 28, 37 edge, 195, 197
field, 156, 171, 178, 199, 202, vertex, 195, 197, 270
212, 214, 215, 226, 233 Gray
flow, 84, 90, 223, 254 ordering, 155
across a cut, 85 representation, 154, 156, 232, 282
blocking, 96, 98 greatest common divisor, 4
conservation of, 84, 87 integer, 181
maximum, 84-100,152,252,255, polynomial, 179, 182-185
287 greedy algorithm, 11, 17, 25, 274
integral, 90, 287 ground term, 234, 289
314 INDEX

Hall's theorem, 224, 233, 255, 256, maximal, 13, 15, 191, 194, 219,
286 230, 239, 272, 274, 282
Hamiltonian induced subgraph, 191
circuit, 131, 133, 144, 155, 158, infimum, 38
260, 285 inner product, 166, 178
directed, 261 inorder, 58, 59, 65, 66
Hamming distance, 157 insert, 40, 58, 65-67
Hasse diagram, see transitive reduc- integer
tion addition, 160
heap arithmetic, 160
binomial, 40-44 division, 163
Fibonacci, 25, 40, 44-47, 61, 99 multiplication, 161
order, 41, 44, 65, 66 programming, 112, 116, 125, 130,
height, 53 133
Hermitian, 177 integral, 69
heuristic, 48, 49, 51, 52, 92-94, 104 maximum flow, 90, 287
homeomorphism, 72 interior
homomorphism point method, 130
group, 208 vertex, 84
Hopcroft, J. E., 78, 102, 107, 178, interpolation, 187
234, 286, 293 interpretation, 34
Huang, M.-D. A., 202 standard, 35
Hungarian tree, 108,233,286 invariant, 19, 26, 174, 248, 254
hypercube, 151, 154, 156 credit, 42, 61
invertible elements
Ibarra, 0., 171, 176 group of, 203, 283
idempotence, 29, 30 involution, 279
identity, 29 irreducible, 212
im, see image isolated vertex, 71, 232
image, 174, 215 isomorphism
inclusion-exclusion principle, 194, 196, algebra, 190, 297
270 field, 179
incremental weight, 103, 106 graph, 72, 75, 231
independence, 13, 152 group, 204, 209
3-wise,271 ring, 149, 204, 207-209
algebraic, 14 tree, 214
d-wise, 200, 229, 269 vector space, 175, 215
data, 151 Itai, A., 191
linear, 4, 14, 176
pairwise, 193, 196, 199, 271 Johnson, D. S., 112, 122, 133
statistical, 66, 192, 193, 201 join, 59
independent set, 13, 117, 118, 125, Jordan canonical form, 174, 175
230,274
k-clique, 113
INDEX 315

k-CNF, 118 equations, 181-182

k-CNFSat, 118 programming, 130
k-colorability, 111, 119, 121, 122, recurrence, 166-168
284 order k, 227, 263
k-conjunctive normal form, 118 link, 41
k-connected, 233, 287 linked list, 12, 41, 75, 231, 277
k-partite, 113 Lipton, R., 71, 77
Konig-Egervary theorem, 224, 255, literal, 113
256 log-cost RAM, 6
Karmarkar, N., 130 logical consequence, 35
Karp reducibility, 117 Lovasz, L., 213, 256
Karp, R. M., 92, 94-96, 98, 102, Luby's algorithm, 191-200,228,270
107, 112, 117, 191,286,287 Luby, M., 191
ker, see kernel
kernel, 174, 177,209,215,269 Maheshwari, S. N., 97
Khachian, L. G., 130 makeheap, 40
Kleene Malhotra, V. M., 97
*,30 many-one reducibility, 117
algebra, 28-39, 221, 245, 262, marriage
273 stable, 224, 254
free, 31, 32, 35 theorem, 255
matrix, 36, 38 Marzullo, K., 232
min,+, 33, 38, 273 matched
Kleene, S. C., 29 edge, 101
knapsack, 128, 129, 133 vertex, 101
Komlos, J., 295 matching, 100, 101, 106, 232, 255,
Kruskal's algorithm, 11, 48 260
Kruskal, J. B., 11 3-dimensional, 126
Kuratowski's Theorem, 72 bipartite, 100, 141, 144,213,224,
235,254
law of sum, 192 maximal, 102, 229, 270, 285
Lawler, E. L., 15, 256 maximum, 100, 102, 107, 255,
lazy meld, 42, 43 286
icm, see least common multiple partial, 254
least perfect, 101, 141, 142, 144,213,
common multiple, 184 224, 235, 255, 286, 299
upper bound, 30, 35, 38, 221, unweighted, 101
246, 247 weighted, 101
level, 78, 94 matrix
graph, 94-98, 287 adjacency, 3, 6, 26, 27, 38, 142,
Levin, L., 134 146,240,243,262,283,286
Lichtenstein, D., 122 bipartite, 141, 142, 144, 213,
LIFO, 19 244
linear block diagonal, 175, 264
316 INDEX

circulant, 235, 295-298 Miller, G., 201

companion, 233, 264, 288 MIMD,151
diagonal, 297 min,+ algebra, 33, 38, 273
Hermitian, 177 minimal
inversion, 167, 235 deficient set, 286
Kleene algebra, 36, 38 edge cover, 285
lower triangular, 167 minimum
multiplication, 7, 153, 166, 227, connectivity, 100
235, 262 cut, 86, 100, 223
permutation, 295 edge cover, 232, 286
polynomial, 170 spanning tree, 11, 13, 47, 48,
powering, 166, 262 222, 226, 260
random, 233, 288 vertex cover, 286
rank, 171, 173-180, 213, 215 minor, 179
Sylvester, 184, 185 modulus, 4
symmetric, 177, 179 monoid,30
Tutte,235 commutative, 30
Vandermonde, 187, 188,229,269 idempotent, 30
matroid, 13, 219, 230, 239, 250, 272 monotone, 63, 220, 244
dual, 272 Moran, S., 171, 176
duality, 15 MPM Algorithm, 97
rank, 239 MST, see minimum spanning tree
max flow-min cut theorem, 86, 88, Mulmuley's algorithm, 178-180, 215
90, 93, 252, 254, 255, 287 Mulmuley, K., 166, 171, 178
maximal multiple edges, 71, 231
clique, 282 multiplication, 161
independent set, 13, 191, 194, matrix, 166, 235
219, 230, 239, 272, 274, 282 multiset, 169
matching, 229, 270, 285
maximum NC, 152, 160, 166, 181, 213, 227,
cut, 223 234, 235, 262, 295
flow, 84-100, 152, 252, 255, 287 negative weight, 230, 273
integral, 90, 287 cycle, 232, 274, 284
matching, 255, 286 path, 232, 285
median, 294 net flow, 85
meld, 40 Newton's method, 163
eager, 41 Newton, 1., 163, 168
lazy, 42, 43 Nicolau, A., 295
member, 58 nonuniform, 178
membership test, 58, 65, 67 NP, 112, 124, 125, 134
Menger's theorem, 233, 286 -complete, 71, 111, 112, 124, 125,
META,232 128,219,223,225,226,230,
Micali, S., 107, 286 232,257,258,260,261,276,
Miller's algorithm, 201-210 284
INDEX 317

-hard, 125, 134, 257 perm, see permanent, 284

permanent, 141, 142, 144, 232, 286
odd cycle, 262 permutation, 67, 73, 141, 144, 278,
oracle, 117 298
orbit, 279 matrix, 295
order random, 67, 68, 70
Gray, 155 phase, 96, 98, 108
heap, 41, 44, 65, 66 Pippenger, No, 152
in-, 58, 59, 65, 66 planar
partial, 9, 23, 30 graph, 71-77, 121, 122, 234
post-, 23, 242 separator theorem, 77-83, 222
pre-, 23, 234, 292 planarity test, 234, 293
quasi-,23 plane
subterm, 63 dual, 72, 74, 79, 231, 293
total, 9, 58, 65, 119 embedding, 71, 72, 78, 234, 242,
ordered tree, 214 281
orientation, 72, 73 graph, 71-76, 231
outerplanar graph, 234, 293 Plummer, Mo Do, 256
outerplane pointer
embedding, 234, 293 doubling, 263, 292, 293
graph, 234 machine, 6, 51, 231
overhead, 9, 42 polylogarithmic, 152
pairwise independence, 196, 199,271 polynomial, 4, 14, 156, 211, 214,
Papadimitriou, Co Ho, 256, 260 233, 296, 299
parallel arithmetic, 178, 179
algorithms, 151 characteristic, 47,166-176,178,
machine models, 151 215, 233
prefix, 153, 156, 160, 167, 169, factorization, 214
262, 293 gcd, 182-185
parity, 158, 263 irreducible, 212
parsimonious, 139, 140, 231, 277 matrix, 170
partial symmetric, 169
matching, 254 postorder, 23, 242
order, 9, 23, 30 potential function, 42
partition, 77, 129, 130, 133, 232, power series, 172, 266
276, 282, 284 P,124
path Priifer, Ho, 243
compression, 49, 52 PRAM, 5, 151, 235, 262, 263, 295
flow, 92, 96, 97 Pramodh-Kumar, Mo, 97
pattern, 230, 276, 289 prefix products, 153
penalty, 230 preorder, 23, 234, 292
perfect matching, 101, 141, 142, 144, Prim's algorithm, 47, 222, 250
213, 224, 235, 255, 286, 299 primality test, 201-210
prime, 4, 199, 201
318 INDEX

factorization, 207, 208 search tree, 65

power, 207 treap,66
relatively, 187, 208 variable, 4, 192, 228, 268
primitive rank, 219
recursive function, 50 full, 182, 288
root of unity, 187, 297 in union-find, 53
principal root of unity, see primitive matrix, 171, 173-180, 213, 215
root of unity matroid, 239
priority, 65 tree, 41
random, 66 rational
probabilistic algorithms, 191 functions, 172, 179
probability, 65, 191, 201, 211, 229, numbers, 90, 130, 172
233, 299 real numbers, 33, 66, 84, 130, 177,
conditional, 4, 192 211
problem domain, 116 reciprocal, 163
PROLOG, 257 recurrence, 3, 7, 8, 27, 38, 68, 70,
propagate, 161 228, 265, 268, 282, 294, 295
propositional logic, 119, 137 linear, 167, 168
pseudoprime, 204 order k, 227, 263
Pugh, W., 65 red rule, 12, 14
reducibility
quadratic convergence, 164 Cook, 117
quasiorder, 23 Karp, 117
queue, 19 many-one, 117
quotient, 156, 163 relation, 117
construction, 23, 172 Turing, 117
graph, 24, 119 reduction, 111-121, 134, 139
Rabin, M. 0., 201 counting, 139
RAM parsimonious, 139, 140,231,277
log-cost, 6 reflexive transitive closure, 9, 23, 26-
unit-cost, 5, 6 28,38,262
random regular
access, 5, 51, 231, 294 expression, 29, 34, 35, 221, 246
machine, see RAM graph, 224
assignment, 299 bipartite, 255
bits, 198, 199 set, 29, 31, 34, 245
input, 211, 214 relation
matrix, 215, 233, 288 binary, 9, 30, 32
NC, 191, 213, 214, 229, 235 equivalence, 20, 23
number generator, 66, 191, 194, relatively prime, 187, 203, 208
198,201 remainder, 163
permutation, 67, 68, 70 residual
priority, 66 capacity, 86, 252
graph, 86, 88, 90, 98, 223, 252
INDEX 319

resolution, 119, 257 path, 92, 232

resultant, 183, 184 simplex method, 130
Riemann single-source shortest paths, 25
hypothesis, 202 sink, 84
zeta function, 202 size, 152
Rivest, R. L., 220 skew symmetry, 84, 87
RNC, see random NC skip list, 65
rook, 141, 142 Sleator, D., 58
root, 163, 212 sorting, 235, 294
of unity, 187, 267 bitonic, 295
primitive, 187, 297 source, 84
Rosenberg, A. L., 220 spanning
Rosier, L. E., 171, 176 forest, 239
rotate, 59, 65 tree, 250, 263
minimum, 260
s, t-connectivity, 223, 225 spanning tree, 11, 79, 80
s, t-cut, 85, 223, 254 depth-first, 19, 20
safe schedule, 274 minimum, 11, 13, 47, 222, 226
satisfiability, 111, 257 splay, 59
saturated, 85 splay tree, 58
partially, 99 split, 59
savings account, 42, 45, 61 square root of unity, 207
Schonhage, A., 201 weird, 207, 209
scheduling, 112, 230, 232, 274, 284 stable marriage, 224, 254
Schwartz, J. T., 211 stack, 19
scorpion, 220, 243 standard interpretation, 35, 221
search tree, 65 Steiglitz, K., 256, 260
Seidel, R. G., 65 Stockmeyer, L., 122
self-loop, 71 Strassen's algorithm, 7, 38, 227, 264
semiring Strassen, V., 201, 264
closed, 30 string, 35
idempotent, 30 strong component, see strongly con-
separator, 77-79, 82, 230, 235, 250, nected component
294 strongly connected
Shapley, L. S., 254 component, 23, 119, 284
Shiloach, Y., 263 graph, 23, 258, 261
shortest paths subset sum, 129, 130, 133
all-pairs, 27, 33, 38 substitution instance, 234, 291
single-source, 25 supremum, see least upper bound
sieve of Eratosthenes, 148 Sylvester matrix, 184, 185
SIMD,151 symmetric
similarity transformation, 175 difference, 102, 106
simple matrix, 177, 179
cycle, 20, 101, 232, 262, 284 polynomial, 169
320 INDEX

TSP, 226 union, 48

synthesizer generator, 233 union-find, 48-57, 275
Szemeredi, E., 295 unit
-cost RAM, 5, 6
Tarjan, R E., 12, 15, 44, 51, 58, 71, circle, 187
77, 78, 96, 234, 293 unordered tree, 214
Teitelbaum, R, 233 upper bound, 30, 247
telescoping sum, 62 least, 30, 35, 38, 221, 246, 247
term, 233
cover, 234, 289 Valiant, L. G., 139, 142, 146
ground, 234, 289 value
topological flow, 86
erase, 108 Vandermonde matrix, 187, 188, 229,
sort, 9, 10, 109, 119, 220, 227, 269
242, 262 Vazirani, V. V., 107, 286
total vector machine, 151
degree, 212 vertex cover, 118, 125, 131, 140, 144,
order, 9, 58, 65, 119 224, 232, 254, 255, 261, 286
totient, 203 Vishkin, U., 263
tr, see trace VLSI,71
trace, 168 von zur Gathen, J., 178
transcendental, 178 Vuillemin, J., 40, 220
extension, 179
transitive while loop, 51
closure, 219, 226, 240, 261, 262 widget, 123, 131, 144, 232, 283, 284
reduction, 219, 226, 240, 261 Wigderson, A., 191
transposition, 281 witness, 138
traveling salesman, 112, 116, 125, function, 138, 139
133, 225, 226, 258, 260 Yao, A. C., 244
treap, 65
tree edge, 19, 22 Zippel, R E., 211
triangle inequality, 226, 260
triangulation, 75, 80, 185, 293
TSP, see traveling salesman
Tukey, J. W., 190
Turing
machine, 116, 124, 134
oracle, 117
reducibility, 117
Tutte matrix, 235

uniform
circuit, 5, 152
distribution, 66, 200, 215
Texts and Monographs in Computer Science
(continued from page ii)

John V. Guttag and James J. Horning, Larch: Languages and Tools for Formal
Specification

Eric C.R. Hehner, A Practical Theory of Programming

Micha Hofri, Probabilistic Analysis of Algorithms

A.J. Kfoury, Robert N. Moll, and Michael A. Arbib, A Programming Approach to

Computability

Dexter C. Kozen, The Design and Analysis of Algorithms

E.V. Krishnamurthy, Error-Free Polynomial Matrix Computations

Ming Li and Paul Vitanyi, An Introduction to Kolmogorov Complexity

and Its Applications

David Luckham, Programming with Specifications: An Introduction to ANNA,

A Language for Specifying Ada Programs

Ernest G. Manes and Michael A. Arbib, Algebraic Approaches to Program Semantics

Bhubaneswar Mishra, Algorithmic Algebra

Robert N. Moll, Michael A. Arbib, and A.J. Kfoury, An Introduction to Formal

Language Theory

Anil Nerode and Richard A. Shore, Logic for Applications

Helmut A. Partsch, Specification and Transformation of Programs

Franco P. Preparata and Michael Ian Shamos, Computational Geometry:

An Introduction

Brian Randell, Ed., The Origins of Digital Computers: Selected Papers, 3rd Edition

Thomas W. Reps and Tim Teitelbaum, The Synthesizer Generator: A System for
Constructing Language-Based Editors

Thomas W. Reps and Tim Teitelbaum, The SyntheSizer Generator Reference Manual,
3rd Edition

Arto Salomaa and Matti Soittola, Automata-Theoretic Aspects of Formal Power

Series

J.T. Schwartz, R.B.K. Dewar, E. Dubinsky, and E. Schonberg, Programming with Sets:
An Introduction to SETL

Alan T. Sherman, VLSI Placement and Routing: The PI Project

Texts and Monographs in Computer Science
(continued)

Santosh K. Shrivastava, Ed., Reliable Computer Systems

Jan L.A. van de Snepscheut, What Computing Is All About

William M. Waite and Gerhard Goos, Compiler Construction

Niklaus Wirth, Programming in Modula-2, 4th Edition

Study Edition

Edward Cohen, Programming in the 1990s: An Introduction to the Calculation of

Programs