Information Processing Letters 75 (2000) 145–151

An optimal parallel algorithm for general maximal matchingsis as easy as for bipartite graphs

K.V.R.C.N. Kishorea,1, Sanjeev Saxenab,∗a Department of Computer Science and Engineering, Indian Institute of Technology, Kanpur, India 208 016

b Information Technology Area, Indian Institute of Information Technology and Management, Gola Ka Mandir, Gwalior 474005, India

Received 3 November 1999; received in revised form 5 May 2000Communicated by F.Y.L. Chin

Abstract

In this paper we show that iftb(n,m) is the parallel time taken for computing a matching in a bipartite graph (incidentwith a fraction of edges) by a parallel work-optimal algorithm and if there is an algorithmA to compute a maximalmatching in a general graph intso(n,m)-time whose cost is poly-logarithmic away from the best known serial algorithmthen there is a work-optimal parallel algorithm for finding a maximal matching in a general graph that runs in timeO(min{log2n log logn, tb(n,m) log logn} + tso(n,m)). This results in an O(log2.5n) time optimal parallel algorithm formaximal matching in a general graph. A parallel algorithm is said to be work-optimal if the processor-time product for thealgorithm is only a constant multiplicative factor away from the best known serial algorithm. 2000 Elsevier Science B.V. Allrights reserved.

Keywords:Parallel algorithms; Computational complexity; Maximal matching; Graphs

1. Introduction

Presently, optimal parallel algorithms for comput-ing a maximal matching in a general graph as well asin a bipartite graph take the same time. So, there isevidence to conjecture the existence of a simpler andfaster optimal parallel algorithm for maximal match-ing in bipartite graphs. We show that a faster opti-mal parallel algorithm for finding a fractional match-ing (one which is incident with at least a constant frac-tion of edges) also results in an improvement in thecase of a maximal matching for general graphs.

∗ Corresponding author.E-mail addresses:ssax@computer.org, ssax@ieee.org (S. Sax-

ena).1 Presently with American International Group, New York.

A matching in a graphG is a subset of edgesMsuch that no two of them share a common end point.A matchingM is maximal ifM is not a proper subsetof another matching. We use the term “fractionalmatching” for a matching which is incident with atleast a constant fraction of edges. In this paper werelate the parallel complexity of computing a maximalmatching in a general graph to the parallel complexityof computing a fractional (and maximal) matching ina bipartite graph.

The parallel computation of a maximal matching isa well studied problem. Israeli and Shiloach [6] gavea randomised O(logn) time algorithm and a determin-istic O(log3n) time algorithm with O(m+ n) proces-sors for general graphs. Han [4] showed that the max-imal matching problem has an O(log2.5n) time algo-

0020-0190/00/$ – see front matter 2000 Elsevier Science B.V. All rights reserved.PII: S0020-0190(00)00101-0

146 K.V.R.C.N. Kishore, S. Saxena / Information Processing Letters 75 (2000) 145–151

rithm with O((m+n)/ log0.5n) processors for generalgraphs. This algorithm is sub-optimal. The cost of thealgorithm is O((m+ n) log2n). Han [4] also gives anO(log2n) time O(M(n)) processor algorithm for gen-eral graphs whereM(n) is the number of processorsrequired to multiply twon × n matrices. CurrentlyM(n) ≈ n2.4. Kelsen [8] gave an O(log4n) time op-timal algorithm for general graphs and O(log3n) timeoptimal algorithm for bipartite graphs. This was laterimproved by Han [3] to an O(log3n) optimal algo-rithm for general graphs. Kelsen [8] also describesan O(log2n) time optimal algorithm for computinga fractional matching which is incident with one-sixth of the edges of a bipartite graph on an EREWPRAM. From results of the present paper, we get anO(log2.5n) time optimal parallel algorithm for a max-imal matching in a general graph, this is an improve-ment over the earlier O(log3n) time optimal algorithmof Han [3]. In Section 2, we first describe some pre-liminary results and the model used in this paper. Themain results of this paper are described in Section 3.

2. Preliminaries

In this paper, we use the Parallel Random AccessMachine (PRAM) as the model of computation for theparallel algorithms. In anExclusive ReadExclusiveWrite (EREW) model, at any particular instant nomore than one processor is allowed to either read orwrite to the same memory location. The algorithmdesigner should write algorithms in such a way thatsuch conflicts never occur. Our results are valid onany model which is at least as strong as the EREWmodel.

A parallel algorithm that runs in time O(t (n))using p(n) processors is said to have a cost ofc(n) = O(t (n)p(n)). If this cost equals the cost ofthe best known sequential algorithm, then the parallelalgorithm is said to be work-optimal [7].

Givenn itemsA[1 : n], the prefix sums problem isto compute then sumsB[1] = A[1],B[2] = A[1] +A[2], . . . ,B[n] = A[1] + A[2] + · · · + A[n]. Prefixsums can be found in O(logn) optimal time on anEREW PRAM [9]. Prefix sums routines can be usedto compacts flagged items in an array of sizen; thecompacted items will be in the firsts locations. Ifthere arem different types of items (say ofm different

colours) then we can bring all items of the same typetogether (and count them) in O(m+ logn) time withO(n) cost [2].

3. Reduction

We first describe a decomposition of a graph intobipartite graphs and then give an algorithm for gettinga maximal matching in general graphs. Merging ofmatchings in two bipartite graphs (the main step) isdiscussed in detail in Section 3.3.

3.1. Decomposition

We give a decomposition scheme for decompositionof a given graphG= (V ,E) into a set of edge disjointbipartite graphs. The result is a generalisation of theresult of Kelsen [8].

Lemma 1. If a graphG = (V ,E) is validly vertexcoloured usingC colours, thenG can be decomposedinto O(logC) edge disjoint bipartite graphs.

Proof. Assume that vertices of the graph are colouredwith C colours. Each colour can be interpreted as abit string of length O(logC). We refer to the colourof vertex v as C(v). S(v) refers to the bit stringcorresponding toC(v). We now partition the edge setsuch that the edgee = (u, v) is kept in the subgraphGi = (V ,Ei) where i = min{j | j th bit of S(u)⊕S(v) = 1}. Here “⊕” is bitwise exclusive “or”.

Clearly asS is a bit string of length O(logC), onlyO(logC) subgraphs are present. Further for any edge(u, v) ∈Gi theith bits ofC(u) andC(v) are different;all vertices whoseith bit is zero can be put in oneclass (sayV 0) and all vertices whoseith bit is one canbe put in the other class (sayV 1), thus for any edge(u, v) ∈Gi , one vertex is inV 0 and the other inV 1,hence the graphGi is bipartite.

Thus {Gi} is an O(logC) bipartite decompositionof G. 2

Such a decomposition is called a bipartite decom-position ofG and the number of subgraphs obtained iscalled the size of the decomposition [8].

K.V.R.C.N. Kishore, S. Saxena / Information Processing Letters 75 (2000) 145–151 147

3.2. Algorithm—first attempt

Our reduction is according to the following “algo-rithm”.

Step 1: If the graphG is uncoloured then number thevertices ofG from 0 ton− 1. These numbers willbe used as “colours”. In rest of this paper, we willassume that the graphG is (vertex) coloured withCcolours.

Step 2: Partition the edges such thate= (u, v) is keptin the graphGi iff

i =min{j | j th bit of u⊕ v = 1

}.

Comment: This is to obtain the bipartite decomposi-tion of size logC =O(logn).

Step 3: Use prefix sums to count the size of eachGi(see discussions in Section 2).

Step 4: In parallel use a parallel algorithm for bipar-tite graphs to independently find a fractional (ormaximal) matching in eachGi .

Step 5: Colour all edges of a matching from subgraphi with colouri. This will result in an edge colouringof a subgraph of the original graph with at mostO(logn) colours.

Step 6: Pairwise merge the matchings of the sub-graphs (in a tree like manner), until a single match-ing is left.

Steps 1–3 can be done in O(logn) optimal time [8].In fact, if a graph is validly coloured, Step 1 does nottake any time. In Step 2, we have to carry out exclusiveOR and find the least significant bit which is one. Thistakes O(1) optimal time [2]. Step 3 can be done on anEREW model in O(logn) optimal time (see discussionin Section 2). Step 5 again takes O(1) optimal time.The merging process of Step 6 is discussed in detailbelow.

3.3. Merging of matchings

We describe a scheme to merge (fractional ormaximal) matchings of a given pair of subgraphs. LetGi andGj be any two subgraphs andMi andMj be

(fractional or maximal) matchings of these subgraphs.In Mi ∪Mj , each vertex has at most 2 edges incidentat it and of different colours (say one is coloured redand the other blue). In fact,Mi ∪Mj consists of listsand cycles of edges alternately coloured red and blue.Vertices adjacent to only blue (or red edges) are freein one subgraph and matched in the other subgraph.Clearly there can be no odd cycles. We can take edgesof either colour and obtain a matching; as a result,in even paths (lists) there will always be one freevertex. In paths of odd length, if edges of one colourare chosen, then there will be no free vertices and ifthe other colour is chosen then there will be two freevertices. We can use a list ranking algorithm so as toalways choose that colour for which there are no freevertices in odd paths, we will assume that this is donein the rest of the paper. The list ranking algorithmtakes O(logn) optimal time [1]. In even paths, wechoose the end point which is adjacent to fewer edgesas the free vertex. Thus any pair of matchings can be“merged” in O(logn) optimal time.

But pairwise “merging” alone (as in the abovealgorithm) does not guarantee that the set of edgesso obtained forms a maximal matching of the originalgraph (even if the original matchings were maximal).This is so because during Step 6, some verticeswhich were matched in the subgraphs earlier maynow become free. There can be some free neighboursfor these vertices and the matching may fail to bemaximal. (See Fig. 1.)

Thus we need to enlarge the matching we haveobtained so far (to get a maximal matching). For thiswe can proceed as follows. Let us assume, for the sakeof simplicity, that matchingsMi andMj are maximalin Gi andGj , respectively.

Let the set of edges in the matching obtained (so farin Step 6) beM. Remove all edges inGi andGj which

Fig. 1. Merge does not give a maximal matching: only the bold edgegets chosen.

148 K.V.R.C.N. Kishore, S. Saxena / Information Processing Letters 75 (2000) 145–151

share an end point with some edge inM and removeall isolated vertices. LetF be the set of vertices thatwere free originally (in bothGi andGj ), that is beforethe merging of Step 6. LetS be the set of verticesthat became free due to merging (in Step 6). LetE′consist of the edges ofGi ∪Gj between the verticesof F and S. Consider the graphG′ = (F ∪ S,E′).This graph is bipartite (by construction) withF andS being the bipartition. We run the bipartite maximalmatching algorithm on this graph. LetM ′ be themaximal matching returned by the bipartite maximalmatching algorithm for the graphG′. UpdateM byadding the edges ofM ′, i.e.,M becomesM ∪M ′.Step 7: Obtain a bipartite graph with the bipartition(F,S) and use the bipartite maximal matchingalgorithm to obtain a maximal matching. Here,F isthe set of vertices that were originally free andS isthe set of vertices that became free due to merging.

But even this step does not ensure that the maximalmatching is computed (even if both matchingsMi andMj were maximal). The matching may fail to coververtices ofS that do not have anyfreeneighbours. (SeeFig. 2.)

Observe that the edges added to the maximalmatching during Steps 3–7 do not share any end pointwith the edges already part of the maximal matching.

The number of vertices ofS not having free neigh-bours can be as high as the number of even paths(which can be at mostn/3; as each even path has atleast 3 vertices). Thus, the number of vertices in theauxiliary graphG′ will be at most a constant frac-tion of the number of vertices ofG. The number of

Fig. 2. Solid edges are inGi and dashed inGj . Bold edges are inrespective maximal matchings. After Step 6, verticesa,b, c will notbe covered by the matching.

edges also reduce by a constant factor (at least half).So we can use the above scheme for O(log logn) itera-tions. As a result for some constantc, the problem sizereduces ton/cO(log logn) = n/ logO(1) n. We can nowuse the non-optimal algorithm. The time required willbe tso(n,m), the time for the sub-optimal algorithm.But the cost reduces to O(Cost of Non-Optimal Algorithm

logO(1) n)

which will be optimal if the non-optimal algorithm isonly a poly-logarithmic factor away.

The complete algorithm is:

Step 1: If the graphG is uncoloured then number thevertices ofG from 0 ton− 1. These numbers willbe used as “colours”. In rest of this paper, we willassume that the graphG is (vertex) coloured withCcolours.

Step 2: Partition the edges such thate= (u, v) is keptin the graphGi iff

i =min{j | j th bit of u⊕ v = 1

}for O(log logn) iterations do

Step 3: Use prefix sums to find the number of edges(size) of eachGi .

Step 4: In parallel use a parallel algorithm for bipar-tite graphs to independently find a fractional (or amaximal) matching in eachGi .

Step 5: Pairwise merge the matchings of the sub-graphs (in a tree like manner) until a single match-ingM is left. GraphsGi andGj are merged as fol-lows:

Step 5.1: Consider the graphGij = (V ,Mi ∪Mj).Use list ranking to find the length of each path.Form a matchingMij by choosing edges ofMi

orMj (exclusive OR) in each path and cycle. Ineach odd path choose edges (ofMi or Mj ) suchthat there are no free vertices. In even paths makesure that the end point having the larger degree ismatched. In cycles, edges ofMi are chosen.

Step 5.2: Remove all edges inGi andGj whichshare an end point with some edge inMij andremove all isolated vertices. LetF be the setof vertices that were free originally (in bothGiand in Gj ) and S be the set of vertices that

K.V.R.C.N. Kishore, S. Saxena / Information Processing Letters 75 (2000) 145–151 149

became free due to merging (i.e., those whichwere matched in eitherMi or Mj but are notmatched inMij ). Let E′ consist of the edgesof Gi ∪ Gj between the vertices ofF and S.Consider the graphG′ = (F ∪ S,E′). Run thebipartite maximal matching algorithm on graphG′. LetM ′ be the maximal matching returned bythe bipartite maximal matching algorithm for thegraphG′. UpdateMij toMij ∪M ′.

Step 6: Remove all edges inG which share an endpoint with some edge inM and remove all isolatedvertices.

Step 7: Use the non-optimal algorithm to compute themaximal matching in the remaining graph.

We now analyse the time for the entire schema.Computation ofMij in Step 5.1 takes O(logn) optimaltime and Step 5.2 will taketb(n,m) time. Sincethere are O(logC) subgraphs, merging them pair-wise will take O(log logC) rounds; thus time will beO(log logC × (logn+ tb(n,m))). Further, except forthe lowest level, the pair of matchings we are mergingwill cease to be maximal. Thus, we perform Step 5.2,for the pair of matchings at the lowest level only. Withthis change, the time for Step 5 (i.e., computationof M) becomes O(log logC logn + tb(n,m)). Thisis repeated for O(log logn) iterations, thus the totaltime is O(log logn log logC logn+ log logntb(n,m)).We finally need anothertso(n,m) time to obtain themaximal matching of the original graph. Thus the totaltime is O(log logn log logC logn+ log logntb(n,m)+tso(n,m)). As after Step 5.1, the number of edges ofGi ∪Gj which do not share an end point withMij is atmost a constant factor of the edges inGi ∪Gj , at mosta constant factor of edges and vertices are left afterStep 6, thus the problem size reduces by a constantfactor in each iteration. Hence the following theoremfollows.

Theorem 1. If tb(n,m) is the time taken for comput-ing a fractional matching in a bipartite graph(i.e., amatching incident with a constant fraction of edges)and if there is atso(n,m) time algorithmA to com-pute a maximal matching in a general graph which ispoly-logarithmic away from optimality then there is anoptimal algorithm that runs inO(tb(n,m) log logn +logn(log logn)2+ tso(n,m)) time.

3.4. O(log2.5n) time optimal algorithm

Kelsen [8] shows that a matching which is incidentwith one-sixth of the edges of a bipartite graph can befound in O(log2n) optimal time on an EREW PRAM;thus tb(n,m) = O(log2n). Further Han [4] has ob-tained an O(log2.5n) time algorithm with O((n +m) log2n) cost for computing a maximal matching ina general graph; thustso(n,m) = O(log2.5n). FromTheorem 1 we have the following corollary

Corollary 1. A maximal matching of a general graphG can be found inO(log2.5n) optimal parallel time.

We can also obtain the above result directly asfollows:

InitialiseM to nilfor c log logn iterations do

(1) Find a bipartite graphG′ containing a constantfraction of edges ofG. This can be done usingHan’s algorithm [3] in O(log2n) optimal time.

(2) Find a matchingM ′ of bipartiteG′ which isincident with a constant fraction of edges.

(3) Remove all matched vertices (together withincident edges) and also remove all isolatedvertices.

Use thetso(n,m) time sub-optimal parallel algorithmto compute a maximal matchingM∗ of the resultinggraph. ThenM =M∪M∗ will be a maximal matchingfor the original graph.

This results in an O(log2n log logn + tso(n,m))

time optimal algorithm for maximal matching of ageneral graph. Combining this with Theorem 1, we get

Corollary 2. If there is a tso(n,m) time algorithmA to compute a maximal matching in a generalgraph which is poly-logarithmic away from optimal-ity then there is an optimal algorithm that runs in timeO(log logn∗(min{log2n, tb(n,m)+ logn log logn})+tso(n,m)).

Step 1 can also be done in O(logn) time withm+nprocessors [5]. If we use this implementation and carryout the algorithm for2(logn) iterations, then we willget a maximal matching (this is similar to the approachof Han [3] and Kelsen [8]). The time complexity of

150 K.V.R.C.N. Kishore, S. Saxena / Information Processing Letters 75 (2000) 145–151

this algorithm will be O(logn ∗ (tb(n,m) + logn))but with O((m + n) logn) cost. Substituting this fortso(n,m), and now using Corollary 2 we get:

Corollary 3. There is an optimal algorithm for find-ing a maximal matching in a general graph that runsin O(tb(n,m) ∗ logn+ log2n) time.

3.5. A simpler algorithm for a dense graph

In this subsection, we use the properties of de-composition to get a simpler algorithm for finding afractional matching of a dense graph, using the algo-rithm for maximal matching in a bipartite graph. As inLemma 1, letGi be the subgraph consisting of edgeswhose end points differ in theith bit. Clearly, the max-imum degree of any vertex inGi can be at mostC/2i ,orGi can have at mostnC/2i+1 edges. If we sort thegraphsGi on the number of edges they contain (indecreasing order) and take the firstc log logn graphsand merge them using Kelsen’s method [8]—i.e., ba-sically delete all vertices of the first graph from allothers, pick up the subgraph having the largest edges,find a maximal matching, include edges of the match-ing and delete all matched vertices from the remain-ing graphs etc. Then we would have deleted at leastcm log logn/ logC edges. Ifm′ is the number of edgesin the last subgraph (which was deleted), then the max-imum number of edges in theith surviving graphs willbe min{m′, (nC/2i+1)}. Or the total number of surviv-ing edges will be∑

min{m′,

(nC/2i+1)}.

If j is the index for whichm′ = nC/2j+1, then thenumber of edges which can survive is at most

(j − c log logn)m′ =m′(

log

(nC

2m′ logc n

))<

m

logClog

(nC

2m logc n

).

Now if the graph is dense, that is ifm> nCε , then thenumber of edges which can survive will be a constantfraction.

4. Final remarks

From Theorem 1, we have obtained an equation re-lating the parallel complexity of a maximal matchingin a bipartite graph and a general graph. The previ-ous fastest work-optimal parallel algorithm for com-puting a maximal matching in a bipartite graph takesO(log3n) time [8] and the previous fastest sub-optimalalgorithm for finding a maximal matching in a generalgraph takes O(log2.5n) time [4]. Also, Han [3] gave anwork-optimal O(log3n) algorithm for finding a maxi-mal matching in a general graph. Results of this paperresult in an O(log2.5n) time optimal parallel algorithmfor a maximal matching of a general (and hence) bipar-tite graph.

Discovery of a faster parallel algorithm for a maxi-mal matching in a general graph (which is only a poly-logarithmic factor away from optimal) will result in anoptimal parallel algorithm without any increase in time(see Corollary 2).

And discovery of a faster optimal parallel algorithmfor a fractional matching in a bipartite graph will resultin an almost corresponding improvement in time for anoptimal algorithm for a maximal matching of a generalgraph (see Corollary 3).

Acknowledgement

We wish to thank the referees for their usefulsuggestions, helpful comments, constructive criticismand thought-provoking questions and remarks, whichwe believe has led to removing ambiguities andcorrection of some errors in an earlier version. Bothauthors wish to thank their current organisations forallowing us to continue/complete this work.

References

[1] R.J. Anderson, G.L. Miller, Deterministic parallel list ranking,Algorithmica 6 (1991) 859–868.

[2] R. Cole, U. Vishkin, Deterministic coin tossing with applica-tions to optimal parallel list ranking, Inform. and Control 70(1986) 32–53.

[3] Y. Han, An improvement on the parallel computation of maxi-mum matching, Inform. Process. Lett. 56 (6) (1995) 343–348.

[4] Y. Han, A fast derandomization scheme and its applications,SIAM J. Comput. 25 (1) (1996) 52–82.

K.V.R.C.N. Kishore, S. Saxena / Information Processing Letters 75 (2000) 145–151 151

[5] Y. Han, Y. Igarashi, Derandomization by exploiting redundancyand mutual independence, in: Proc. Internat. Symposium SI-GAL’90, Tokyo, Japan, Lecture Notes in Comput. Sci., Vol. 450,Springer, Berlin, 1990, pp. 328–337.

[6] A. Israeli, Y. Shiloach, An improved parallel algorithm formaximal matching, Inform. Process. Lett. 22 (1986) 57–60. Seealso Inform. Proc. Lett. 22 (1986) 77–80.

[7] J. Jaja, An Introduction to Parallel Algorithms, Addison-Wesley,Reading, MA, 1992.

[8] P. Kelsen, An optimal parallel algorithm for maximal matching,Inform. Process. Lett. 52 (1994) 223–228.

[9] C.P. Kruskal, L. Rudolph, M. Snir, The power of parallel prefix,IEEE Trans. on Comput. 34 (1985) 965–968.