Greedy Matching: Guarantees and Limitations

Abstract

Since Tinhofer proposed the MinGreedy algorithm for maximum cardinality matching in 1984, several experimental studies found the randomized algorithm to perform excellently for various classes of random graphs and benchmark instances. In contrast, only few analytical results are known. We show that MinGreedy cannot improve on the trivial approximation ratio of $\frac{1}{2}$ whp., even for bipartite graphs. Our hard inputs seem to require a small number of high-degree nodes. This motivates an investigation of greedy algorithms on graphs with maximum degree $\varDelta$: we show that MinGreedy achieves a ${\frac{{\varDelta }-1}{2{\varDelta }-3}}$-approximation for graphs with ${\varDelta } {=} 3$ and for $\varDelta$-regular graphs, and a guarantee of ${\frac{{\varDelta }-1/2}{2{\varDelta }-2}}$ for graphs with maximum degree ${\varDelta }$. Interestingly, our bounds even hold for the deterministic MinGreedy that breaks all ties arbitrarily. Moreover, we investigate the limitations of the greedy paradigm, using the model of priority algorithms introduced by Borodin, Nielsen, and Rackoff. We study deterministic priority algorithms and prove a ${\frac{{\varDelta }-1}{2{\varDelta }-3}}$-inapproximability result for graphs with maximum degree ${\varDelta }$; thus, these greedy algorithms do not achieve a $\frac{1}{2} {+} \varepsilon$-approximation and in particular the $\frac{2}{3}$-approximation obtained by the deterministic MinGreedy for ${\varDelta } {=} 3$ is optimal in this class. For k-uniform hypergraphs we show a tight $\frac{1}{k}$-inapproximability bound. We also study fully randomized priority algorithms and give a $\frac{5}{6}$-inapproximability bound. Thus, they cannot compete with matching algorithms of other paradigms.

Appendix: A Linear Time Implementation of MinGreedy

For MRG and Ranking Poloczek and Szegedy [41] propose a data structure that allows to run both algorithms in linear time. Greedy can also be implemented in linear time using a data structure similar to the one we describe below.

Given an adjacency list representation of the input graph $G = (V=\{0,\ldots ,n-1\},E)$, the data structure can be initialized in linear time $O(|E| + |V|)$. At any time during MinGreedy, the data structure supports each of the following operations in constant time: selection of a random node of minimum (non-zero) degree, selection of a random neighbor of a given node, and the deletion of a given edge. Hence MinGreedy can be implemented in linear time since a minimum degree node and a neighbor are selected at most $\frac{|V|}{2}$ times and each of the |E| edges is removed exactly once.

How is a minimum degree node u selected in constant time? Consider a step of MinGreedy and let $d_0<d_1<\cdots <d_k$ be the different degrees currently present in the graph, where $d_0=0$ is the degree of already isolated nodes. We use an array S which is partitioned into sub-arrays $S_i$ ($0\le i\le k$) such that $S_i$ precedes all $S_j$ with $i < j$. Each $S_i$ contains all nodes that currently have degree $d_i$ in contiguous cells of S . A doubly linked list D stores (from head to tail) the borders of $S_0,S_1,\ldots ,S_k$. Node u is selected by reading the second entry in D , which stores nodes of minimum degree $d_1$, and choosing a random cell in $S_1$.

To select a random neighbor v of u in constant time, instead of adjacency lists we utilize adjacency arrays (which have same lengths as the lists and can be computed in linear time during the preprocessing phase). To pick v from the adjacency array $A_u$ of u , we assert that the currently available neighbors of u are stored in a consecutive part of $A_u$.

Now that nodes u and v are selected, the edge (u, v), and all incident edges of u and v are removed from the data structure. We remove these edges one-by-one, each in constant time.

This is how we update the adjacency arrays. Let a node x and an index of a cell in $A_x$ be given, say containing neighbor y . Assume that the array cell in $A_x$ containing node y also stores the index of the array cell in $A_y$ containing node x as a reference and vice versa. In order to remove the edge (x, y) , we move the entry of the last non-empty cell in $A_x$ to the position of y , and handle $A_y$ and x analogously. We also update the references of the two moved entries accordingly; this is done in constant time using the references stored inside the moved entries. The references are initialized during the construction of the adjacency arrays.

How to update S and D for the removal of an edge (x, y) ? Since the degrees $d_x,d_y$ of x respectively y are decreased by exactly one, these nodes are moved from sub-array $S_{d_x}$ to sub-array $S_{d_x-1}$ respectively from $S_{d_y}$ to $S_{d_y-1}$. We proceed analogously for x and y . To move x to its new sub-array, we utilize two helper arrays $P_D,P_S$: $P_D[x]$ stores a pointer to the D -entry containing x , $P_S[x]$ holds the index of the cell in S containing x . The entry of node x in the sub-array $S_{d_x}$ is replaced by the “leftmost” node in $S_{d_x}$, i.e., the node stored at the smallest index, and x is appended to the “right” of $S_{d_x-1}$. If $S_{d_x}$ is now empty, we remove it from D in constant time using the pointer $P_D[x]$. If $S_{d_x-1}$ does not yet exist, i.e., x is now the only node of degree $d_x-1$, then we create $S_{d_x-1}$ at the now cleared position in S and insert $S_{d_x-1}$ before $S_{d_x}$ (or before the successor of $S_{d_x}$, if $S_{d_x}$ was removed), also in constant time. The pointers in $P_D$ and the addresses stored in $P_S$ are updated accordingly.

Note that $S,D,P_S,P_D$ can be initialized in time $O(|E|+|V|)$ during the preprocessing phase by scanning through the adjacency lists of G a constant number of times.