6.2 Polynomial Time Algorithms
6.2.1 Bipartite Permutation
We now provide an efficient algorithm for the maximum weight cross-free matching of bipartite permutation graphs.
Recall that permutation graphs admit a rook representation induced by a permu- tation π: the vertex i of the graph is mapped to the point (i, π(i)). In particular, when the graph is bipartite, the previous representation is a bicolored rook represen- tation (A, B) where all the points of A (resp. of B) form an antichain for ≤R2. In what follows assume that G = (A, B, R) is given to us in the way we just described. We can solve the maximum weight independent set of R in O(n2) time using the
fact that the complement of the intersection graph I(R) is a comparability graph. To see this, let us write R & S if R and S are disjoint and either Rx < Sx or Ry > Sy
holds, where we use the notation Px< Qx as shortcut for px < qx for all p ∈ P, q ∈ Q.
It is not hard to verify that D = (R, &) is a partial order whose comparability graph is the complement of I(R), and that maximum weight cross-free matchings in G correspond to maximum weight paths in the digraph D, using w as a weight function on the vertex set R. Since D has |R| vertices and O(|R|2) arcs this optimal
path Q∗ can be found in O(|R|2) time (see, e.g. [38]).
We can find the optimal path Q∗ faster by exploiting the structure of D. For simplicity, assume first that all the weights are different.
Let R & S & T be three consecutive rectangles in the optimal path Q∗, then we can extract information about the rectangle S. The following properties are easy to verify.
Right-Right Case. If Rx < Sx and Sx < Tx, then
(i) Among all the rectangles located completely to the right of R and having the same top-right corner tr(S), S is the heaviest.
Right-Down Case. If Rx < Sx and Sy > Ty, then
(ii) Among all the rectangles having the same bottom-left corner bl(S), S is the heaviest.
Down-Right Case. If Ry > Sy and Sx < Tx, then
(iii) Among all the rectangles having the same top-right corner tr(S), S is the heaviest.
Down-Down Case. If Ry > Sy and Sy > Ty, then
(iv) Among all the rectangles located completely below R and having the same bottom-left corner bl(S), S is the heaviest.
See Figure 6-1 for examples of each case.
The previous properties motivate the following recursion.
Define T (v) for v ∈ A ∪ B as the rectangle of maximum weight (if any) having a corner in v. Also, define T (b, b0), for b, b0 ∈ B, to be the rectangle (if any) of maximum weight being both strictly to the right of the vertical line passing through b and having top-right corner b0. Similarly, define T (a, a0), for a, a0 ∈ A to be the rectangle (if any) of maximum weight being strictly below the horizontal line passing through a and having bottom-left corner a0.
For R ∈ R, let V→(R) (resp. V↓(R)) be the maximum weight of a path in D starting
R S T (a) Right-Right R S T (b) Right-Down R S T (c) Down-Right R S T (d) Down-Down
Figure 6-1: Three consecutive rectangles in Q∗.
below R). Using properties (i)–(iv), we conclude that:
V (R) = max{V→(R), V↓(R)}
V→(Γ(a, b)) = w(Γ(a, b)) + max
max b0: b0 x>bx V→(T (b, b0)), max a0: a0 x>bx V↓(T (a0)) . V↓(Γ(a, b)) = w(Γ(a, b)) + max
( max a0: a0 y<ay V↓(T (a, a0)), max b0: b0 y<ay V→(T (b0)) ) .
Claim 2. We can compute the entire set of values above in O(n2).
To prove this claim, note that {T (a)}a∈Aand {T (b)}b∈B can be computed in time
O(|R|) = O(n2). Also, by visiting the points a0 in A from bottom to top, we can
find T (a, a0) for each a ∈ A in time O(|A|) = O(n). This means that the entire table {T (a, a0)}
a,a0∈A can be computed in O(n2)-time and so can the table {T (b, b0)}b,b0∈B. Using those values, compute the quantities:
S(b) = max b0: b0x>b x V→(T (b, b0)). S0(b) = max a0: a0 x>bx V↓(T (a0)). S(a) = max a0: a0 y<ay
V↓(T (a, a0)). S0(a) = max
b0: b0y<a
y
V→(T (b0)).
the maximum of at most n known values, the entire tables S(·) and S0(·) can be computed in O(n2) time.
After precomputing all the previous values, it takes constant time to output each entry of the tables V (·), V→(·), and V↓(·). As there are 3|R| = O(n2) of these values,
we conclude the proof of the claim.
After computing {V (R)}R∈R, we can easily obtain the weight of the optimal path
Q∗ as the maximum over all these values. It is also very simple to recover the actual path Q∗ from the tables using the recurrences above.
Theorem 6.2.1. By using the dynamic algorithm described above, we can compute
the maximum weight cross-free matching of a bipartite permutation graph in O(n2)
time.
6.2.2
Convex Graphs
By the discussion in Section 4.3.3 and especially by the proof of Theorem 4.3.7, cross- free matchings of convex graphs correspond to independent sets of a certain system of point-interval pairs. Lubiw [110] gives a polynomial time algorithm for the maximum weight independent set of a system of point-interval pairs. It is straightforward to implement her algorithm in O(n3) time.
We describe her algorithm in our terminology. Let G be a convex graph on A ∪ B with labeling A = {a1, . . . , ak}, where the neighborhood of b ∈ B is {a`(b), . . . , ar(b)}.
We see G as an interval bigraph using Iai = {i} and Ib = [`(b), r(b)]. Let G =
(A, B, R) where (A, B) is the natural bicolored representation for interval bigraphs described in Section 3.4.5. This representation puts the points A∪B on the triangular grid U ≡ {(i, −j) ∈ Z2: 0 ≤ j ≤ i ≤ |A|} with the points of A lying in the line
y = −x.
Since we are looking for a maximum weight independent set of rectangles, we can assume that no two rectangles in R are equal geometrically. If this is the case, only keep the one having maximum weight.
Given two disjoint rectangles R and S in R, let us say that R precedes S if either
Rx < Sx and Ry ∩ Sy 6= ∅ or if Ry < Sy and Rx∩ Sx 6= ∅. It can be shown that this
relation is acyclic; therefore, the maximum weight independent set R∗ must contain a
rectangle T that no one precedes. The algorithm finds R∗by guessing this rectangle T and then recursively finding the maximum weighted independent set of the rectangles lying strictly below T and the rectangles lying strictly to the left of T .
More precisely, for each point q in the grid U let V (q) be the weight of a maximum independent set using only rectangles R ∈ R having bottom-left corner a ≤R2 q and top-right corner b ≤R2 q. It is easy to check that
V (q) = max
a∈A : a≤R2q{w(a, q) + V (ax− 1, qy) + V (qx, ay − 1)}.
where w(a, q) is the weight of a maximum weight rectangle T contained in Γ(a, q) or 0 if there is no such rectangle. See Figure 6-2.
a q (ax− 1, qy) (qx, ay− 1) T y =−x
Figure 6-2: Example of Lubiw’s algorithm. V (q) equals the weight of rectangle T plus the weight of the maximum independent set in both shaded regions.
All values {w(a, q)}a∈A,q∈U can be precomputed in time O(|A| · |U |) = O(n3).
Once we know those values, we can also find all the values of V (q) in time O(|A| · |U |) = O(n3) by dynamic programming. Finally, once {V (q)}
q∈U is known, the value
V (|A|, 0) holds the weight of the maximum independent set. As usual, we can recover
the object achieving the maximum from the tables of values defined above.
Theorem 6.2.2 (Based on Lubiw’s algorithm [110]). By using the dynamic algorithm
described above, we can compute the maximum weight cross-free matching of a convex graph in O(n3) time.
6.3
Open Problems
We have shown that the weighted cross-free matching is NP-complete for 2dorgs and polynomially solvable for convex graphs. The most relevant open problem of this chapter is the complexity of the weighted cross-free matching of interval bigraphs.
Part III
Constrained Set Function
Minimization
Chapter 7
Set Function Minimization under
Hereditary Constraints
In this chapter we present an efficient algorithm to find nonempty minimizers of certain functions over any family of sets closed under inclusion. The function classes we consider include symmetric submodular functions. Our algorithm makes O(n3)
oracle calls to the submodular function where n is the cardinality of the ground set. In contrast, the problem of minimizing a general submodular function under a cardinality constraint is known to be inapproximable within a factor of oqn/ log n [159].
The results of this chapter are joint work with Michel Goemans. This chapter is organized as follows. First, we offer an introduction to the problem and some back- ground on previous work. Later, we explore the unconstrained problem of finding a nontrivial minimizer of a set function. For the specific case of symmetric submod- ular functions, this problem can be efficiently solved by a pendant pair technique consolidated by Queyranne [141]; and Nagamochi and Ibaraki [127]. This technique finds a collection of at most n candidate sets, containing a minimizer of the problem. Later in the chapter, we define other classes of functions for which the pendant pair technique can also be used.
Afterwards, we move to the problem of minimizing set functions under hereditary constraints. We show how to modify the pendant pair technique in such a way that the candidate sets are always inside the hereditary family, and that at least one minimizer of the problem is declared as a candidate. By using ideas of Nagamochi and Ibaraki [127] we modify our algorithm so that it outputs all the inclusion-wise minimal minimizers of the problem.
After the completion of this work, we were informed of an independently discovered algorithm of Nagamochi [124] which is able to perform a stronger feat for certain classes of functions, including symmetric submodular functions. In the last part of this chapter we compare our results.
7.1
Introduction
Let V be a finite ground set of size n. A set function on V is a real valued function defined on all the subsets of V . A pair (V, f ) where f is a set function on V is called a (set function) system. In this work we assume that the set function f is given through a value oracle, this is an oracle that given a set S returns f (S).
A submodular function f is a set function on V , satisfying that for every pair of sets A and B,
f (A ∪ B) + f (A ∩ B) ≤ f (A) + f (B). (7.1)
Examples of submodular functions include weight functions, the cut function of a nonnegatively weighted graph and the entropy of a set of random variables. These functions have applications in many areas, including game theory, information the- ory and graph theory. Many important combinatorial optimization problems can be formulated as finding a minimizer of a submodular function. For this reason the following is considered a fundamental problem of the field.
Problem 17 (Submodular Function Minimization). Given a submodular function
f : 2V →R, find a subset X∗ ⊆ V that minimizes f (X∗).
Grötschel, Lovász and Schrijver [75, 76] show that the submodular function min- imization problem can be solved using the ellipsoid method in strongly polyno- mial time and using a polynomial number of oracle calls. Later, a collection of combinatorial strongly polynomial algorithms have been developed by several au- thors [57, 89, 88, 134, 146, 91]. The current fastest combinatorial algorithms known, due to Iwata and Orlin [91] and Orlin [134] make O(n5log n) and O(n5) function
oracle calls respectively, and run in O(n6log n) and O(n6) time respectively, where n is the size of the ground set.
There are faster algorithms available when the function f has more structure. The case where f is symmetric is of special interest. In this case, we also require the minimizer A∗ of f to be a nontrivial subset of V , that is ∅ ⊂ A∗ ⊂ V , otherwise the problem becomes trivial since, by symmetry and submodularity, f (∅) = 12(f (∅) +
f (V )) ≤ 12(f (A) + f (V \ A)) = f (A), for all A ⊆ V .
The canonical example of a symmetric submodular function is the cut function of a nonnegatively weighted graph. Finding a nontrivial minimizer corresponds in this case to the minimum cut problem. Nagamochi and Ibaraki [125, 126] give a combinatorial algorithm to solve this problem without relying on network flows. This algorithm has been improved and simplified independently by Stoer and Wagner [158] and Frank [61]. Queyranne [141] generalizes this and obtains a purely combinatorial algorithm that minimizes a symmetric submodular function using only O(n3) function oracle calls.
It is worth noting that if we impose simple additional constraints, minimizing general submodular functions becomes intractable. For example, the problem of min- imizing a submodular function over all the sets of cardinality at most k is NP-hard to approximate within an oqn/ log nfactor, as shown by Svitkina and Fleischer [159].
In this work we show that this is not the case for symmetric submodular func- tions. In Section 7.3 we extend Queyranne’s algorithm so that it returns a nontrivial minimizer of any hereditary family, this is, a family that it is closed under inclusion. In other words, the new algorithm solves the following problem.
Problem 18 (Hereditary Symmetric Submodular Function Minimization). Given a
symmetric submodular function f : 2V →R, and an hereditary family I ⊆ 2V, find
a nonempty subset X∗ ∈ I that minimizes f (X∗).
Common examples of hereditary families include
• Cardinality families: For k ≥ 0, the family of all subsets with at most k elements: I = {A ⊆ V : |A| ≤ k}.
• Knapsack families: Given a weight function w : V →R+, consider the family
of all subsets of weight at most one unit: I = {A ⊆ V : P
v∈Aw(v) ≤ 1}.
• Matroid families: Given a matroid M over V , consider the family of inde- pendent sets of M.
• Hereditary graph families: Given a graph G = (V, E), consider the fam- ily of sets S of vertices such that the induced subgraph G[S] satisfies certain hereditary property such as being a clique, being triangle-free, being planar or exclude a given list of minors.
• Matching families: Given a hypergraph H = (V, E), consider the family of matchings of H, that is sets of edges that are pairwise disjoint.
Since the intersection of hereditary families is hereditary, the hereditary minimization problem is very broad. This problem includes the following examples.
1. Find a minimum unbalanced cut in a graph; that is for given k, find among all nonempty sets of at most k vertices, the one inducing the minimum cut. 2. More generally, given a nonnegatively weighted graph, find a nonempty induced
subgraph satisfying an hereditary graph property (e.g. triangle-free, clique, stable-set, planar) minimizing the weights of the edges having precisely one endpoint in the subgraph.
For the unrestricted problem (equivalently for the case where I = 2V \ {V }),
Nagamochi and Ibaraki [127] present a modification of Queyranne’s algorithm that finds all inclusion-wise minimal minimizers of a symmetric submodular function while still using a cubic number of oracle calls. Using similar ideas, we can also list all minimal solutions of an hereditary minimization problem.
The algorithms we present are not restricted to work on symmetric submodular functions. In Section 7.4 we explore other function classes where our methods can still be applied. For instance, we can solve the hereditary problem for functions f that are restrictions of a symmetric submodular function (also known as submodular-
posimodular functions) or when f (A) is defined as d(A, V \ A) for a monotone and
Other related work. Constrained submodular function minimization problems, i.e. the minimization of a submodular function over subfamilies of 2V, have been
studied in different contexts. Padberg and Rao [138] show that the minimum odd cut problem obtained by restricting the minimization over all odd sets can be solved in polynomial time. This was generalized to submodular functions over larger families of sets (satisfying certain axioms) by Grötschel, Lovász and Schrijver [76] and by Goemans and Ramakrishnan [73]. This covers for example the minimization over all even sets, or all sets not belonging to a given antichain, or all sets excluding all minimizers (i.e. to find the second minimum). For the particular case of minimizing a
symmetric submodular function under cardinality constraints the best previous result
is a 2-approximation algorithm by Shaddin Dughmi [46]. Recently, Goel et al. [71] have studied the minimization of monotone submodular functions constrained to sets satisfying combinatorial structures on graphs, such as vertex covers, shortest paths, perfect matchings and spanning trees, giving inapproximability results and almost matching approximation algorithms for them. Independently, Iwata and Nagano [90] study both the vertex and the edge covering version of this problem.
The algorithm of Nagamochi and Ibaraki [127] also works with functions satisfy- ing a less restrictive symmetry condition. Narayanan [130] shows that Queyranne’s algorithm can be used to minimize a wider class of submodular functions, namely functions that are contractions or restrictions of symmetric submodular functions. Rizzi [145] has given further extension for a different class of functions.
Nagamochi [124] has recently given an algorithm to find all extreme sets of a symmetric submodular function, where a set is called extreme if its function value is strictly smaller than any one of its nontrivial subsets. As we show in Section 7.5, this algorithm can also be used to solve the hereditary minimization problem.