Cardinality Matching Research Articles

Balanced network flows. VIII. A revised theory of phase‐ordered algorithms and the O( $\bf\it\sqrt{n}m$ log(n2/m)/log n) bound for the nonbipartite cardinality matching problem

AbstractThis paper closes some gaps in the discussion of nonweighted balanced network flow problems. These gaps all concern the phase‐ordered augmentation algorithm, which can be viewed as the matching counterpart of the Dinic max‐flow algorithm. We show that this algorithm runs in O(n2m) time compared to the bound of O(nm2) derived in Part III of this series and that the bipartiteness requirement can be omitted. The result which deserves attention is the complexity bound for the cardinality matching problem which was shown for the bipartite case by Feder and Motwani. This bound was previously claimed for the general case in a preprint of Goldberg and Karzanov but omitted in later versions of this paper. © 2003 Wiley Periodicals, Inc.

Exact Expectations and Distributions for the Random Assignment Problem

A generalization of the random assignment problem asks the expected cost of the minimum-cost matching of cardinality k in a complete bipartite graph Km,n, with independent random edge weights. With weights drawn from the exponential distribution with intensity 1, the answer has been conjectured to beΣi,j≥0, i+j<k1/(m−i)(n−j).Here, we prove the conjecture for k [les ] 4, k = m = 5, and k = m = n = 6, using a structured, automated proof technique that results in proofs with relatively few cases. The method yields not only the minimum assignment cost's expectation but the Laplace transform of its distribution as well. From the Laplace transform we compute the variance in these cases, and conjecture that, with k = m = n → ∞, the variance is 2/n + O(log n/n2). We also include some asymptotic properties of the expectation and variance when k is fixed.

AN IMPROVED PARALLEL ALGORITHM FOR A GEOMETRIC MATCHING PROBLEM WITH APPLICATION TO TRAPEZOID GRAPHS

Let B be a set of n b blue points and R a set of nrred points in the plane, where nb + nr = n. A blue point b and a red point r can be matched if r dominates b, that is, if x(b) ≤ x(r) and y( b) ≤ y(r). We consider the problem of finding a maximum cardinality matching between the points in B and the points in R. We give an adaptive parallel algorithm to solve this problem that runs in O(log2n) time using the CREW PRAM with O(n2+ε/log n) processors for some ε,0 < ε < 1.It follows that finding the minimum number of colors to color a trapezoid graph can be solved within these resource bounds

A Decomposition Theorem for Maximum Weight Bipartite Matchings

Let G be a bipartite graph with positive integer weights on the edges and without isolated nodes. Let n, N, and W be the node count, the largest edge weight, and the total weight of G. Let k(x, y) be log x / log (x2/y). We present a new decomposition theorem for maximum weight bipartite matchings and use it to design an $O(\sqrt{n}W / k(n, W/N))$-time algorithm for computing a maximum weight matching of G. This algorithm bridges a long-standing gap between the best known time complexity of computing a maximum weight matching and that of computing a maximum cardinality matching. Given G and a maximum weight matching of G, we can further compute the weight of a maximum weight matching of G - {u} for all nodes u in O(W) time.

Parallel Algorithms for Maximum Matching in Complements of Interval Graphs and Related Problems

Given a set of n intervals representing an interval graph, the problem of finding a maximum matching between pairs of disjoint (nonintersecting) intervals has been considered in the sequential model. In this paper we present parallel algorithms for computing maximum cardinality matchings among pairs of disjoint intervals in interval graphs in the EREW PRAM and hypercube models. For the general case of the problem, our algorithms compute a maximum matching in O( log 3 n) time using O(n/ log 2 n) processors on the EREW PRAM and using n processors on the hypercubes. For the case of proper interval graphs, our algorithm runs in O( log n ) time using O(n) processors if the input intervals are not given already sorted and using O(n/ log n ) processors otherwise, on the EREW PRAM. On n -processor hypercubes, our algorithm for the proper interval case takes O( log n log log n ) time for unsorted input and O( log n ) time for sorted input. Our parallel results also lead to optimal sequential algorithms for computing maximum matchings among disjoint intervals. In addition, we present an improved parallel algorithm for maximum matching between overlapping intervals in proper interval graphs.

Balanced network flows. III. Strongly polynomial augmentation algorithms

We discuss efficient augmentation algorithms for the maximum balanced flow problem which run in O(nm2) time. More explicitly, we discuss a balanced network search procedure which finds valid augmenting paths of minimum length in linear time. The algorithms are based on the famous cardinality matching algorithm given by Micali and Vazirani. A comprehensive description of the double depth first search is included. © 1999 John Wiley & Sons, Inc. Networks 33: 43–56, 1999

Balanced network flows. I. A unifying framework for design and analysis of matching algorithms

We discuss a wide range of matching problems in terms of a network flow model. More than this, we start up a matching theory which is very intuitive and independent from the original graph context. This first paper contains a standardized theory for the performance analysis of augmentation algorithms in a wide area of matching problems. Several optimality criteria are given which do not use cuts or barriers. As an application of our theory, the known cardinality matching algorithms of Edmonds, Kameda and Munro, and Micali and Vazirani, and the algorithm of Kocay and Stone for capacitated matching problems can be studied in their effects. From our theory a c-capacitated b-matching algorithm can be derived that behaves like the Dinic algorithm for the maximum flow problem. It will turn out that techniques for the maximum flow problem can be applied to matching problems much more explicitly than done before. A comprehensive duality theory depending on the network flow model used here will follow. Explicit algorithms for nonweighted problems will be presented in subsequent papers. © 1999 John Wiley & Sons, Inc. Networks 33: 1–28, 1999

Resource Constrained Chain Scheduling of UET Jobs on Two Machines

A well-known technique for solving scheduling problems with two identical parallel processors and unit execution time jobs under a makespan minimization criteria involves finding maximum cardinality matchings in the graph associated with the problem, and then using these matchings to create optimal schedules. For some problem instances, however, this method will not work, since the problems are NP-hard. In this note, a previously open problem involving additional resource constraints is shown to have a polynomial algorithm using cardinality matching method.

Maximum vertex-weighted matching in strongly chordal graphs

Given a graph G = ( V, E) and a real weight for each vertex of G, the vertex-weight of a matching is defined to be the sum of the weights of the vertices covered by the matching. In this paper we present a linear time algorithm for finding a maximum vertex-weighted matching in a strongly chordal graph, given a strong elimination ordering. The algorithm can be specialized to find a maximum cardinality matching, yielding an algorithm similar to one proposed earlier by Dahlhaus and Karpinsky. The technique does not seem to apply to the case of general edge-weighted matchings.

Average-Case Analysis of Dynamic Graph Algorithms

We present a model for edge updates with restricted randomness in dynamic graph algorithms and a general technique for analyzing the expected running time of an update operation. This model is able to capture the average case in many applications, since (1) it allows restrictions on the set of edges which can be used for insertions and (2) the type (insertion or deletion) of each update operation is arbitrary, i.e., not random. We use our technique to analyze existing and new dynamic algorithms for the following problems: maximum cardinality matching, minimum spanning forest, connectivity, 2-edge connectivity, k -edge connectivity, k -vertex connectivity, and bipartiteness. Given a random graph G with m 0 edges and n vertices and a sequence of l update operations such that the graph contains m i edges after operation i , the expected time for performing the updates for any l is $O(l log n + \sum_{i=1}^{l} n/\sqrt m_i)$ in the case of minimum spanning forests, connectivity, 2-edge connectivity, and bipartiteness. The expected time per update operation is O(n) in the case of maximum matching. We also give improved bounds for k -edge and k -vertex connectivity. Additionally we give an insertions-only algorithm for maximum cardinality matching with worst-case O(n) amortized time per insertion.

Solution methods and computational investigations for the Linear Bottleneck Assignment Problem

The Linear Bottleneck Assignment ProblemLBAP is analyzed from a computational point of view. Beside a brief review of known algorithms new methods are developed using only sparse subgraphs for their computation. The practical behaviour of both types of algorithms is investigated. The most promising algorithm consists of computing a maximum cardinality matching with all edge costs smaller than a previously determined bound and augmenting this matching to an assignment. The methods on sparse subgraphs are useful in the case of memory restrictions and are superior if the subgraph selection can be improved by some previously generated structure. Other treated questions are how to select a suitable subgraph for the new methods, how to deal with non regular data and what connections to asymptotic results for theLBAP can be detected.

Matchings, covers, and Jacobian matrices

Abstract It is well-known that the nonsingularity of the Jacobian matrix is a necessary and sufficient condition for the local uniqueness of the solution of a system of equations. A necessary condition for this nonsingularity is the existence of a normalization of the equations. If the Jacobian matrix is large and sparse, as it is, for instance, for macroeconometric models, the verification of this necessary condition is not immediate. The paper shows how this problem can be efficiently investigated by means of a graph-theoretic approach. In particular, this is done by seeking a maximum cardinality matching in a bipartite graph. The case where a normalization does not exist often constitutes a heavy challenge to the model builder and is a situation which, again, is analyzed using properties connecting covers to matchings in bipartite graphs. The whole approach is qualitative, and this not obvious condition can be checked prior to the quantification of the model, i.e., at the stage of the theoretical formulation of the model where numerical method cannot yet been used.

Approximate Max-Flow on Small Depth Networks

We consider the maximum flow problem on directed acyclic networks with $m$ edges and depth $r$ (length of the longest $s$-$t$ path). Our main result is a new deterministic algorithm for solving the relaxed problem of computing an $s$-$t$ flow of value at least $(1-\epsilon)$ of the maximum flow. For instances where $r$ and $\epsilon^{-1}$ are small (i.e., $O(\polylog(m))$), this algorithm is in $\NC$ and uses only $O(m)$ processors, which is a significant improvement over existing parallel algorithms. As one consequence, we obtain an $\NC$ $O(m)$ processor algorithm to find a bipartite matching of cardinality $(1-\epsilon)$ of the maximum (for $\epsilon^{-1}= O(\polylog(m))$). We use a novel approach based on path-counts to compute blocking flows in parallel. This approach produces fractional flow even when capacities are integral. To encounter that, we provide a rounding algorithm that is of independent interest. In polylogarithmic time using $O(m)$ processors, the algorithm rounds any fractional flow on a network with integral capacities to an integral flow. The rounding technique extends to networks with costs.

Synthesis for path delay fault testability via tautology-based untestability identification and factorization

An area efficient synthesis procedure targeting complete robust path delay fault testability (RPDFT) of scan-based circuits is described. It includes an efficient untestability identification algorithm for two-level and multilevel circuits. The implementation of the algorithm uses tautology checking instead of test pattern generation (TPG) resulting in a speed-up factor of 5 in comparison to today's fastest TPG methods. Exploiting that untestability identification capability, factorization is improved to first combining only those product terms in which the same literal is untestable and checking whether this eliminates the untestable fault. If not, cardinality matching is used to add the best-suited term that removes the untestable fault. Our method has been found to give better results in terms of RPDFT and area than reported before. In contrast to previously published papers, we found that technology mapping using tree covering does not always preserve RPDFT.

PARALLEL APPROXIMATE MATCHING

Determining the parallel complexity of maximum cardinality matching in bipartite graphs is one of the most famous open problems in parallel algorithm design. The problem is known to be in RNC, but all known fast (polylogarithmic running time) parallel algorithms that find maximum cardinality matchings require the use of random numbers. Moreover, they are based on matrix algebra, so they are inherently inefficient for sparse graphs. Therefore, we are interested in the problem of finding an approximate maximum cardinality matching. The parallel matching algorithm of Goldberg, Plotkin and Vaidya (FOCS 1988) can be modified so that it runs in O(a2log3n) time on an EREW PRAM with n + m processors and finds a matching of size (1 - 1/a)p when given a graph with n vertices, m edges, and a maximum cardinality matching of size p. The resulting algorithm is deterministic.

Efficient labelling algorithms for the maximum noncrossing matching problem

Consider a bipartite graph; let's suppose we draw the origin nodes and the destination nodes arranged in two columns, and the edges as straight-line segments. A noncrossing matching is a subset of edges such that no two of them intersect. Several algorithms for the problem of finding the noncrossing matching of maximum cardinality are proposed. Moreover an extension to weighted graphs is considered.

Solving the Euclidean bottleneck matching problem byk-relative neighborhood graphs

Given a set of pointsV in the plane, the Euclidean bottleneck matching problem is to match each point with some other point such that the longest Euclidean distance between matched points, resulting from this matching, is minimized. To solve this problem, we definek-relative neighborhood graphs, (kRNG) which are derived from Toussaint's relative neighborhood graphs (RNG). Two points are calledk-relative neighbors if and only if there are less thank points ofV which are closer to both of the two points than the two points are to each other. AkRNG is an undirected graph (V,E r k) whereE r k is the set of pairs of points ofV which arek-relative neighbors. We prove that there exists an optimal solution of the Euclidean bottleneck matching problem which is a subset ofE r 17. We also prove that ¦E r k¦ < 18kn wheren is the number of points in setV. Our algorithm would construct a 17RNG first. This takesO(n2) time. We then use Gabow and Tarjan's bottleneck maximum cardinality matching algorithm for general graphs whose time-complexity isO((n logn)0.5m), wherem is the number of edges in the graph, to solve the bottleneck maximum cardinality matching problem in the 17RNG. This takesO(n1.5 log0.5n) time. The total time-complexity of our algorithm for the Euclidean bottleneck matching problem isO(n2 +n1.5 log0.5n).

Using Interior-Point Methods for Fast Parallel Algorithms for Bipartite Matching and Related Problems

In this paper interior-point methods for linear programming, developed in the context of sequential computation, are used to obtain a parallel algorithm for the bipartite matching problem. This algorithm finds a maximum cardinality matching in a bipartite graph with n nodes and m edges in $O(\sqrt m \log ^3 n)$ time on a CRCW PRAM. The results here extend to the weighted bipartite matching problem and to the zero-one minimum-cost flow problem, yielding $O(\sqrt m \log ^2 n\log nC)$ algorithms, where $C > 1$ is an upper bound on the absolute value of the integral weights or costs in the two problems, respectively. The results here improve previous bounds on these problems and introduce interior-point methods to the context of parallel algorithm design.

The uniquely solvable bipartite matching problem

The bipartite cardinality matching problem can be solved by a well-known algorithm with complexity O(| E | · | V | 1 2 ) . We give a characterization of the bipartite graphs with a unique maximum matching and an O(| E |) algorithm for both recognizing these graphs and producing the unique matching, when it exists.

Computing a maximum cardinality matching in a bipartite graph in time O( n1.5[formula omitted

We show how to compute a maximum cardinality matching in a bipartite graph of n vertices in time O( n 1.5 m log n ). For dense graphs this improves on the O( n m) algorithm of Hopcroft and Karp. The speed-up is obtained by an application of the fast adjacency matrix scanning technique of Cheriyan, Hagerup and Mehlhorn.