127 research outputs found

    On Adaptive Algorithms for Maximum Matching

    Get PDF
    In the fundamental Maximum Matching problem the task is to find a maximum cardinality set of pairwise disjoint edges in a given undirected graph. The fastest algorithm for this problem, due to Micali and Vazirani, runs in time O(sqrt{n}m) and stands unbeaten since 1980. It is complemented by faster, often linear-time, algorithms for various special graph classes. Moreover, there are fast parameterized algorithms, e.g., time O(km log n) relative to tree-width k, which outperform O(sqrt{n}m) when the parameter is sufficiently small. We show that the Micali-Vazirani algorithm, and in fact any algorithm following the phase framework of Hopcroft and Karp, is adaptive to beneficial input structure. We exhibit several graph classes for which such algorithms run in linear time O(n+m). More strongly, we show that they run in time O(sqrt{k}m) for graphs that are k vertex deletions away from any of several such classes, without explicitly computing an optimal or approximate deletion set; before, most such bounds were at least Omega(km). Thus, any phase-based matching algorithm with linear-time phases obliviously interpolates between linear time for k=O(1) and the worst case of O(sqrt{n}m) when k=Theta(n). We complement our findings by proving that the phase framework by itself still allows Omega(sqrt{n}) phases, and hence time Omega(sqrt{n}m), even on paths, cographs, and bipartite chain graphs

    A Weighted Approach to the Maximum Cardinality Bipartite Matching Problem with Applications in Geometric Settings

    Get PDF
    We present a weighted approach to compute a maximum cardinality matching in an arbitrary bipartite graph. Our main result is a new algorithm that takes as input a weighted bipartite graph G(A cup B,E) with edge weights of 0 or 1. Let w <= n be an upper bound on the weight of any matching in G. Consider the subgraph induced by all the edges of G with a weight 0. Suppose every connected component in this subgraph has O(r) vertices and O(mr/n) edges. We present an algorithm to compute a maximum cardinality matching in G in O~(m(sqrt{w} + sqrt{r} + wr/n)) time. When all the edge weights are 1 (symmetrically when all weights are 0), our algorithm will be identical to the well-known Hopcroft-Karp (HK) algorithm, which runs in O(m sqrt{n}) time. However, if we can carefully assign weights of 0 and 1 on its edges such that both w and r are sub-linear in n and wr=O(n^{gamma}) for gamma < 3/2, then we can compute maximum cardinality matching in G in o(m sqrt{n}) time. Using our algorithm, we obtain a new O~(n^{4/3}/epsilon^4) time algorithm to compute an epsilon-approximate bottleneck matching of A,B subsetR^2 and an 1/(epsilon^{O(d)}}n^{1+(d-1)/(2d-1)}) poly log n time algorithm for computing epsilon-approximate bottleneck matching in d-dimensions. All previous algorithms take Omega(n^{3/2}) time. Given any graph G(A cup B,E) that has an easily computable balanced vertex separator for every subgraph G\u27(V\u27,E\u27) of size |V\u27|^{delta}, for delta in [1/2,1), we can apply our algorithm to compute a maximum matching in O~(mn^{delta/1+delta}) time improving upon the O(m sqrt{n}) time taken by the HK-Algorithm

    Faster Algorithms for Semi-Matching Problems

    Full text link
    We consider the problem of finding \textit{semi-matching} in bipartite graphs which is also extensively studied under various names in the scheduling literature. We give faster algorithms for both weighted and unweighted case. For the weighted case, we give an O(nmlogn)O(nm\log n)-time algorithm, where nn is the number of vertices and mm is the number of edges, by exploiting the geometric structure of the problem. This improves the classical O(n3)O(n^3) algorithms by Horn [Operations Research 1973] and Bruno, Coffman and Sethi [Communications of the ACM 1974]. For the unweighted case, the bound could be improved even further. We give a simple divide-and-conquer algorithm which runs in O(nmlogn)O(\sqrt{n}m\log n) time, improving two previous O(nm)O(nm)-time algorithms by Abraham [MSc thesis, University of Glasgow 2003] and Harvey, Ladner, Lov\'asz and Tamir [WADS 2003 and Journal of Algorithms 2006]. We also extend this algorithm to solve the \textit{Balance Edge Cover} problem in O(nmlogn)O(\sqrt{n}m\log n) time, improving the previous O(nm)O(nm)-time algorithm by Harada, Ono, Sadakane and Yamashita [ISAAC 2008].Comment: ICALP 201

    Breaking the nn-Pass Barrier: A Streaming Algorithm for Maximum Weight Bipartite Matching

    Full text link
    Given a weighted bipartite graph with nn vertices and mm edges, the \emph{maximum weight bipartite matching} problem is to find a set of vertex-disjoint edges with the maximum weight. This classic problem has been extensively studied for over a century. In this paper, we present a new streaming algorithm for the maximum weight bipartite matching problem that uses O~(n)\widetilde{O}(n) space and O~(m)\widetilde{O}(\sqrt{m}) passes, which breaks the nn-pass barrier. All the previous streaming algorithms either require Ω(nlogn)\Omega(n \log n) passes or only find an approximate solution. Our streaming algorithm constructs a subgraph with nn edges of the input graph in O~(m)\widetilde{O}(\sqrt{m}) passes, such that the subgraph admits the optimal matching with good probability. Our method combines various ideas from different fields, most notably the construction of \emph{space-efficient} interior point method (IPM), SDD system solvers, the isolation lemma, and LP duality. To the best of our knowledge, this is the first work that implements the SDD solvers and IPMs in the streaming model in O~(n)\widetilde{O}(n) spaces for graph matrices; previous IPM algorithms only focus on optimizing the running time, regardless of the space usage

    Fully Dynamic Matching in Bipartite Graphs

    Full text link
    Maximum cardinality matching in bipartite graphs is an important and well-studied problem. The fully dynamic version, in which edges are inserted and deleted over time has also been the subject of much attention. Existing algorithms for dynamic matching (in general graphs) seem to fall into two groups: there are fast (mostly randomized) algorithms that do not achieve a better than 2-approximation, and there slow algorithms with \O(\sqrt{m}) update time that achieve a better-than-2 approximation. Thus the obvious question is whether we can design an algorithm -- deterministic or randomized -- that achieves a tradeoff between these two: a o(m)o(\sqrt{m}) approximation and a better-than-2 approximation simultaneously. We answer this question in the affirmative for bipartite graphs. Our main result is a fully dynamic algorithm that maintains a 3/2 + \eps approximation in worst-case update time O(m^{1/4}\eps^{/2.5}). We also give stronger results for graphs whose arboricity is at most \al, achieving a (1+ \eps) approximation in worst-case time O(\al (\al + \log n)) for constant \eps. When the arboricity is constant, this bound is O(logn)O(\log n) and when the arboricity is polylogarithmic the update time is also polylogarithmic. The most important technical developement is the use of an intermediate graph we call an edge degree constrained subgraph (EDCS). This graph places constraints on the sum of the degrees of the endpoints of each edge: upper bounds for matched edges and lower bounds for unmatched edges. The main technical content of our paper involves showing both how to maintain an EDCS dynamically and that and EDCS always contains a sufficiently large matching. We also make use of graph orientations to help bound the amount of work done during each update.Comment: Longer version of paper that appears in ICALP 201

    Multiplicative Auction Algorithm for Approximate Maximum Weight Bipartite Matching

    Full text link
    \newcommand{\eps}{\varepsilon} We present an auction algorithm using multiplicative instead of constant weight updates to compute a (1-\eps)-approximate maximum weight matching (MWM) in a bipartite graph with nn vertices and mm edges in time O(m\eps^{-1}\log(\eps^{-1})), matching the running time of the linear-time approximation algorithm of Duan and Pettie [JACM '14]. Our algorithm is very simple and it can be extended to give a dynamic data structure that maintains a (1-\eps)-approximate maximum weight matching under (1) edge deletions in amortized O(\eps^{-1}\log(\eps^{-1})) time and (2) one-sided vertex insertions. If all edges incident to an inserted vertex are given in sorted weight the amortized time is O(\eps^{-1}\log(\eps^{-1})) per inserted edge. If the inserted incident edges are not sorted, the amortized time per inserted edge increases by an additive term of O(logn)O(\log n). The fastest prior dynamic (1-\eps)-approximate algorithm in weighted graphs took time O(\sqrt{m}\eps^{-1}\log (w_{max})) per updated edge, where the edge weights lie in the range [1,wmax][1,w_{max}].Comment: To appear in IPCO 202
    corecore