Distributed Approximate Matching

Transcription

1 Distributed Approximate Matching Zvi Lotker Boaz Patt-Shamir Adi Rosén Abstract We consider distributed algorithms for approximate maximum matching on general graphs. Our main result is a (4+ǫ)-approximation distributed algorithm for weighted maximum matching, whose running time is O(log n) for any constant ǫ, where n is the number of nodes. In addition, we consider the dynamic case, where nodes are inserted and deleted one at a time. For unweighted graphs, we give an algorithm that maintains a (1 + ǫ)-approximation in O(1/ǫ) time for each node insertion or deletion. For dynamic weighted graphs we give a constant-factor approximation algorithm that runs in constant time for each insertion or deletion. Dept. of Communication Systems Engineering, Ben-Gurion University, P.O.Box 653, Beer Sheva 84105, Israel. Dept. of Electrical Engineering, Tel Aviv University, Tel Aviv 69978, Israel. CNRS, Laboratoire de Recherche en Informatique (LRI), Bâtiment 490, Université Paris-Sud, Orsay CEDEX, France.

2 1 Introduction More than twenty years ago, a randomized distributed algorithm for maximal unweighted matching was given in [6]. The running time of the algorithm is O(log n) rounds, where n is the number of nodes in the graph. 1 Much more recently, Wattenhofer and Wattenhofer [10] presented distributed algorithms for computing approximate maximum weighted matchings: For trees, they give a 4-approximation algorithm that runs in constant time, and for general graphs, they give a randomized algorithm that runs in O(log 2 n) time, and with high probability achieves approximation factor 5. Subsequently, in [8] it was proved that any (possibly randomized) distributed algorithm that approximates maximum matching to within a constant must have running time Ω( log n/log log n + log /log log ), where is the largest degree in the graph. This lower bound holds regardless of the size of the messages used by the algorithm. In this paper, we give a distributed algorithm for general weighted graphs that (with high probability) approximates the maximum weighted matching to within a factor of 4 + ǫ and has running time of O(ǫ 1 log ǫ 1 log n) for any given ǫ > 0, getting to within an O(log log n) factor from the best possible running time. Our algorithms for this case use messages of constant size. We also consider the model of dynamic graphs. In this model, nodes are inserted and deleted one at a time. For this case we present algorithms which maintain an (1 + ǫ)-approximate unweighted matching in Θ(1/ǫ) time per insertion or deletion, for any given ǫ > 0. For weighted graphs we present an algorithm that maintains a constant-approximation weighted matching, and runs in constant time per insertion or deletion. Our algorithms for the dynamic case are deterministic. Related work Maximum matching is a classic optimization problem that was the target of extensive research (see, e.g., [1] for a comprehensive survey). There are quite a few PRAM algorithms for maximum matching. For example, Karp et al. [7] give a randomized NC algorithm for maximum matching, and Fischer et al. [3] give a deterministic NC algorithm that approximates maximum matching to within 1 + ǫ for any ǫ > 0. From the distributed perspective, however, the situation is less well understood. In addition to the works mentioned above, a number of other works considered distributed matching algorithms. Hoepman et al. [5] give an (expected) 2 + ǫ approximation for unweighted matching on trees in O(1/ǫ) time. For general graphs, Hoepman [4] gave a deterministic distributed O(n)-time algorithm that achieves a 2-approximation for weighted matching. A O(log 4 n) time deterministic distributed algorithm for 1.5-approximation of unweighted maximum matching was presented in [2]. Organization. The remainder of this paper is organized as follows. In Section 2 we give the model. In Section 3 we present algorithms for the static case, and in Section 4 we give algorithms for the dynamic model. Some conclusions appear in Section 5. 1 The algorithm in [6] is presented as a PRAM algorithm, but it readily works in the distributed message passing model. 1

3 2 Model We consider the standard synchronous message passing distributed model of computation (see [9] for complete details). The system is modeled as an undirected graph G = (V,E), V = n, were nodes represent processors and edges represent communication links. Time progresses in synchronous rounds, where in each round each processor may send messages to any subset of its neighbors. All messages sent are received and processed in the same round. Processors may have unique identifiers of O(log n) bits. Edges may have weights, where the minimum possible weight is defined to be 1. Unless otherwise stated, in what follows all logarithms are to base 2. 3 Weighted Matchings in Static Graphs In this section we define a distributed algorithm that computes (with high probability) a weighted matching in general graphs which is within a factor of 4 + ǫ of optimum, for any ǫ > 0. The running time of the algorithm is O(ǫ 1 log ǫ 1 log n). Preliminaries. To specify the algorithm, we define the following parameters as a function of ǫ: α = ǫ β = α α 1 = 1 + ǫ In what follows we assume, without loss of generality, that 1/n < ǫ 1: if we are given ǫ 1, we run the algorithm with ǫ := 1; and if we are given ǫ 1/n, we run the algorithm of Hoepman [4] that runs in O(n) = O( 1 ǫ ) time, getting approximation factor 2. The Algorithm. We partition the edge set into classes according to weights, and each weight class is further partitioned into subclasses according to (more refined) weights. Intuitively, the weights in classes increase exponentially with factor α, and weights in subclasses increase exponentially with factor β. Formally, class i, for i 0, includes all edges e with w(e) [α i,α i+1 ). Each class i is divided into subclasses (i,0),(i,1),(i,2),...,(i,k 1), where k = log β α. Given i 0 and 0 j < k 1, subclass (i,j) contains all edges e with w(e) [α i β j,α i β j+1 ). For j = k 1, the range is [α i β j,min{α i β j+1,α i+1 }). To specify the algorithm, we first define a virtual graph as follows. Let W be the highest class in the graph. Each node is duplicated W times: one virtual node for every weight class. The edge set of the virtual graph is the edge set of the original graph. An edge in class i will be adjacent to the virtual copy number i of the original nodes to which it was adjacent. Finally, we discard isolated nodes from the virtual graph. Note that the total number of virtual nodes in the graph is at most 2 E < 2n 2. Note also that the virtual graph can be constructed distributively from the original graph, and without knowledge of W. Furthermore, each original node can simulate all the virtual nodes it is responsible for creating. We now specify the algorithm. It consists of two stages. In the first stage we run an algorithm that calculates a maximal unweighted matching in the virtual graph. Note that by construction, a 2

4 maximal matching in the virtual graph may be viewed as a set of maximal matchings, each one for the subgraph that contains only the edges of a given class. Therefore, by the end of the first stage, we have, for each class i, a set of edges which is a maximal matching on the edges of class i. Denote that matching A i. Note that the union of all A i s is not necessarily a matching in the original graph. The maximal matchings that we calculate have the further property that if an edge e of subclass (i,j) is not in A i, then one of its endpoints is matched (in A i ) with an edge of subclass (i,j ), for some j j. The matchings are computed distributively using the algorithm of [6], called henceforth Algorithm II. Specifically, we proceed as follows. We start with empty A i for each i. We run k phases (recall that k = log β α ). We start with the virtual graph, and in each phase, we add some edges to the A i s, and delete some (other) edges from the virtual graph. In phase l 1, we consider only edges in subclasses (,k l). At the beginning of phase l, we start Algorithm II only on edges of subclasses (,k l) and wait for γ log n rounds, for some constant γ that we determine later. Note that in fact the graph considered for this phase consists of a number of separate components, each one for one subclass (,k l). After γ log n rounds, the output is (with high probability) a set of maximal matchings, each one for (the remainder from previous phases of) the edges of a subclass (,k l). We then eliminate from the graph any edge e from a subclass (i,j) with j < k l, with an endpoint which is matched with an edge of class (i,k l). In the second stage of the algorithm, we start with the A i s and produce a single matching in the original graph using Algorithm COMBINE, defined as follows. Algorithm COMBINE is defined on the original nodes and not the virtual nodes. Algorithm COMBINE Initially, at each node, each edge which is in any of the A i s is marked eligible. Do for r = 1 to 3 log α n : Let e v be the highest-weight edge adjacent to v which is eligible. Send request on e v. If received request on e v : (1) Output e v as part of the matching. (2) Send not eligible on all other eligible edges. (3) Halt (locally). Otherwise: Mark as not eligible all edges on which a not eligible message was received. 3.1 Analysis In our analysis we use the following fact about the II algorithm [6]. Claim 3.1 Let N be the number of edges in the graph. Then there exists a constant c > 0 such that, for any x > 0, Algorithm II terminates at all nodes within xlog N rounds with probability at least 1 N cx. We start with two lemmas about the first stage of our algorithm. 3

5 Lemma 3.2 The probability that for all iterations, all nodes terminate the maximal matching algorithm by the end of the iteration (i.e., within γ log n rounds) is at least 1 1 n 2. Proof: During the whole execution of the algorithm, there are k = log β α runs of the II algorithm. Since 1 n < ǫ 1, k = O(ǫ 1 log ǫ 1 ) = O(n log n). Now, each instance of the II algorithm is run on the virtual graph, that contains less than n 2 edges. By Claim 3.1, the probability that an execution of Algorithm II does not terminate within xlog(n 2 ) = 2xlog n rounds is at most (n 2 ) cx = n 2cx for some constant c > 0. Setting γ = 4/c (and x = γ/2), we have that the probability that an execution does not terminate in γ log n rounds is less than n 2cγ/2 = n 2c 2/c = 1/n 4 ; thus, by the union bound, the probability that all k executions of the II algorithm terminate in γ log n rounds is at least 1 k/n 4 > 1 1/n 2, as required. Definition 3.1 A maximal matching with respect to edges in class i is said to have the superiority property if it holds that any edge e of subclass (i,j) which is not in A i has an endpoint which is adjacent to an edge e which is in A i, and is in subclass (i,j ), for j j. Lemma 3.3 With probability at least 1 1 n 2, for each i, A i is a maximal matching with the superiority property with respect to the edges in class i. Proof: By Lemma 3.2, with probability at least 1 1 n 2 all runs of the II algorithms terminate before the algorithm proceeds to the next iteration. By induction on the iteration number we have that after iteration s, for each class i, we have a maximal matching, with the superiority property, with respect to the edges in subclasses (i,j), j k s. We now proceed to analyze Algorithm COMBINE. We start with the following loop invariant. Lemma 3.4 Let W be the highest class that exists in the graph. After iteration r of algorithm COM- BINE, every edge in A i, i > W r, is either in the output M, or one of its endpoints is matched in M with an edge which is in A i, i > i. Proof: By induction on r. For the base of the induction (iteration r = 1), note that for every edge e in A W, both its endpoints must have e as the heaviest edge among all adjacent edges in the various A i s. Therefore all edges in A W will be included in M, and the claim holds for r = 1. For r > 1 assume the claim holds for all r < r. For edge in A i, i > W (r 1) the claim holds by the induction hypothesis. Consider an edge e in A W (r 1). If before iteration r we have e M, we are done. Similarly, we are done if e is adjacent to an edge of class i > W (r 1) that was added to M before iteration r. Otherwise, consider each of the endpoints of e. We claim that they cannot be matched with an edge e of class i < W (r 1). Assume by way of contradiction that endpoint v was the first among the two endpoints to be matched with an edge e of class i < W (r 1). But when this occurred e was not the heaviest eligible edge of v in the various A i s. A contradiction. We also have that the endpoints of e cannot have an eligible edge e in some A i, i > W (r 1). This is because by the induction hypothesis edge e is either already in M, or one of its endpoints is matched in M with an edge which is in A i, i > i. Thus both endpoints of e will chose e (i.e., will send a request message on it) and e will be added to M in iteration r. We can now prove the approximation factor of our algorithm. 4

6 Theorem 3.5 Assume that for all i 1, A i is a maximal matching with the superiority property of the edges in class i. Let M be the matching that algorithm COMBINE outputs, and let M be any matching in the graph. Then w(m) (4 + 5ǫ)w(M). Proof: Let W be the highest class that exists in the graph. To account for the weight of the matching M against the weight of the output matching M, we consider separately edges e M which are in classes i > W 3 log α n, and edges e M which are in lower-numbered classes. To account for edges e M which are in classes i > W 3 log α n we construct the following charging scheme, that maps each such edge e M to an edge in f(e) M. Suppose e M belongs to class i. Then f(e) M is defined as follows. First assume that e A i. (1) If e is in M then f(e) = e. (2) If e is not in M, it follows from Lemma 3.4 that one of the endpoints of e is matched in M with an edge e 1 of class i > i. We define f(e) = e 1. If e / A i, by the maximality of A i one of its endpoints is matched in A i, with an edge e 2. We now let f(e) be the edge that would be f(e 2 ) if e 2 was in A i. Formally, (3) if e 2 is in M then f(e) = e 2. (4) If e 2 is not in M, it follows that one of the endpoints of e 2 is matched in M with an edge e 3 of class i > i. We define f(e) = e 3. We now give an upper bound on the weight assigned to each edge a M, as a function of the weight of that edge, w(a). Note that by the definition of the mapping f, an edge a is assigned the weight of an edge e which is in some A i only if they share an endpoint. An edge a is assigned the weight of an edge e of class i which is not in A i only if they share an endpoint or there is an intermediate edge e in A i which shares an endpoint with a and shares an endpoint with e. Each endpoint of a M is also the endpoint of at most a single edge e M. Thus this type of assignment can add, for each endpoint of a, at most the weight β w(a): the assigned weight is w(a) if the edge e is the same as a (case (1)) or the class of a is higher than the class of e (case (2)); the assigned weight is β w(a) if e and a are in the same class (case (3)), since by the superiority property, the subclass of a is not smaller than that of e. As to assignments of case (4), for each endpoint of a there can be at most one edge from each A i that shares this endpoint. All edges mapped to a this way are in classes lower than the class of a. Therefore the total weight mapped to a by case (4), per endpoint, is at most w(a) s=0 α s α = w(a) α 1. The total weight assigned to edge a is therefore at most 2 (β + α α 1 ) = 4β = 4(1 + ǫ). We now consider the edges e M which are in classes i W 3 log α n. Let X be the total weight of edges in M which are in classes i W 3 log α n. It follows that X n 2 αw 3 log α n +1. The weight of M is at least α W (since it includes at least one edge of the top class). Therefore, and since n > 1 ǫ, X 1 n w(m) ǫ w(m). The next theorem states the running time of our algorithm. Theorem 3.6 The running time of the algorithm is O( 1 ǫ log 1 ǫ log n). 5

7 Proof: The number of iterations of the first stage is k = log β α, and each iteration takes γ log n = O(log n) rounds. Now, since 0 < ǫ 1, we have that log β α = lnα ln β = ln(1 + 1 ǫ ) ln(1 + ǫ) 4log 1 ǫ ǫ It follows that the total running time of the first stage is O( 1 ǫ log 1 ǫ log n). The second stage has 3log α n = O(log n) rounds, each taking constant time. The time complexity therefore is dominated by the first stage. For completeness, we note that the algorithm of [10] can be extended to yield approximation factor 2 + ǫ (assuming that a polynomial bound on the largest edge weight is known). Briefly, the idea is to divide the edges into weight classes of the form [(1 + ǫ) i,(1 + ǫ) i+1 ), and then run the II algorithm on each class in descending order of weights. When such an execution is over (which occurs in O(log n) time w.h.p.), all selected edges are output, and they are removed along with all their incident edges. The number of classes is O(log 1+ǫ n) = O(ǫ 1 log n). We omit details here Dynamic graphs In this section we consider dynamic graphs. In this model, the input is a sequence of topological changes; without loss of generality, we assume that each topological change is either the insertion or the deletion of a single node (edge insertion and deletion can be simulated by deleting a node and re-inserting it with the new set of incident edges). After each topological change, the system makes a computation, and outputs a local indication for each edge, whether it is in the matching or not. We consider both the unweighted and weighted graphs case, and present deterministic approximation algorithm for both cases. 4.1 Unweighted Dynamic Graphs In this section we prove the following result. Theorem 4.1 Let ǫ > 0. There exists a distributed algorithm whose running time per topological 1 change is O(1/ǫ), and whose output, after processing the change, is at least 1+ǫ times the size of the maximum matching. We need the following standard concept. Definition 4.1 Let G = (V,E) be a graph, let M E be a set of non-intersecting edges in E, and let k 1. A path v 0,v 1,...,v 2(k 1),v 2k 1 is an augmenting path of length 2k 1 with respect to M if for all 1 i k 1, (v 2i 1,v 2i ) M, for all 1 i k (v 2(i 1),v 2i 1 ) / M, and both v 0 and v 2k 1 are not endpoints of any edge in M. Our algorithm relies on the following graph-theoretic result (see, e.g., [3]). Theorem 4.2 Let G = (V, E) be a graph, and let M E be a set of non-intersecting edges. Let k be a positive integer. If there is no augmenting path of length 2k 1 or less w.r.t M, then the size of the largest matching in G is at most k+1 k M. 6

8 The idea behind our algorithm is to maintain the invariant that the output never contains augmenting paths shorter than 2/ǫ. This invariant implies, by Theorem 4.2, that the size of the output matching is close to the size of the best possible matching, as promised by Theorem 4.1. It remains to show how to maintain that invariant. We start with the event of node insertion. We use the following property. Lemma 4.3 Let G = (V,E) be a graph, let M E be a matching, and suppose that there are no augmenting paths in G of size at most l w.r.t M. Let v / V be a new node, and let E {v } V be its incident edges. Let G = (V {v },E E ) be the resulting graph. Then any augmenting path of size at most l in G has v as one of its endpoints. Proof: If in G there are no augmenting paths of size at most l we are done. Otherwise, let P be such a path. First, note that P must contain v : otherwise, P is an augmenting path in G of size at most l, contradicting the assumption. Next, note that v cannot be in the middle of P, because no edge incident to v is in M, and any augmenting w.r.t M path alternates between edges in M and edges not in M. In the algorithm, we search for all augmenting paths that start with v and whose size is at most 2 1 ǫ 1. If no such path exists, we are done. Otherwise, let P be the shortest such path. We augment along P, i.e., we switch the roles of the edges in P as follows. Let P M be the set of edges in P M, and let P A be the set of edges in P \ M. We set M = M P A \ P M, and declare M as the new output. The correctness of our algorithm relies on the following key lemma, which may be of independent interest. Lemma 4.4 Let G be a graph, and let M be a matching in G, and let l be such that there are no augmenting paths of length l or less in G w.r.t M. Let G be the graph obtained from G by adding node v and its incident edges. Let P be the shortest augmenting path in G, and suppose that P l. Let M be the matching obtained by augmenting M along P. Then in G there are no augmenting paths of size l or less. Proof: Denote the nodes in P by v,v 1,v 2,...,v n. Consider any augmenting path P in G w.r.t. M. If P does not contain any edges from P, then P is an augmenting path in G w.r.t. M, and hence its length is more than l and we are done. Otherwise, fix an orientation of P. Let v i be the first node from P under this orientation which is also in P, and let v j be the last node in P which is also on P. Without loss of generality assume that i < j (otherwise reverse the orientation of P ). We proceed by case analysis, depending on whether edge (v i,v i+1 ) is in M or not, and whether edge (v j 1,v j ) is in M or not (both edges must exist, but they may be the same edge). There are 4 cases to consider. Case 1: (v i,v i+1 ) / M, and (v j 1,v j ) / M. This is the situation depicted in Figure 1. P goes from w to v i, and from v i it must turn to v i+1, and eventually get to v j 1 (and then to v j ). In general, P may take a detour leaving P and later return to P. Let ṽ be the first time P leaves P and let ˆv be the last node on that detour. After v j, P continue to u. In this case (and in all other cases as well), the last edge on P before v i is not in M; therefore, the path v v i w is an augmenting path in G w.r.t. M. Since P is a shortest augmenting path in G w.r.t. M, then, using the notation 7

9 a b 1 b 2 b 3 c v w d v i v i+1 v j-1 v j v n f e u Figure 1: Case 1 considered in the proof of Lemma 4.4. Thick lines denote edges in M. in Figure 1, we have that it must hold that a + d a + b 1 + b 2 + b 3 + c d > c. (1) Similarly, u v j v n is an augmenting path in G w.r.t. M, and by assumption on the length of the shortest augmenting path in G w.r.t. M, we have and hence, by Eq. (1), we have that and we are done for this case. e + c > l, (2) P e + d e + c > l, a 1 b 1 b 2 c a 2 v w d v i v i+1 v j-1 v j v n f e u Figure 2: Case 2 considered in the proof of Lemma 4.4. Thick lines denote edges in M. Case 2: (v i,v i+1 ) M, and (v j 1,v j ) / M (see Figure 2). As before, P = w v i ṽ ˆv v j u. Similarly to Case 1, we have an augmenting path in G v n v j u, and hence it must be the case that e + c > l. (3) In addition, the path v ṽ ˆv v i w is an augmenting path in G, and since P is a shortest augmenting path in G, we have a 1 + f + b 1 + d a 1 + a 2 + b 1 + b 2 + c f + d a 2 + b 2 + c. (4) Therefore, P = d + a 2 + f + b 2 + e a 2 + b 2 + c + a 2 + b 2 + e > l + 2(a 2 + b 2 ), and we are done for this case. Case 3: (v i,v i+1 ) / M, and (v j 1,v j ) M. In this case (depicted in Figure 3) we have that u v j ṽ ˆv v n is an augmenting path in G and hence e + b 2 + f + c 2 > l. (5) 8

10 a b 1 b 2 c 1 c 2 v w d v i v i+1 v j-1 v j v n f e u Figure 3: Case 3 considered in the proof of Lemma 4.4. Thick lines denote edges in M. In addition, the path v v i w is an augmenting path in G, and by minimality of P a + d a + b 1 + b 2 + c 1 + c 2 d b 1 + b 2 + c 1 + c 2. (6) Therefore, P = d + b 1 + f + c 1 + e b 1 + b 2 + c 1 + c 2 + b 1 + f + c 1 + e > l + 2(b 1 + c 2 ), and we are done for this case too. a 1 a 2 b c 1 c 2 v w d v i v i+1 v j-1 v j v n f e u Figure 4: Case 4 considered in the proof of Lemma 4.4. Thick lines denote edges in M. Case 4: (v i,v i+1 ) M, and (v j 1,v j ) M (Figure 4). Then the path v ṽ ˆv v n is an augmenting path in G, and therefore a 1 + f + c 2 a 1 + a 2 + b + c 1 + c 2 f a 2 + b + c 1. (7) Also, the path w v i v j u is augmenting in G, and therefore Again, we obtain and we are done. d + b + e > l. (8) P = d + a 2 + f + c 1 + e a 2 + b + c 1 + d + a 2 + c 1 + e > l + 2(a 2 + c 1 ), The algorithm. Based on the above observations, the algorithm is straightforward: whenever a node v is inserted, it initiates an exploration of the topology of the graph up to distance 2/ǫ + 1 from itself, so as to find any augmenting path (w.r.t. the current matching M) which starts with v, and is of size at most 2/ǫ. If no such path is found the algorithm terminates. Otherwise, a shortest augmenting path is chosen (ties broken arbitrarily), and its edges flip their role: matching edge become non-matching edge and vice versa. When a node v is deleted, there are two cases. If v was not matched, then the algorithm terminates immediately. Otherwise, suppose that (v,v ) M for some node v. In this case, the algorithm reinserts v using the insertion algorithm. Note that if there are no augmenting paths of size at most l in G, then there are no such paths in G \ {v,v }. 9

11 4.2 Weighted Dynamic Graphs We now show how to maintain constant approximation weighted matching in dynamic graphs (when the edges are weighted). Following each topological change, our algorithm runs in constant time. We make no attempt here to optimize the constants. Our algorithm is based on the idea to reduce the weighted case to the unweighted case, and apply a simplified version of the COMBINE algorithm. More formally, the algorithm is as follows. (1) We partition the edges into disjoint classes, where all edges in class i 0 have weight in [4 i,4 i+1 ). (2) When a node is inserted, it initiates the unweighted algorithm for each weight class, according to the weights of its incident edges. The algorithms are run with ǫ = 1, which in fact means that each new edge is added to the output (of its class) greedily, i.e., if and only if both its endpoints are not matched in that class. (3) After O(1) time, all algorithms terminate, and each node may have at most one incident edge matched for every weight class. Each node then picks, as a candidate for the output, the matched incident edge in the highest weight class (if such edge exists). (4) An edge is output if and only if it is chosen as candidate by both its endpoints. Note that each of the class weight algorithms works only to distance O(1/ǫ) = O(1) from the location of the topological change, and therefore the only possible changes in the output are in that neighborhood. It follows that Steps 3 and 4 need to be carried out only at distance O(1/ǫ) = O(1) from the location of the change more remote nodes in the graph do not change their output. Analysis. Let A i be the output of the algorithm for weight class i, and let OPT denote the optimum weighted matching. We start with the following simple property. Lemma 4.5 w(opt) 8 i w(a i). Proof: Let OPT i be the optimum weighted matching, if only edges of class i are considered. Then the number of edges in A i is at least half the number of edges in OPT i, and since each edge in OPT i weighs at most 4 times the weight of each edge in A i, we have that w(opt i ) 8w(A i ) for each i. Summing over all weight classes yields the claim. Let M be the matching output by our algorithm. We now give a lower bound on the weight of M by a function of the weights of the A i s. Lemma 4.6 i w(a i) 32 9 w(m). Proof: We bound the total weight of the edges that are in the A i s but are not in M by mapping each such rejected edge to an edge in M. The mapping is natural: an edge in A i is not in M only if it is incident to an edge in A j for some j > i. Transitively, we have a tree of rejected A i edges hanging on each endpoint of each edge which is in the output matching M. We now bound the total weight in such a tree. Let e M, and denote the weight class of e by i 0. On each endpoint of e there may be at most one edge from each weight class smaller than i 0 that was rejected by e. Each such edge e may in turn have rejected an edge from each class smaller than its own. By induction, it follows that the number of rejected edges from weight class i 0 j, j 1 (per endpoint of e) is at most j. In the 10

12 worst case, the weight of the edges in class i 0 j may be almost as large as w(e)/4 j 1, and thus we have that the total weight of one tree of rejected edges hanging from e is less than j=0 ( w(e) j + 1 ) 2 4 j = w(e) 4 j = w(e) i=0 Since there is one such tree in each endpoint of e, we have that the total weight rejected by e is less than 32/9 times its own weight. Summing over all edges in M yields the claim. We can now summarize with the following theorem. Theorem 4.7 w(opt) < 30 w(m). Proof: Follows from Lemma 4.5 and Lemma 4.6. Note that all the algorithms for the various weight classes run in parallel in time O(1/ǫ) = O(1) (since we use ǫ = 1). The combining phase runs in constant time. If follows immediately that the running time of our algorithm is constant per node insertion or deletion. Lower bound for dynamic graphs. To complete the picture, we observe that it is easy to see that Ω(1/ǫ) time is necessary to maintain (1 + ǫ)-approximation of maximum matching in dynamic unweighted graphs. To see that, assume without loss of generality that ǫ = 1/k for some integer k > 0. Consider a line of 2(k 1) edges. The size of the maximum matching in this graph is k 1, so a (1 + ǫ)-approximation must be a maximum matching. Since this is an even-length line, the matching must consist of every other edge, and in particular, one of the endpoints of the line, say v 0, is matched. If we remove this endpoint, the size of the maximum matching remains k 1, and so is any (1 + ǫ)- approximation. But to switch to such a matching, all remaining edges must flip their status, which cannot happen in less than Ω(1/ǫ) time. 1/ /4 1/4 1 1/4 Figure 5: Trees of rejected A i edges hanging on an edge e M (see Lemma 4.6). 11

13 5 Conclusion Distributed matching is obviously a fundamental network algorithm, which has been the subject of an active research area for over 30 years. Yet, determining the exact complexity of this problem remains an elusive target. In this paper we have narrowed the gap between the lower and upper bounds for weighted matching. However, several very interesting questions remain open. For example, a longstanding open problem is to find a deterministic log-time distributed algorithm for maximal matching. References [1] R. K. Ahuja, T. L. Magnanti, and J. B. Orlin. Network Flows. Prentice-Hall, Engelwood Cliffs, New Jersey, USA, [2] A. Czygrinow, M. Hańćkowiak, and E. Szymańska. A fast distributed algorithm for approximating the maximum matching. In Proc. 12th Annual European Symposium on Algorithms (ESA), pages , [3] T. Fischer, A. V. Goldberg, D. J. Haglin and S. Plotkin. Approximating matchings in parallel. Info. Proc. Lett., 46(3): , [4] Jaap-Henk Hoepman. Simple Distributed Weighted Matchings CoRR cs.dc/ , [5] Jaap-Henk Hoepman, Shay Kutten, Zvi Lotker. Efficient Distributed Weighted Matchings on Trees. proc. of SIROCCO 2006, pp [6] A. Israeli and A. Itai. A fast and simple randomized parallel algorithm for maximal matching. Info. Proc. Lett., 22(2):77 80, [7] R. M. Karp, E. Upfal, and A. Wigderson. Constructing a Perfect Matching is in RandomNC. In Proc. 17th Ann. ACM Symp. on Theory of Computing (STOC), pages 22 32, [8] F. Kuhn, T. Moscibroda, and R. Wattenhofer. The price of being near-sighted. In Proc. 17th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages , [9] D. Peleg. Distributed computing: a locality-sensitive approach. Society for Industrial and Applied Mathematics, Philadelphia, PA, USA, [10] M. Wattenhofer and R. Wattenhofer. Distributed weighted matching. In Proc. 18th International Conference on Distributed Computing (DISC), pages ,