Abstract 1 Introduction 2 Related Work 3 Technical Overview 4 Preliminaries 5 The b-Matching Polytope 6 The Sparsification Scheme 7 Dynamic Algorithms for Maximum k-Edge Coloring 8 Conclusion References Appendix A Omitted Proofs Appendix B Related Work

On 𝒃-Matching and Fully-Dynamic Maximum 𝒌-Edge Coloring

Antoine El-Hayek ORCID Institute of Science and Technology Austria (ISTA), Klosterneuburg, Austria Kathrin Hanauer ORCID Faculty of Computer Science, University of Vienna, Austria Monika Henzinger ORCID Institute of Science and Technology Austria (ISTA), Klosterneuburg, Austria
Abstract

Given a graph G that undergoes a sequence of edge insertions and deletions, we study the Maximum k-Edge Coloring problem (MkEC): Having access to k different colors, color as many edges of G as possible such that no two adjacent edges share the same color. While this problem is different from simply maintaining a b-matching with b=k, the two problems are related. However, maximum b-matching can be solved efficiently in the static setting, whereas MkEC is NP-hard and even APX-hard for k2.

We present new results on both problems: For b-matching, we show a new integrality gap result and we adapt Wajc’s matching sparsification scheme [50] for the case where b is a constant.

Using these as basis, we give three new algorithms for the dynamic MkEC problem: Our MatchO algorithm builds on the dynamic (2+ϵ)-approximation algorithm of Bhattacharya, Gupta, and Mohan [9] for b-matching and achieves a (2+ϵ)k+1k-approximation in O(poly(logn,ϵ1)) update time against an oblivious adversary. Our MatchA algorithm builds on the dynamic (7+ϵ)-approximation algorithm by Bhattacharya, Henzinger, and Italiano [10] for fractional b-matching and achieves a (7+ϵ)3k+33k1-approximation in O(poly(logn,ϵ1)) update time against an adaptive adversary. Moreover, our reductions use the dynamic b-matching algorithm as a black box, so any future improvement in the approximation ratio for dynamic b-matching will automatically translate into a better approximation ratio for our algorithms. Finally, we present a greedy algorithm with O(Δ+k) update time, which guarantees a 2.16 approximation factor.

Keywords and phrases:
dynamic algorithm, graph algorithm, matching, b-matching, edge coloring
Copyright and License:
[Uncaptioned image] © Antoine El-Hayek, Kathrin Hanauer, and Monika Henzinger; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Graph algorithms analysis
Related Version:
Full Version: https://arxiv.org/abs/2310.01149
Funding:
This project has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (MoDynStruct, No. 101019564) margin: [Uncaptioned image] and the Austrian Science Fund (FWF) grant DOI 10.55776/Z422, grant DOI 10.55776/I5982, and grant DOI 10.55776/P33775 with additional funding from the netidee SCIENCE Stiftung, 2020–2024. This work was further supported by the Federal Ministry of Education and Research (BMBF) project, 6G-RIC: 6G Research and Innovation Cluster, grant 16KISK020K.
Editors:
Kitty Meeks and Christian Scheideler

1 Introduction

In large data centers, new technologies such as optical switches allow for quick adaptations of the network topology that are optimally tailored to current traffic demands. Indeed, network performance has been identified to be a major bottleneck for the scalability of computations in the cloud [35, 42]. Each optical switch can establish a set of direct connections between pairs of data center racks, such that each rack has a high-bandwidth connection to at most one other rack via the switch. The regular network infrastructure remains in place and can be used for all other traffic. With their fast reconfiguration time and the possibility to use multiple appliances in parallel, optical switches have become a promising means to mitigate the performance bottleneck. A major algorithmic challenge is how to configure them optimally.

Consider an undirected graph G where each node represents a data center rack and the edges indicate pairs of racks with high communication demand. We refer to G as demand graph. Each set of connections realized by a single optical switch is a matching in G, i.e., a set of pairwise node-disjoint edges, and it is desirable that this matching is large, such that a substantial amount of the traffic is routed via the high-bandwidth direct connections. For kN optical switches, the problem hence amounts to finding a collection of k pairwise edge-disjoint matchings Mi, 1ik, with maximum total cardinality i=1k|Mi|. We call this the maximum k-disjoint matching problem. Identifying each matching with a unique color, it can equivalently be rephrased as a maximum k-edge coloring problem (MkEC), where the goal is to maximize the number of colored edges. As communication demands naturally change frequently over time, we study the problem in the dynamic setting. In some situations, e.g. when remote resources such as GPUs are accessed via the network, the demand graph may be bipartite, which is why we also consider bipartite graphs.

There exists a related, but different problem, the maximum 𝐛-matching problem: for a graph G=(V,E) and 𝐛NV, find a maximum-cardinality subset of edges HE such that each vertex vV is incident to at most bv edges in H. Note that one can set bv to a constant k for all vV, but this does not yield the MkEC problem: there is no requirement that H can be edge-colored completely with k colors. Consider, e.g., a graph G=(V,E) that is a length-3 cycle. A solution H to the 𝐛-matching problem with bv=2vV contains all three edges of G, while a solution to the maximum 2-edge coloring problem can only color two edges of G. The third edge has to remain uncolored. This example shows that an optimal solution to the MkEC problem can be 1.5 times smaller than one to the 𝐛-matching problem with bv=k for all vV. Furthermore, a solution to the latter does not always give a solution to the former. In general, deciding whether a graph with maximum degree Δ can be edge-colored with Δ colors or whether Δ+1 are required is a well-known NP-hard problem [32] (Vizing [49] showed that every simple graph needs either Δ or Δ(G)+1 colors to color all edges). On bipartite graphs, however, Δ colors always suffice.

Let G=(V,E) be a graph with n=|V| and m=|E|. For the fully dynamic 𝐛-matching problem, Bhattacharya, Henzinger, and Italiano [11] gave a constant approximation algorithm with O(log3n) update time which works against an adaptive adversary. If the adversary is oblivious, there also is a (2+ϵ)-approximation with O(1/ϵ4) update time by Bhattacharya, Gupta, and Mohan [9].

The only prior work for the fully dynamic MkEC problem is an experimental analysis of various dynamic algorithms by Hanauer, Henzinger, Ost and Schmid [30], who, among others, also describe a near-linear-time, fully-dynamic 3-approximation algorithm for the weighted case. Dropping the weights, we show how to significantly improve the update time to O(poly(logn,ϵ1)) while achieving an approximation ratio to almost (2+2/k) against an oblivious adversary and (7+ϵ)(1+4/(3k1)) (for any ϵ>0) against an adaptive adversary. The problem is known to be NP-hard and even APX-hard for k2 [23].

Table 1: Previous and New Algorithms for Dynamic Maximum k-Edge-Coloring. The “Det.?” column states whether or not the algorithm is deterministic.
Algorithm Update Time Approximation Ratio Det.? Adversary Theorem Sect.
algorithms in [30] O(n) or more 3 yes
O(1) unknown no
Greedy O(k+Δ) 1+2332.155 yes 14 7.1
MatchO O(poly(logn,ϵ1)) (2+ϵ)(1+1/k) no oblivious 16 7.2.1
[Uncaptioned image]bipartite O(poly(logn,ϵ1)) (2+ϵ) no oblivious 17 7.2.1
MatchA O(poly(logn,ϵ1)) (7+ϵ)3k+33k1 no adaptive 18 7.2.2
[Uncaptioned image]bipartite O(poly(logn,ϵ1)) (7+ϵ) no adaptive 19 7.2.2
Our contributions.

We show that the integrality gap for the 𝐛-matching problem is 3β3β1 where β=minvVbv. In the case where 𝐛 is the constant vector with bv=kvV, we adapt the elegant rounding technique given by Wajc [50], who showed how to round a fractional matching to an integral matching in a dynamic graph, to round a given fractional k-matching111Whenever 𝐛 is the all-k vector for some constant k, we will refer to the problem as k-matching instead of 𝐛-matching. to an integral k-matching whose size is linear (up to polylogarithmic factors) in the size of the optimal solution.

For the dynamic MkEC problem, we describe and analyze three dynamic approximation algorithms, with different trade-offs between their update time and approximation ratio. We also give two versions specific to bipartite graphs, where the approximation ratio is improved. See Table 1 for a summary. Our algorithms MatchO and MatchA represent a general black-box reduction from dynamic maximum k-edge coloring to dynamic 𝐛-matching. Thus, any improvement in the approximation ratio of maximum 𝐛-matching immediately leads to an improvement of the approximation ratio of our algorithms.

Most proofs are only available in the appendix due to space restrictions.

2 Related Work

We only give a short overview here, see Appendix B for an extended version.

Edge Coloring.

Given a graph G of maximum degree Δ, its chromatic index χ(G) is the smallest value q such that all edges of G can be colored with q colors. Generally, Δχ(G)Δ+1 [49], whereas χ(G)=Δ [36] for bipartite graphs. Deciding whether χ(G)=Δ or χ(G)=Δ+1 is NP-hard already for Δ=3 [32], even if G is regular [38].

For an n-vertex m-edge graph G, Gabow [27] gave an O(mΔlogn)-time coloring algorithm that uses at most Δ+1 colors. Misra and Gries [41] gave an algorithm that needs O(mn) running time, and which was improved to O(mn) running time by Sinnamon [46]. A recent series of works further reduced the running time to O~(n2) (Assadi [2]), O~(mn1/3)(Bhattacharya et al. [6]), and O~(mn1/4) (Bhattacharya et al. [8]). Duan et al. [20] further reduced the time to O(mpoly(logn,ϵ1)) as long as Δ=Ω(log2nϵ2), but use up to (1+ϵ)Δ colors. For bipartite graphs, Cole et al. [19] gave an optimal algorithm with O(mlogΔ) running time. Cohen et al. [18] recently studied the problem in the online setting and proved various competitive ratio results.

For dynamic graphs, Bhattacharya et al. [7] show how to maintain a (2Δ1)-edge coloring in O(logn) worst-case update time, and that a (2+ϵ)Δ-edge coloring can be maintained with O(1/ϵ) expected update time. If Δ=Ω(log2nϵ2), Duan et al. [20] maintain an edge-coloring using (1+ϵ)Δ colors in amortized O(log8nϵ4) update time.

Maximum k-Edge Coloring.

The problem was first studied by Favrholdt and Nielsen [22] in the online setting, who show that every algorithm that never chooses to not color (“reject”) a colorable edge has a competitive ratio between 1/0.4641 and 2, and that any online algorithm is at most 47-competitive. Feige et al. [23] showed that for every k2, there exists an ϵk>0 such that it is NP-hard to approximate the problem within a ratio better than (1+ϵk). They also describe a static (1(11/k)k)1-approximation algorithm for general k. The currently best approximation ratios are 1/0.842 for k=2 and 1513 for k=3 [17, 34].

The maximum k-edge coloring problem was first studied in the edge-weighted setting by Hanauer et al. [31]. Here, instead of finding a maximum-cardinality subset of the edges, the total weight of the colored edges is to be maximized. In a follow-up work, Hanauer et al. [30] design a collection of different dynamic and batch-dynamic algorithms for weighted k-edge coloring. Their focus is again more on the practical side. Ferdous et al. [24] recently studied the problem in the streaming setting.

Matching.

The matching problem has been subject to extensive research both in the unweighted and weighted case [40, 28, 33, 26, 21]. Various dynamic algorithms with different trade-offs between update time and approximation ratio also exist for general [44, 3, 47, 43, 10, 12, 29] and bipartite graphs [14, 16]. Wajc [50] gives a metatheorem for rounding a dynamic fractional matching against an adaptive adversary and a (2+ϵ)-approximate algorithm with O(1) update time or O(poly(logn,ϵ1)) worst-case update time.

b-Matching.

Gabow [25] gives a O(b1m)-time algorithm to compute a 𝐛-matching in the unweighted, static setting, and an O(b1min(mlogn,n2))-time algorithm for weighted graphs. Ahn and Guha’s algorithm [1] computes a (1+ϵ)-approximation for 𝐛-matching and runs in O(mpoly(logn,ϵ1)) time. Bienkowski et al. [13] give an online O(logb)-approximate solution, which is asympotically optimal in the online setting.

For dynamic graphs, Bhattacharya et al. [11] give a deterministic algorithm that maintains an O(1)-approximate fractional k-matching with O(log3n) amortized update time. This is improved by Bhattacharya et al. [9], who show how to maintain an integral (2+ϵ)-approximate 𝐛-matching in expected amortized O(1/ϵ4) update time against an oblivious adversary.

3 Technical Overview

Our starting point is the following observation: The two problems 𝐛-matching and k-edge coloring seem very similar if 𝐛 is the vector having bv=k for every vertex vV. Indeed, the colored edges in a k-edge coloring form a k-matching. Vice versa, a maximum k-matching always contains a k+1k-approximate k-edge coloring, as one can always color the edges with k+1 colors and discard the least-used color. This close connection is one major ingredient for the two main algorithms we present, the dynamic MatchO and MatchA algorithms: Find a good k-matching in the graph first, then color it using as few colors as possible, and finally discard all edges of the least-used colors. The goal is to perform updates in O(poly(logn,ϵ1)) time.

Our MatchO algorithm, which works against oblivious adversaries, is a combination of known algorithms: We use the aforementioned (2+ϵ)-approximation by Bhattarcharya et al. [9] to find a k-matching. Duan et al.’s algorithm [20] colors the edges with (1+ϵ)Δ colors. Discarding the least-used colors yields a (2+ϵ)k+1k-approximation for MkEC.

For our MatchA algorithm, which is designed to work against an adaptive adversary, we could have used the so-far best algorithm for 𝐛-matching by Bhattacharya et al. [11], which however only guarantees an O(1)-approximation. The algorithm is based on a (7+ϵ)-approximate fractional 𝐛-matching algorithm, whose solution is rounded. We present an alternative rounding approach and thus obtain an improved integral k-matching algorithm that guarantees a (7+ϵ)3k3k1-approximation, which is at most (8.4+ϵ) (for k=2). Following the same scheme as for MatchO, we thus obtain a (7+ϵ)3k+33k1-approximation for MkEC.

Our new rounding technique works as follows: Given a fractional k-matching, we partition the edges of our graph by powers of (1+ϵ) according to their fractional value and maintain a 3Δ-coloring of each subgraph (which is not related to the coloring we will output). We then construct a sparsified graph by choosing a subset of colors uniformly at random and keeping only edges of these colors. Intuitively, the sparsified graph consists of those edges with high fractional values. We show that if an optimal k-edge coloring of the input graph colors s edges, then the sparsified graph contains at most O(spoly(logn,ϵ1)) edges. Running Ahn and Guha’s algorithm [1] on the sparsified graph takes O(spoly(logn,ϵ1)) time and computes an integral k-matching. We can thus afford to rerun Ahn and Guha’s algorithm every Ω(ϵs) updates and still have polylogarithmic update time. Recomputing the rounding this often also ensures the approximation ratio is still good enough. We further prove that the integrality gap of the k-matching problem is 3k3k1 and hence small. This ensures that the sparsified graph, which we show contains a large fractional k-matching, also contains a large integral k-matching, and thus that the graph output by Ahn and Guha’s algorithm is a good rounding of the original fractional matching.

We also show that the integrality gap of 𝐛-matching is small. The argument starts by noting that the integrality gap of 𝐛-matching on bipartite graphs is 1, which is a known result. We then prove that every 𝐛-matching polytope is half-integral. To do so, we build a bipartite graph that encodes the original graph. Every extremal point of the polytope of the original graph can be encoded as half the sum of two extremal points of the bipartite polytope, and thus is half-integral. Once we have a half-integral solution, we proceed to show that we can round it to an integer solution without losing much of the fractional solution. Essentially, we look at the dual variables of the 𝐛-matching, that is, for each vertex, we look at its weighted degree. We then show that while rounding, out of every carefully chosen three vertices, only one can see its degree drop, under the crucial condition that its weighted degree was already equal to bv. This allows us to prove that the integrality gap is 3β3β1, with β=minvVbv.

On bipartite graphs, many aspects of the problem become easier: the integrality gap of the b-matching algorithm, as well as the existence of efficient edge-coloring algorithms, like the one by Cole, Ost, and Schirra [19], which colors all of the edges with Δ colors in O(mpolylogn) time. This improves the approximation ratio of MatchO and MatchA to (2+ϵ) and 7(1+ϵ) respectively.

4 Preliminaries

Unless denoted otherwise, we consider an undirected, unweighted graph G=(V,E) with n:=|V| and m:=|E|. G is dynamic, that is it undergoes an a priori unknown series of updates in the form of edge insertions and edge deletions. The update time of an algorithm is the time it needs to process an update before accepting the next one. These updates are controlled by an adversary, that can be either adaptive, that is, can see the internal state of our data structure and choose the next update accordingly, or oblivious, that is, has to decide all of the updates before we start running our algorithm. G, n, and m always refer to the current graph and its number of vertices and edges, respectively, i.e., including all updates that occurred beforehand. Edges are treated as subsets of vertices of size 2. We use Δ(G) to denote the maximum vertex degree in G. If it is clear from the context, we may omit G and just write Δ.

Definition 1 (Edge Coloring).

Let G=(V,E) be a graph, kN+, and f:E[k]{} an edge coloring of the edges of G. We say that:

  1. 1.

    f is a proper coloring of E if for any adjacent edges e,e, we have that either f(e)f(e), or f(e)=f(e)=.

  2. 2.

    f is a total coloring of E if f1()=. We say it is partial to emphasize it is not necessarily total, that is, f1() may or may not be equal to .

  3. 3.

    A color c[k] is free on node v (according to f) if no edge incident to v has color c, that is, for every ev,f(e)c.

  4. 4.

    An edge e is colored if f(e)[k] and uncolored otherwise.

Given G=(V,E) and kN, the maximum k-edge coloring problem consists in finding a proper coloring f:E[k]{} of E such that the set of colored edges |f1([k])| is maximized. In the rest of this paper, unless specified otherwise, every (k-)coloring is proper and we use f to denote an arbitrary (proper) (k-)coloring, and f to denote an optimal (k-)coloring.

A matching ME is a subset of edges such that for every distinct pair e,eM, ee=. Note that given a k-edge coloring f, f1(c) is a matching for each c[k]. A set of edges ME is a k-matching if for all vV, |{eM:ev}|k. Given an n-dimensional vector 𝐛V, we say that a set of edges ME is a 𝐛-matching if for every vV, |{eM:ev}|bv. Thus, a k-matching is a 𝐛-matching where 𝐛=kV, and a matching is a 1-matching (k=1).

Theorem 2 (Coloring an Approximate k-Matching, extension of [23]).

Let G be a graph and H a subgraph such that H is a solution of an α-approximation algorithm for k-matching on G, for some α1. Let f be a total coloring of H using k+ colors, with N. Then, discarding the least used colors from f yields an (αk+k)-approximate k-edge coloring of G. In particular, if k=Δ(H) and =ϵΔ(H), the approximation ratio is α(1+ϵ).

Corollary 3.

Given a graph G, let s be the size of an optimum k-matching in G and let p be the size of an optimum k-edge coloring. Then psk+1kp.

5 The b-Matching Polytope

In this section, we will show the following theorem.

Theorem 4.

The integrality gap of the 𝐛-matching polytope is 3β3β1, where β=minvVbv. The integrality gap of the bipartite 𝐛-matching polytope is 1.

While the result on bipartite graphs was known [45], the general result does not exist in the literature to the best of our knowledge. We first show that the (fractional) 𝐛-matching polytope is half-integral222Even though the 𝐛-matching polytope is well-researched, we could not find this result in the literature., then round an optimal solution for the fractional 𝐛-matching problem to get an integral solution with a good approximation ratio.

In this section, a trail is a walk with no repeated edges (but possibly repeated nodes), a circuit is a closed trail, and an Eulerian circuit is a circuit that visits all edges.

The 𝐛-matching polytope is defined as follows:

Definition 5 (fractional 𝐛-matching polytope).

Let G=(V,E) be an undirected graph. The fractional 𝐛-matching polytope 𝒫(G) is:

𝒫(G)={𝐱[0,1]E:vVevxebv}

It is well-known that if G is bipartite, then 𝒫(G) is integral, i.e., every vertex of the polytope has integer entries:

Lemma 6 ([45]).

Let G=(V,E) be a bipartite graph. Then 𝒫(G) is integral.

We will now show that the fractional 𝐛-matching polytope over general graphs is half-integral, that is, the entries of all its vertices are in {0,12,1}. To do so, given a graph G, we build a graph G that is bipartite and show a relationship between vertices of 𝒫(G) and 𝒫(G).

Lemma 7.

Let G=(V,E) be a graph. Then 𝒫(G) is half-integral.

Next, we introduce a technique for rounding an optimal solution in 𝒫(G) to an integer solution that has similar total cost. This requires the following helper lemma:

Lemma 8.

Let G be a graph that contains no even circuit. Then G has no even cycles, and no two odd cycles in G share a node.

We also recall the Euler partition of a graph:

Definition 9 (Euler Partition).

Let G=(V,E) be a graph. A Euler Partition of G is a partition of its edges into trails and circuits such that every node of odd degree is the endpoint of exactly one trail, and every node of even degree is the endpoint of no trail.

It is easy to see that such a partition exists for every graph, as one can compute one by removing maximal trails from G until no edge remains. We now have all the tools necessary to find the integrality gap of the 𝐛-matching polytope, to which we give the proof sketch here, and the full proof in the appendix.

Theorem 4. [Restated, see original statement.]

The integrality gap of the 𝐛-matching polytope is 3β3β1, where β=minvVbv. The integrality gap of the bipartite 𝐛-matching polytope is 1.

Proof Sketch.

Since the fractional polytope is half-integral, we find an optimal fractional solution 𝐱 where all entries are in {0,12,1}. We then consider a Euler partition of the union of edges whose value is 12. First, consider all trails that start and end at different vertices, and alternatively round up and down the values of the edges. This does not affect the optimality of the solution: for each inner vertex of the trail, the same number of incident edges is rounded up and down. For each end vertex x, evxebv12, so rounding up does not violate the condition at x.

Note that all trails must have even length, otherwise 𝐱 would not be optimal. We again remove all integral edges from the subgraph, and end up with a Eulerian graph. We then apply the same strategy to every even circuit in the subgraph, until there are no more even circuits. By Lemma 8, the remaining graph is composed of disjoint odd cycles. We can thus again apply the strategy of alternatively rounding up and down the values of the edges, except that this time, there might be two consecutive edges we might need to round down, which may decrease the solution value. The worst-case scenario occurs for length-3 cycles, as the rounded solution is only 2/3 as good as the fractional solution. But this only happens when no node on the cycle can “afford” both incident edges to be rounded up, that is, all dual inequalities are tight to a 1/2 additive factor. This gives the result.

6 The Sparsification Scheme

Given a dynamic fractional k-matching algorithm 𝒜m, this section provides a sparsification scheme for fractional k-matching that enables us to give an algorithm 𝒜 that maintains an approximate integral k-matching:

Theorem 10 (Sparsify and Round).

Let G be a dynamic graph, ϵ>0, α=O(1), and 𝒜m a dynamic algorithm that maintains an α-approximate fractional k-matching of G in O(Tm) update time. Then there exists an algorithm 𝒜 that maintains an α(1+ϵ)3k3k1-approximate integral k-matching in O(Tm+poly(logn,ϵ1)) amortized update time against an adaptive adversary. If G is bipartite, the approximation ratio reduces to α(1+ϵ).

This result will be particularly useful for the MatchA algorithm in Section 7.2.2. To prove the theorem, we consider a dynamic graph G and assume we have access to a dynamic algorithm 𝒜m that has update time O(Tm) and maintains a fractional k-matching 𝐱 with approximation factor α. The goal is to maintain a sparse subgraph H of G that contains an integral k-matching whose size is within an α(1+ϵ)3k3k1 factor of the size of an optimal k-matching in G.

To this end, we separate our strategy into two schemes: the update scheme is repeated at every update, while the request scheme is only repeated when we need the sparse graph H. Our technique is an adaptation and generalization of an efficient sparsification by Wajc [50] for rounding fractional (1-)matchings to integral ones.

Update Scheme

Let 𝐱 be the fractional k-matching maintained by 𝒜m of value c(𝐱)=eExe. Let :=2log(1+ϵ)(nϵ1). We maintain subgraphs G1,,G of G, where Gi=(V,Ei) and

Ei={eE:xe((1+ϵ)i,(1+ϵ)i+1]}

Let E+=i[]Ei. Note that E+ is a subset of E and does not contain edges e such that xe(1+ϵ)=ϵ2n2. Hence, eEE+xemϵ2n2ϵ2 and we obtain

eE+xec(𝐱)ϵ2c(𝐱)(1ϵ). (1)

In each Gi, we maintain a proper, total (3k(1+ϵ)i)-edge coloring. Since in Gi, every edge satisfies xe>(1+ϵ)i, and 𝐱 is a k-matching, we know that the maximum degree of Gi can be no higher than k(1+ϵ)i. Hence, every edge modified in Gi can be colored in expected constant time333By maintaining a hash table at each vertex of the free colors, since we have more than 3Δ(Gi) colors available. By picking a color at random, we have a probability higher than 13 for this color to be free at both end nodes, and thus we only need three random picks in expectation to find a free color.. As each update of G can modify only O(Tm) edges, there are at most O(Tm) modifications in total to all subgraphs Gi. The recoloring caused by each modification can be handled in expected constant time, which implies O(Tm) expected time per update to G.

Request Scheme

We fix a parameter d:=max{1kϵ,4log(2/ϵ)kϵ2}. Whenever we need access to the sparse graph H, we obtain a set of edges Hi from each Gi by choosing uniformly at random without replacement up to kd(1+ϵ) colors, and setting Hi to be the set of edges colored with those colors. Then, H:=(V,i=1Hi). Obtaining H takes O(|H|) time.

We analyze the size of H with respect to |f1([k])|, the size of an optimal k-edge coloring in G. Let p:=|f1([k])| and s be the size of a maximum k-matching on G. Each collection of k colors in Hi creates a k-edge coloring in G, and has thus size at most p. We have O(d(1+ϵ)) such collections in Hi, and hence |Hi|=O(d(1+ϵ)p)=O(d(1+ϵ)s). Therefore,

|H|i=1|Hi|O(d(1+ϵ)s)=O(slognpoly(ϵ1)).

Together with Equation (1), Lemmas 12 and 13 below show that in expectation, H contains a fractional k-matching of total value at least c(x)(1ϵ)(16ϵ)c(x)(17ϵ). By our Integrality Gap Theorem (Theorem 4), H then contains an integral k-matching of cardinality greater than c(x)(17ϵ)3k13k. Since the fractional dynamic algorithm outputs an α-approximation c(x) of the optimal fractional solution, we have that sαc(x). Therefore H contains a k-matching of cardinality greater than 3k13k(17ϵ)s/α. We thus get the following theorem:

Theorem 11 (Sparsification).

Let G be a dynamic graph, ϵ>0, and 𝒜m a dynamic algorithm that maintains an α-approximate fractional k-matching of G in O(Tm) update time. Let s be the size of an optimal k-matching in G. Then the sparsification scheme maintains a sparsification H of G that runs in O(Tm) update time and O(spoly(logn,ϵ1)) request time. In expectation, H contains an integral k-matching of size at least s/(α3k3k1(1+ϵ)) and satisfies |H|=O(slognpoly(ϵ1)). If G is bipartite, the approximation ratio reduces to α(1+ϵ).

We now prove the Sparsify and Round Theorem:

Proof of Theorem 10.

We build the algorithm 𝒜 that maintains an approximate integral k-matching as follows: We use 𝒜m to maintain an α-approximation of a fractional k-matching in G. At a given update, we compute a sparsification H of G using Theorem 11 of size O(spoly(logn,ϵ1)) that contains an integral k-matching of size at least 1α3k3k1(1+ϵ)s. We then run the Ahn-Guha algorithm [1] on H in O(spoly(logn,ϵ1)) time to get a α3k3k1(1+O(ϵ))-approximate k-matching s of G. Since every update only changes the size of an optimal solution by at most 1, the computed k-matching remains a good approximation of the optimal solution over the next ϵs updates, which yields an amortized update time of O(poly(logn,ϵ1)).

Next, we state Lemmas 12 and 13, whose proofs are given in the appendix.

Lemma 12.

Let iN, and Gi=(V,Ei) be a graph. Let x be a fractional k-matching on Gi that satisfies xe((1+ϵ)i,(1+ϵ)i+1], and d1kϵ. If d(1+ϵ)i1, set Hi:=Ei. Otherwise, let fi be a total (3k(1+ϵ)i)-edge coloring of Gi. Sample 3kd colors uniformly at random (without replacement), and set Hi to be the set of all edges colored by one of the sampled colors. Then each edge e is sampled with probability P[eHi] such that

min{1,xed}(1+ϵ)2P[eHi]min{1,xed}(1+ϵ). (2)

Then, if xe>1d, P[eHi]=1. Moreover, any two adjacent edges are negatively associated, that is, for any edges e and e that share a node, we have P[Xe|Xe]P[Xe]. Furthermore, the random variables {[Xe|Xe]ev} are negatively associated for any vV,ev.

Lemma 13 (Sparsification).

Let x be a fractional k-matching on a graph G, ϵ(0,12), and dmax{1kϵ,4log(2/ϵ)kϵ2}. Let H be a subgraph of G, where each edge of G is sampled with probability P[eH], where P[eH]=1 if xe>1d and

min{1,xed}(1+ϵ)2P[eH]min{1,xed}(1+ϵ). (3)

Let Xe:=1[eH]. The edges need not be sampled independently, however two edges that are adjacent need to be negatively associated, that is, for any edges e and e that share a node, we have P[Xe|Xe]P[Xe]. We also require that for any vG,ev, the random variables {[Xe|Xe]|ev} are negatively associated. Then, H has a fractional k-matching 𝐲 of expected value at least

E[eye]exe(16ϵ).

7 Dynamic Algorithms for Maximum k-Edge Coloring

7.1 The Greedy Algorithm

Our first algorithm follows a simple greedy scheme: If an edge is added to the graph, we only check whether there is a common free color available at both its end nodes, and if it is the case, we color this edge with that color, otherwise we do nothing. If an edge colored c is removed from the graph, we try to color one edge adjacent to each of its end nodes with color c. This keeps the coloring maximal, and is thus a (1+233)-approximation, as shown by Favrholdt and Nielsen [22]. If we maintain a table of free colors at every vertex, each insertion takes O(min{k,Δ}) time, as we have to go through all used colors at the endpoints to find a free one. Every edge deletion takes O(Δ) time, as we have to check whether the color c is free at the end of 2Δ edges in the worst case.

Theorem 14 (Greedy Algorithm).

The Greedy algorithm is deterministic and maintains a (1+2332.155)-approximation of a maximum k-edge coloring in O(Δ) update time.

Note that in the case of bounded arboricity, one can maintain an orientation of the graph such that the out-degree of each node is at most a multiple of the arboricity, as shown by Chekuri et al. [15], in polylogarithmic time. In this case, each vertex is “responsible” for letting neighboring out-vertices know about its available colors. In that case, the update time drops to O(c), where c is the arboricity of the graph, as the limiting factor now is not finding a suitable color for an edge, but rather updating the available colors on each vertex.

7.2 The Amortized Algorithms

Our next two algorithms rely on k-matchings. The idea is to maintain an approximate k-matching, and have it totally colored. However, as coloring can be expensive, we will not use the coloring algorithm at every update, but rather only once over multiple rounds, so we can amortize its cost. The following lemma formalizes the amortization technique:

Lemma 15 (Amortization).

Let ϵ>0, and assume we compute a coloring f that colors p:=|f1([k])| edges of a graph G. Then assume we have up to ϵp edge insertions and deletions to G. Define a coloring g on G as follows: g(e):=f(e) if e was already in G before the modifications, and g(e):= otherwise. Then if f is an α-approximation of maximum k-edge coloring before the updates, g is a α(1+3ϵ)-approximation after the updates if ϵ13.

7.2.1 The MatchO Algorithm

If the updates to the graph are controlled by an oblivious adversary, we can use Bhattacharya, Gupta, and Mohan’s algorithm [9] for dynamic 𝐛-matching. They maintain an integral (2+ϵ)-approximation of 𝐛-matching against an oblivious adversary in O(ϵ4) update time.

Our MatchO algorithm works as follows: We use Bhattacharya et al.’s algorithm to maintain a (2+ϵ)-approximation for k-matching, which is represented by a graph H. Then, we compute a (k+1)-edge coloring using Gabow’s coloring algorithm [27] on H, and discard the least used color to obtain a (2+ϵ)k+1k-approximation f of a k-edge coloring, guaranteed by Theorem 2. We refrain from recomputing the coloring for the next ϵ|f1([k])| updates, while continuing to update the k-matching after each update operation. By the Amortization Lemma (Lemma 15), this yields a (1+3ϵ)(2+ϵ)k+1k-approximation, which is a (2+5ϵ)k+1k-approximation if ϵ13. This is particularily efficient if Δ(H)=O(log2nϵ2).

If on the other hand Δ(H)=Ω(log2nϵ2), using the edge-coloring by Duan, He, and Zhang [20], we color all the edges of H with (1+ϵ)Δ(H) colors. Discarding the ϵΔ(H) colors that color the fewest edges among them, this yields a (2+O(ϵ)) approximation of the maximum k-edge coloring by Theorem 2.

Running time analysis. Let s be the size of H at the time of recoloring. Computing the recoloring (whether it is a (k+1) or (1+ϵ)Δ(H)-edge coloring) and removing the least used color(s) gives a k-edge coloring f of size at least kk+1s. Thus, sk+1k|f1([k])|=O(|f1([k])|).

Let us now analyze the amortized update time. For each update, we spend O(ϵ4) time to maintain the k-matching. If Δ(H)=O(log2nϵ2), coloring the k-matching with Gabow’s algorithm takes O(sΔ(H)logn)=O(spoly(logn,ϵ1)) time. If on the other hand Δ(H)=Ω(log2nϵ2), coloring the k-matching with Duan, He, and Zhang’s algorithm takes O(spoly(logn,ϵ1)) time. Either way, this can be amortized over the next ϵ|f1([k])| updates, yielding an amortized update time of O(poly(logn,ϵ1)) for the complete algorithm.

We hence have the following result:

Theorem 16 (MatchO Algorithm).

Against an oblivious adversary, the MatchO algorithm runs in O(poly(logn,ϵ1)) amortized update time and maintains a k-edge coloring that is in expectation a (2+ϵ)k+1k-approximation.

In the case of a bipartite graph, we can color the k-matching with k colors in O(mlogk) time using the algorithm by Cole, Ost, and Schirra [19] instead of either Gabow’s or Duan, He, and Zhang’s algorithm. This yields a better approximation ratio:

Theorem 17 (Bipartite MatchO Algorithm).

Against an oblivious adversary, the bipartite MatchO algorithm runs in O(poly(logn,ϵ1)) amortized update time and maintains a k-edge coloring that is in expectation a (2+ϵ)-approximation.

7.2.2 The MatchA Algorithm

If the updates to the graph are controlled by an adaptive adversary, we can use Bhattacharya, Henzinger and Italiano’s [11] algorithm for fractional 𝐛-matching. They maintain an (7+ϵ)-approximate fractional 𝐛-matching of the dynamic graph in O(log(m+n)ϵ2) time against an adaptive adversary.

Our MatchA algorithm works as follows: We use Bhattacharya et al.’s algorithm as described in Section 6 to maintain a sparsification H of G. By the Sparsify and Round Theorem (Theorem 10), this takes O(log(m+n)ϵ2) update time and O(|H|) time to output H when requested. Let f be an optimal k-edge coloring of G of size p:=|f1([k])|. By Theorem 10, H in expectation contains an integral k-matching of size at least p/(73k3k1(1+ϵ)) and |H|=O(plognpoly(ϵ1)).

Similarly to the case with an oblivious adversary, we will only compute a coloring in few, carefully selected rounds, and thus will not need to access H in every round. More specifically, we use the amortization technique from Lemma 15 to determine in which rounds to recolor H for the current graph. To recolor we run Ahn and Guha’s static algorithm for 𝐛-matching [1] on H to compute a (1+ϵ)-approximate (integral) k-matching H of H. This ensures that the sparse graph has degree at most k. Finally, we either compute a (k+1)-edge coloring using Gabow’s algorithm for edge-coloring [27] of H, if Δ(H)=O(log2nϵ2), or a (1+ϵ)Δ(H)-edge coloring using Duan, He, and Zhang’s Algorithm otherwise, and discard the least used colors to obtain a 7(1+ϵ)3k3k1k+1k-approximation f of the maximum cardinality k-edge coloring of G.

We refrain from recomputing the coloring for the next ϵ|f1([k])| updates, while continuing to maintain the k-matching. By Lemma 15, this yields an 7(1+3ϵ)(1+ϵ)3k+33k1-approximation f of the current f, which is an 7(1+5ϵ)3k+33k1-approximation if ϵ13.

Running time analysis. Let us analyze the amortized update time. For each update, we must first spend O(lognpoly(ϵ1)) time to maintain the fractional k-matching and its sparsification. Requesting the sparse graph H takes O(|H|) time. Finding a k-matching in it takes O(|H|poly(logn,ϵ1)) time [1]. Let s be the size of that k-matching after the current update. Coloring the k-matching with either Gabow’s or Duan, He, and Zhang’s algorithm takes O(spoly(logn,ϵ1)) time. Thus the total time for all updates in an interval starting at a recoloring and containing all updates up to the next recoloring is O((s+|H|)poly(logn,ϵ1)).

Let s be the size of the optimum k-matching after the current update. Recall that sk+1kp by Corollary 3. Thus, we have that ssk+1kp=O(p). We also have |H|=O(plognpoly(ϵ1)). Hence, the total update time in an interval is O(ppoly(logn,ϵ1))

Note also that |f1([k])|=O(|f1([k])|) as we recolor every ϵ|f1([k])| updates and each update changes the size of the k-edge coloring by at most one. Thus it follows that

p7(1+5ϵ)3k+33k1|f1([k])|=O(|f1([k])|)=O(|f1([k])|).

Hence we can amortize the total update time of an interval over the length of an interval, which consists of ϵ|f1([k])| updates, to achieve an amortized update time of O(kpoly(logn,ϵ1)), resulting in the following theorem.

Theorem 18 (MatchA Algorithm).

Against an adaptive adversary, the MatchA algorithm runs in expected O(poly(logn,ϵ1)) amortized update time and maintains a k-edge coloring that is in expectation a 7(1+ϵ)3k+33k1-approximation.

Similarly to the previous section, in the case of a bipartite graph, we can color the k-matching with k colors in O(mlogk) time using Cole, Ost, and Schirra’s algorithm [19] instead of either Gabow’s or that of Duan, He, and Zhang. This also drops the k+1k factor in the approximation computation above. Moreover, the integrality gap for the k-matching becomes 1, removing the 3k3k1 factor. This yields a better approximation ratio:

Theorem 19 (Bipartite MatchA Algorithm).

Against an adaptive adversary, the bipartite MatchA algorithm runs in expected O(poly(logn,ϵ1)) amortized update time and maintains a k-edge coloring that is in expectation an 7(1+ϵ)-approximation.

8 Conclusion

In this work, we have initiated the study of fully dynamic approximation algorithms for the NP-hard k-edge coloring problem by presenting and analyzing three dynamic algorithms. Moreover, we have demonstrated the close relationship between 𝐛-matching and k-edge coloring, making any advances in 𝐛-matching to automatically translate into better results for k-edge coloring. In the future, it would be thus interesting to investigate more into 𝐛-matching algorithms. In particular there is space for improvement in finding dynamic (fractional or not) 𝐛-matching algorithms against an adaptive adversary with approximation ratio better than 7 which still run in polylogarithmic time.

References

  • [1] Kook Jin Ahn and Sudipto Guha. Near linear time approximation schemes for uncapacitated and capacitated b-matching problems in nonbipartite graphs. In Chandra Chekuri, editor, Proceedings of the Twenty-Fifth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2014, Portland, Oregon, USA, January 5-7, 2014, pages 239–258. SIAM, 2014. doi:10.1137/1.9781611973402.18.
  • [2] Sepehr Assadi. Faster vizing and near-vizing edge coloring algorithms. In Proceedings of the 2025 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 4861–4898. SIAM, 2025. doi:10.1137/1.9781611978322.165.
  • [3] Surender Baswana, Manoj Gupta, and Sandeep Sen. Fully dynamic maximal matching in O (log n) update time. In Rafail Ostrovsky, editor, IEEE 52nd Annual Symposium on Foundations of Computer Science, FOCS 2011, Palm Springs, CA, USA, October 22-25, 2011, pages 383–392. IEEE Computer Society, 2011. doi:10.1109/FOCS.2011.89.
  • [4] Soheil Behnezhad. Time-optimal sublinear algorithms for matching and vertex cover. In 62nd IEEE Annual Symposium on Foundations of Computer Science, FOCS 2021, Denver, CO, USA, February 7-10, 2022, pages 873–884. IEEE, 2021. doi:10.1109/FOCS52979.2021.00089.
  • [5] Aaron Bernstein, Aditi Dudeja, and Zachary Langley. A framework for dynamic matching in weighted graphs. In Samir Khuller and Virginia Vassilevska Williams, editors, STOC ’21: 53rd Annual ACM SIGACT Symposium on Theory of Computing, Virtual Event, Italy, June 21-25, 2021, pages 668–681. ACM, 2021. doi:10.1145/3406325.3451113.
  • [6] Sayan Bhattacharya, Din Carmon, Martín Costa, Shay Solomon, and Tianyi Zhang. Faster (Δ+1)-edge coloring: Breaking the mn time barrier. In 65th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2024, Chicago, IL, USA, October 27-30, 2024, pages 2186–2201. IEEE, 2024. doi:10.1109/FOCS61266.2024.00128.
  • [7] Sayan Bhattacharya, Deeparnab Chakrabarty, Monika Henzinger, and Danupon Nanongkai. Dynamic algorithms for graph coloring. In Artur Czumaj, editor, Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2018, New Orleans, LA, USA, January 7-10, 2018, pages 1–20. SIAM, 2018. doi:10.1137/1.9781611975031.1.
  • [8] Sayan Bhattacharya, Martín Costa, Shay Solomon, and Tianyi Zhang. Even faster (δ+ 1)-edge coloring via shorter multi-step vizing chains. In Proceedings of the 2025 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 4914–4947. SIAM, 2025. doi:10.1137/1.9781611978322.167.
  • [9] Sayan Bhattacharya, Manoj Gupta, and Divyarthi Mohan. Improved algorithm for dynamic b-matching. In Kirk Pruhs and Christian Sohler, editors, 25th Annual European Symposium on Algorithms, ESA 2017, September 4-6, 2017, Vienna, Austria, volume 87 of LIPIcs, pages 15:1–15:13. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2017. doi:10.4230/LIPIcs.ESA.2017.15.
  • [10] Sayan Bhattacharya, Monika Henzinger, and Giuseppe F. Italiano. Deterministic fully dynamic data structures for vertex cover and matching. In Piotr Indyk, editor, Proceedings of the Twenty-Sixth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2015, San Diego, CA, USA, January 4-6, 2015, pages 785–804. SIAM, 2015. doi:10.1137/1.9781611973730.54.
  • [11] Sayan Bhattacharya, Monika Henzinger, and Giuseppe F. Italiano. Dynamic algorithms via the primal-dual method. Inf. Comput., 261:219–239, 2018. doi:10.1016/j.ic.2018.02.005.
  • [12] Sayan Bhattacharya, Monika Henzinger, and Danupon Nanongkai. New deterministic approximation algorithms for fully dynamic matching. In Daniel Wichs and Yishay Mansour, editors, Proceedings of the 48th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2016, Cambridge, MA, USA, June 18-21, 2016, pages 398–411. ACM, 2016. doi:10.1145/2897518.2897568.
  • [13] Marcin Bienkowski, David Fuchssteiner, and Stefan Schmid. Optimizing reconfigurable optical datacenters: The power of randomization. In Dorian Arnold, Rosa M. Badia, and Kathryn M. Mohror, editors, Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, SC 2023, Denver, CO, USA, November 12-17, 2023, pages 83:1–83:11. ACM, 2023. doi:10.1145/3581784.3607057.
  • [14] Bartlomiej Bosek, Dariusz Leniowski, Piotr Sankowski, and Anna Zych. Online bipartite matching in offline time. In 55th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2014, Philadelphia, PA, USA, October 18-21, 2014, pages 384–393. IEEE Computer Society, 2014. doi:10.1109/FOCS.2014.48.
  • [15] Chandra Chekuri, Aleksander Bjørn Grodt Christiansen, Jacob Holm, Ivor van der Hoog, Kent Quanrud, Eva Rotenberg, and Chris Schwiegelshohn. Adaptive out-orientations with applications. In David P. Woodruff, editor, Proceedings of the 2024 ACM-SIAM Symposium on Discrete Algorithms, SODA 2024, Alexandria, VA, USA, January 7-10, 2024, pages 3062–3088. SIAM, 2024. doi:10.1137/1.9781611977912.110.
  • [16] Li Chen, Rasmus Kyng, Yang P. Liu, Richard Peng, Maximilian Probst Gutenberg, and Sushant Sachdeva. Maximum flow and minimum-cost flow in almost-linear time. In 63rd IEEE Annual Symposium on Foundations of Computer Science, FOCS 2022, Denver, CO, USA, October 31 - November 3, 2022, pages 612–623. IEEE, 2022. doi:10.1109/FOCS54457.2022.00064.
  • [17] Zhi-Zhong Chen, Sayuri Konno, and Yuki Matsushita. Approximating maximum edge 2-coloring in simple graphs. Discret. Appl. Math., 158(17):1894–1901, 2010. doi:10.1016/J.DAM.2010.08.010.
  • [18] Ilan Reuven Cohen, Binghui Peng, and David Wajc. Tight bounds for online edge coloring. In David Zuckerman, editor, 60th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2019, Baltimore, Maryland, USA, November 9-12, 2019, pages 1–25. IEEE Computer Society, 2019. doi:10.1109/FOCS.2019.00010.
  • [19] Richard Cole, Kirstin Ost, and Stefan Schirra. Edge-coloring bipartite multigraphs in O(E log D) time. Comb., 21(1):5–12, 2001. doi:10.1007/s004930170002.
  • [20] Ran Duan, Haoqing He, and Tianyi Zhang. Dynamic edge coloring with improved approximation. In Timothy M. Chan, editor, Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2019, San Diego, California, USA, January 6-9, 2019, pages 1937–1945. SIAM, 2019. doi:10.1137/1.9781611975482.117.
  • [21] Ran Duan and Seth Pettie. Approximating maximum weight matching in near-linear time. In 51th Annual IEEE Symposium on Foundations of Computer Science, FOCS 2010, October 23-26, 2010, Las Vegas, Nevada, USA, pages 673–682. IEEE Computer Society, 2010. doi:10.1109/FOCS.2010.70.
  • [22] Lene M. Favrholdt and Morten N. Nielsen. On-line edge-coloring with a fixed number of colors. Algorithmica, 35(2):176–191, 2003. doi:10.1007/s00453-002-0992-3.
  • [23] Uriel Feige, Eran Ofek, and Udi Wieder. Approximating maximum edge coloring in multigraphs. In Klaus Jansen, Stefano Leonardi, and Vijay V. Vazirani, editors, Approximation Algorithms for Combinatorial Optimization, 5th International Workshop, APPROX 2002, Rome, Italy, September 17-21, 2002, Proceedings, volume 2462 of Lecture Notes in Computer Science, pages 108–121. Springer, 2002. doi:10.1007/3-540-45753-4_11.
  • [24] S. M. Ferdous, Bhargav Samineni, Alex Pothen, Mahantesh Halappanavar, and Bala Krishnamoorthy. Semi-streaming algorithms for weighted k-disjoint matchings. In Timothy M. Chan, Johannes Fischer, John Iacono, and Grzegorz Herman, editors, 32nd Annual European Symposium on Algorithms, ESA 2024, September 2-4, 2024, Royal Holloway, London, United Kingdom, volume 308 of LIPIcs, pages 53:1–53:19. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPICS.ESA.2024.53.
  • [25] Harold N. Gabow. An efficient reduction technique for degree-constrained subgraph and bidirected network flow problems. In David S. Johnson, Ronald Fagin, Michael L. Fredman, David Harel, Richard M. Karp, Nancy A. Lynch, Christos H. Papadimitriou, Ronald L. Rivest, Walter L. Ruzzo, and Joel I. Seiferas, editors, Proceedings of the 15th Annual ACM Symposium on Theory of Computing, 25-27 April, 1983, Boston, Massachusetts, USA, pages 448–456. ACM, 1983. doi:10.1145/800061.808776.
  • [26] Harold N. Gabow. Data structures for weighted matching and nearest common ancestors with linking. In David S. Johnson, editor, SODA 1990, 22-24 January, San Francisco, CA, USA, pages 434–443. SIAM, 1990. URL: http://dl.acm.org/citation.cfm?id=320176.320229.
  • [27] Harold N Gabow, Takao Nishizeki, Oded Kariv, Daniel Leven, and Osamu Terada. Algorithms for edge-coloring. In Technical report 41/85. Tel Aviv University, 1985.
  • [28] Harold N. Gabow and Robert Endre Tarjan. Faster scaling algorithms for general graph-matching problems. J. ACM, 38(4):815–853, 1991. doi:10.1145/115234.115366.
  • [29] Manoj Gupta and Richard Peng. Fully dynamic (1+ e)-approximate matchings. In 54th Annual IEEE Symposium on Foundations of Computer Science, FOCS 2013, 26-29 October, 2013, Berkeley, CA, USA, pages 548–557. IEEE Computer Society, 2013. doi:10.1109/FOCS.2013.65.
  • [30] Kathrin Hanauer, Monika Henzinger, Lara Ost, and Stefan Schmid. Dynamic demand-aware link scheduling for reconfigurable datacenters. In IEEE INFOCOM 2023 - IEEE Conference on Computer Communications, New York City, NY, USA, May 17-20, 2023, pages 1–10. IEEE, 2023. doi:10.1109/INFOCOM53939.2023.10229050.
  • [31] Kathrin Hanauer, Monika Henzinger, Stefan Schmid, and Jonathan Trummer. Fast and heavy disjoint weighted matchings for demand-aware datacenter topologies. In IEEE INFOCOM 2022 - IEEE Conference on Computer Communications, London, United Kingdom, May 2-5, 2022, pages 1649–1658. IEEE, 2022. doi:10.1109/INFOCOM48880.2022.9796921.
  • [32] Ian Holyer. The NP-completeness of edge-coloring. SIAM J. Comput., 10(4):718–720, 1981. doi:10.1137/0210055.
  • [33] John E. Hopcroft and Richard M. Karp. An n5/2 algorithm for maximum matchings in bipartite graphs. SIAM J. Comput., 2(4):225–231, 1973. doi:10.1137/0202019.
  • [34] Marcin Jakub Kaminski and Lukasz Kowalik. Beyond the vizing’s bound for at most seven colors. SIAM J. Discret. Math., 28(3):1334–1362, 2014. doi:10.1137/120899765.
  • [35] Mehrdad Khani, Manya Ghobadi, Mohammad Alizadeh, Ziyi Zhu, Madeleine Glick, Keren Bergman, Amin Vahdat, Benjamin Klenk, and Eiman Ebrahimi. SiP-ML: high-bandwidth optical network interconnects for machine learning training. In Proceedings of the ACM SIGCOMM, pages 657–675, 2021.
  • [36] Dénes König. Über Graphen und ihre Anwendung auf Determinantentheorie und Mengenlehre. Mathematische Annalen, 77(4):453–465, 1916.
  • [37] Adrian Kosowski. Approximating the maximum 2- and 3-edge-colorable subgraph problems. Discret. Appl. Math., 157(17):3593–3600, 2009. doi:10.1016/j.dam.2009.04.002.
  • [38] Daniel Leven and Zvi Galil. NP completeness of finding the chromatic index of regular graphs. J. Algorithms, 4(1):35–44, 1983. doi:10.1016/0196-6774(83)90032-9.
  • [39] L. Lovasz and M. D. Plummer. Matching Theory, volume 121 of North-Holland Mathematics Studies. Elsevier Science Ltd., 1986.
  • [40] Silvio Micali and Vijay V. Vazirani. An o(sqrt(|v|) |e|) algorithm for finding maximum matching in general graphs. In 21st Annual Symposium on Foundations of Computer Science, Syracuse, New York, USA, 13-15 October 1980, pages 17–27. IEEE Computer Society, 1980. doi:10.1109/SFCS.1980.12.
  • [41] Jayadev Misra and David Gries. A constructive proof of vizing’s theorem. Inf. Process. Lett., 41(3):131–133, 1992. doi:10.1016/0020-0190(92)90041-S.
  • [42] Jeffrey C Mogul and Lucian Popa. What we talk about when we talk about cloud network performance. ACM SIGCOMM Computer Communication Review, 42(5):44–48, 2012. doi:10.1145/2378956.2378964.
  • [43] Ofer Neiman and Shay Solomon. Simple deterministic algorithms for fully dynamic maximal matching. In Dan Boneh, Tim Roughgarden, and Joan Feigenbaum, editors, Symposium on Theory of Computing Conference, STOC’13, Palo Alto, CA, USA, June 1-4, 2013, pages 745–754. ACM, 2013. doi:10.1145/2488608.2488703.
  • [44] Krzysztof Onak and Ronitt Rubinfeld. Maintaining a large matching and a small vertex cover. In Leonard J. Schulman, editor, Proceedings of the 42nd ACM Symposium on Theory of Computing, STOC 2010, Cambridge, Massachusetts, USA, 5-8 June 2010, pages 457–464. ACM, 2010. doi:10.1145/1806689.1806753.
  • [45] Alexander Schrijver et al. Combinatorial optimization: polyhedra and efficiency, volume 24. Springer, 2003.
  • [46] Corwin Sinnamon. A randomized algorithm for edge-colouring graphs in o(mn) time. CoRR, abs/1907.03201, 2019. arXiv:1907.03201.
  • [47] Shay Solomon. Fully dynamic maximal matching in constant update time. In Irit Dinur, editor, IEEE 57th Annual Symposium on Foundations of Computer Science, FOCS 2016, 9-11 October 2016, Hyatt Regency, New Brunswick, New Jersey, USA, pages 325–334. IEEE Computer Society, 2016. doi:10.1109/FOCS.2016.43.
  • [48] Daniel Stubbs and Virginia Vassilevska Williams. Metatheorems for dynamic weighted matching. In Christos H. Papadimitriou, editor, 8th Innovations in Theoretical Computer Science Conference, ITCS 2017, January 9-11, 2017, Berkeley, CA, USA, volume 67 of LIPIcs, pages 58:1–58:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2017. doi:10.4230/LIPIcs.ITCS.2017.58.
  • [49] Vadim G Vizing. On an estimate of the chromatic class of a p-graph. Discret. Analiz., 3:25–30, 1964.
  • [50] David Wajc. Rounding dynamic matchings against an adaptive adversary. In Konstantin Makarychev, Yury Makarychev, Madhur Tulsiani, Gautam Kamath, and Julia Chuzhoy, editors, Proccedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing, STOC 2020, Chicago, IL, USA, June 22-26, 2020, pages 194–207. ACM, 2020. doi:10.1145/3357713.3384258.

Appendix A Omitted Proofs

Proof of Theorem 2.

Let s be the size of an optimum k-matching in G and let p be the size of an optimum k-edge coloring. Since any k-edge coloring is a k-matching, we have that ps. Let s=|H|. The colors that color the smallest number of edges color at most k+s edges, otherwise the average of colored edges by color exceeds s+k. Let p be the number of edges colored by the remaining colors. Then pkk+skk+1αskk+1αp.

Proof of Theorem 4.

Since the 𝐛-matching polytope is half-integral, we can find an optimal fractional b-matching 𝐱 of G=(V,E) such that 𝐱 is half-integral. Let H=(V,Ep) be the subgraph of G with Ep={eE:xe{0,1}}. If Ep=, x is integral.

Otherwise, consider an Euler partition of H. If it contains a trail T which starts and ends at different nodes, write T={e1,,e|T|} where each ei is adjacent to ei+1. Let 𝐱+ be defined by

xe+:={xeifeT,xe+12(1)i+1ife=ei,

i.e., we alternatingly round up and down by 12 along the trail. We clearly have that 𝐱+𝒫(G), since 𝐱[0,1]m and for each node vV except the endpoints of T, an equal number of edges incident to v is rounded up and down. An end point v of the trail might have at most one more edge that sees its value increase than decrease by 12. Since the node v is of odd degree in Ep, we have that evxebv12, which implies evxe+bv, i.e. the condition is still satisfied. We moreover have that exeexe+.

We can, hence, reduce the number of nodes of odd degree in Ep by creating solutions that are as good as 𝐱 that have fewer and fewer odd degree nodes. We end up with H having only even degree nodes. By Euler’s Theorem, there exists an Euler Circuit on every connected component of H.

For every node u, let x(u):=euxe, and let C be a connected component of H. If there exists a node uC such that x(u)<𝐛u, then x(u)𝐛u1, and we can write the connected component C={e1,,e|C|} as an Eulerian circuit where each ei is adjacent to e(i+1)mod|C|, and where e1 is adjacent to u. Then define:

xe+:={xeifeCxe+12(1)i+1ife=ei

We clearly have that 𝐱+𝒫(G), since 𝐱[0,1]m, and for each node vV except for u, we have that the number of edges adjacent to v losing 12 is equal to the number of edges adjacent to v winning 12 canceling out. Node u has at most two more edge that sees its value increase than decrease by 12. Since x(u)bu1, we have euxe+bu, the condition is still satisfied. We moreover have that exeexe+.

We can also show that even if no uC satisfies x(u)<bu, but C has an even number of nodes, the number of edges in the component is even, and thus the Eulerian circuit of C is of even length, and thus computing 𝐱+ as above will yield an integer solution on C. Note as well that if C is of size 1, then C contains no edges and x is already integral on C.

We end up with connected components C1,,C of odd size at least 3, where every node ui[]Ci satisfies x(u)=bu. Each Ci can be seen as an Eulerian circuit. We will now build an integer solution 𝐱 that approximates 𝐱. For every i[], pick an arbitrary node uiCi, and write Ci={e1i,,e|Ci|i} where each eji is adjacent to ej+1mod|C|i, and where e1i is adjacent to ui. Define then:

xe:={xeifei[]Cixe+12(1)jife=eji

We clearly have that 𝐱𝒫(G), since 𝐱[0,1]m and for each node vV, we have that the number of edges adjacent to v losing 12 is larger than the number of edges adjacent to v winning 12, and thus evxeevxebv. We moreover have that

exe =12vV𝐱(v)=12vVi[]Cix(v)+12i[](x(ui)1+vCi,vuix(v))
12vVi[]Cix(v)+12i[](𝐛ui1+vCi,vuibv)
=12vVi[]Cix(v)+12i[](1+vCibv).

However, we have that vCibv|Ci|β and that for each i[], |Ci|3 and thus 13|i[]Ci|. Therefore:

12i[](1+vCibv)l+12i[l]vCibv(113β)12i[l]vCibv=(113β)12i[l]vCix(v)

Hence,

exe12vVi[]Cix(v)+(113β)12i[l]vCix(v)(113β)12vVx(v).

Since 𝐱 is integral, the theorem follows.

Proof of Lemma 7.

Let us write V={v1,,vn} and E={e1,,em}. Define G=(V,E), where V={v1,vn,v1′′,,vn′′}, and E={e1,,em,e1′′,,em′′}, where for each i[m], if ei=(vj,v) for some j,[n], then ei and ei′′ are defined as ei=(vj,v′′) and ei′′=(vj′′,v). Define b such that bvi=bvi′′=bvi for all i.

Let 𝐱 be a vertex of 𝒫(G). Then 𝐲, defined as yei=yei′′=xei for every i[m], satisfies 𝐲𝒫(G). Indeed, for every i[n] we have that vieye=vi′′eye=viexebvi.

Since 𝐲𝒫(G), and G is bipartite, by Lemma 6, 𝐲 is a convex combination of some 𝐲(1),,𝐲() such that for each 1j it holds that 𝐲(j)𝒫(G) and all entries of 𝐲(j) are in {0,1}. Let λ1,,λ[0,1] such that y=j[]λj𝐲(j), and define for every j[], 𝐱(j) such that xei(j)=12(yei(j)+yei′′(j)) for every i[m], which is half-integer. Note that for every i[m], xei=12(yei+yei′′)=12j[]λj(yei(j)+yei′′(j))=j[]λjxei(j) and, hence, 𝐱=j[]λj𝐱(j). Thus, 𝐱 is a convex combination of 𝐱(1),,𝐱(). We are left with showing that 𝐱(j) belongs to 𝒫(G) for every 1j. To do so note that for every i[n],j[],

viexe(j)=12vieye(j)+ye′′(j)=12(vieye(j)+vi′′e′′ye′′(j))bvi,

which implies that 𝐱(j)𝒫(G). Since 𝐱 is a vertex of 𝒫(G) and a convex combination of 𝐱(1),,𝐱(), it must be equal to one of them, say 𝐱=𝐱(j) for some j[], and thus is half-integral.

Proof of Lemma 8.

Since every even cycle is an even circuit, it is straightforward to see that G has no even cycle. Let us now assume that there exist two odd cycles C1 and C2 that share a node u in G. Suppose that C1 and C2 share no edge. Then, the circuit that starts at u and visits the first cycle, then the second, is an even circuit, a contradiction. Thus, C1 and C2 share at least one edge. Let {v,w} be a shared edge such that the other neighbor of w in C1 is different from its neighbor in C2 (this edge must exists otherwise C1=C2). Consider the path in C2 from w to v that does not go through {v,w}. This path ends in C1. Let v denote the first node on that path that is different from w and is in C1. We now have three edge-disjoint paths from w to v: two in C1 and one in C2. Two of them must have the same parity and thus together form an even circuit.

Proof of Lemma 12.

Wajc [50] has proven that choosing edges using that method (that is, choosing colors uniformly at random then picking all edges of those colors in a proper coloring) ensures that any two adjacent edges are negatively associated, and that for any vV,ev, the random variables {[Xe|Xe]ev} are negatively associated. Let e be an edge of Ei. We have three cases:

Case 1: If d(1+ϵ)i1, then all colors are sampled and Hi=Ei. Moreover, xed(1+ϵ)i(1+ϵ)i1=11+ϵ, and (2) holds trivially.

Case 2: If xe>1d, then (1+ϵ)i+1xe>1d and in particular d(1+ϵ)i1, we thus refer to the previous case.

Case 3: If xe1d and d(1+ϵ)i1, then e is sampled with probability P[eHi]=3kd3k(1+ϵ)i. Since kd1ϵ, we have that kd+1kd(1+ϵ), and thus:

P[eHi]=3kd3k(1+ϵ)ikd+1k(1+ϵ)ikd(1+ϵ)k(1+ϵ)ixed(1+ϵ)=min{1,xed}(1+ϵ)

On the other hand, since (1+ϵ)i(1+ϵ)i1d1kϵ, we have that k(1+ϵ)i+1k(1+ϵ)i+1. Therefore,

P[eHi]=3kd3k(1+ϵ)ikdk(1+ϵ)i+1kdk(1+ϵ)i+1xed(1+ϵ)2=min{1,xed}(1+ϵ)2.

For the proof of Lemma 13, we need the following inequality:

Theorem 20 (Bernstein’s Inequality for Negatively Associated Variables).

Let Y be the sum of negatively associated random variables Y1,,Y, with Yi[0,U] for each i[]. Then, for σ2=i=1Var(Yi) and all a>0,

P[Y>E[Y]+a]exp(a22(σ2+aU/3))
Proof of Lemma 13.

Let 𝐳RE with ze:=xe(13ϵ)min{1,xed}Xe. By equation (3),

E[ze]=E[ze|Xe]P[Xe]xe(13ϵ)(1+ϵ)2xe(15ϵ) (4)

Therefore, 𝐳 is a good approximation for 𝐱 in the sense that E[eze]exe(15ϵ). However, as we are scaling up xe to get ze for some edges e, 𝐳 might not be a feasible fractional k-matching. We obtain a feasible fractional k-matching 𝐲 from 𝐳 as follows:

ye:={0if xe<1/d and maxve{evze}>kzeotherwise
Claim 21.

𝐲 is a feasible fractional k-matching.

Proof.

Consider a node v. If evzek, then evyeevzek. Otherwise, if evze>k, then evye=ev,xe1/dze=ev,xe1/dxe(13ϵ)k.

To complete the proof, we will now show that for every edge e, we have E[ye](1ϵ)E[ze]. If xe1d, this trivially follows since ye=ze and thus E[ye]=E[ze]. We thus concentrate on the case xe<1d and bound by (1ϵ) the probability of the event yeze, that is the event maxve(evze)>k. In particular, we will consider the case Xe=1.

Let v be an endpoint of e. We have that xe<1/dkϵ (because we choose d such that d1/kϵ). Let ee such that ve. Since Xe and Xe are negatively correlated, we have that P[Xe|Xe]P[Xe]min{1,xed}(1+ϵ), by equation (3). Therefore:

E[ze|Xe]=xe(13ϵ)min{1,xed}P[Xe|Xe]xe(13ϵ)min{1,xed}P[Xe]xe(13ϵ)(1+ϵ)xe(12ϵ)

Hence:

E[evze|Xe]=E[ze|Xe]+ev,eeE[ze|Xe]kϵ+ev,eexe(12ϵ)k(1ϵ)

We therefore expect 𝐳 to not violate the constraint on v. To bound the probability that 𝐳 does violate the constraint, we first compute the variance of [evze|Xe], and in particular, for every ev, the variance of [ze|Xe].

If e is such that xe1d, then P[Xe]=1, and in particular P[Xe|Xe]=1. The variance of ze=xe(13ϵ)min{1,xed}Xe is therefore 0. On the other hand, if xe<1/d, then [ze|Xe] is a Bernoulli random variable scaled by 13ϵd, with success probability at most P[Xe|Xe]min{1,xed}(1+ϵ)=xed(1+ϵ). Therefore, the variance of this random variable is at most

Var([ze|Xe])(13ϵd)2xed(1+ϵ)xed.

Summing over all edges, we get:

evVar([ze|Xe])evxedkd

Since the variables {[Xe|Xe]ev} are negatively associated, so are the variables {[zeXe]|ev}, by closure of negative association under scaling by positive constants. Therefore, we can use Bernstein’s inequality (cf. Theorem 20).

For [evze|Xe] to go over k, it needs to exceed its expectation by at least kϵ. Since for all e such that xe>1/d,[ze|Xe] is deterministic, this is equivalent to the sum only over edges e such that xe1/d exceeding its expectation by at least kϵ. In that case, ze(13ϵ)d1d. We thus have

P[evze>k|Xe]P[ev,xe1dze>E[ev,xe1dze|xe]+ϵk|Xe]exp(ϵ2k22(k/d+ϵk/3d))exp(ϵ2k2(1/d+ϵ/3d))exp(ϵ2k4d),

which is at most ϵ/2 since d4log(2/ϵ)kϵ2.

For ye, we thus have that, conditioned on eH, the probability of the constraints on each of the nodes of e being violated is at most ϵ. By union bound, we thus have P[ye=ze|Xe](1ϵ). Combined with Equation (4), we have:

E[ye]=xe(13ϵ)min{1,xed}P[ye=ze|Xe]P[Xe](1ϵ)E[ze]xe(16ϵ)

We thus conclude that H contains a fractional k-matching of expected value at least 16ϵ times the value of the fractional k-matching 𝐱 in G.

Proof of Lemma 15.

Let f be an optimal coloring before the updates, and g be an optimal coloring after the updates. Let q:=|g1([k])|, p:=|f1([k])|, and q:=|g1([k])|. Since every deleted edge decreases the number of colored edges by at most 1, we have:

qpϵpp(1ϵ)

Similarly, since every added edge increases the size of the optimal coloring by at most 1, we have:

qp+ϵpp(1+ϵ)

If f is an α-approximation, then pαp. Therefore, as long as ϵ13:

qp(1+ϵ)αp(1+ϵ)α1+ϵ1ϵqαq(1+3ϵ)

Hence, whenever we compute a partial coloring of a dynamic graph of size p, we can charge the cost of that computation to the next ϵp updates without recomputing anything, and while losing a (1+3ϵ) approximation factor at most.

Appendix B Related Work

In this section, we give a more extensive overview over related work. As the maximum k-edge coloring problem is also closely related to various matching problems, we include relevant results for these problems.

Edge Coloring.

Given a graph G, its chromatic index χ(G) is the smallest value q such that all edges of G can be colored with q colors. It is straightforward that Δ(G)χ(G), where Δ(G) denotes the maximum vertex degree in G. Vizing [49] showed that χ(G)Δ(G)+1. For bipartite graphs, χ(G)=Δ(G) [36]. In general, it is NP-hard to decide whether a given graph G has χ(G)=Δ(G) or χ(G)=Δ(G)+1 already for Δ(G)=3 [32], and even if G is regular [38]. Note that if Δ(G)=1, then G’s edges form a matching, whereas if Δ(G)=2, then G is a collection of cycles and paths and χ(G)=2 iff all cycles have even length. Another lower bound on the chromatic index is given by the odd density ρ(G):=maxSV,|S|=2i+1E(S)i, where E(S) denotes the set of edges in the subgraph induced by S: As all edges of the same color form a matching, at most |S|2=i edges of E(S) can share the same color, so at least E(S)i colors are necessary to color E(S). Edmonds [39] showed that the fractional chromatic index is equal to max{Δ(G),ρ(G)}.

Misra and Gries [41] designed an algorithm that uses at most Δ(G)+1 colors. It processes the edges in arbitrary order and colors each in O(n) time, thus resulting in an O(mn) running time overall. If new edges are added to the graph, they can be colored in O(n) time. Their algorithm improved on an earlier approach by Gabow [27], which has a running time of O(mΔ(G)logn). Simmanon [46] reduces the time for finding a (Δ(G)+1)-edge coloring to O(mn). By allowing more colors – up to (1+ϵ)Δ colors – Duan, He and Zhang [20] further reduce the running time to O(mpoly(logn,ϵ1)) as long as Δ(G)=Ω(log2nϵ2). For bipartite graphs, Cole, Ost, and Schirra [19] gave an optimal algorithm (it uses Δ colors) with O(mlogΔ(G)) running time.

Cohen, Peng, and Wajc [18] recently studied the edge coloring problem in the online setting and proved various competitive ratio results.

For the dynamic setting, Bhattacharya, Chakrabarty, Henzinger, and Naongkai [7] show how to maintain a (2Δ(G)1)-edge coloring in O(logn) worst-case update time. They also show that a (2+ϵ)Δ(G)-edge coloring can easily be maintained with O(1/ϵ) expected update time. If Δ(G)=Ω(log2nϵ2), Duan, He and Zhang [20] maintain an edge-coloring using (1+ϵ)Δ colors in amortized O(log8nϵ4) update time.

Maximum k-Edge Coloring.

For the maximum k-edge coloring problem, the number of available colors is limited to some kN and the task is to find a maximum-cardinality subset of the edges H such that for the subgraph restricted to H, G|H, χ(G|H)k.

This problem was first studied by Favrholdt and Nielsen [22] in the online setting. They propose and analyze the competitive ratio of various online algorithms and show that every algorithm that never chooses to not color (“reject”) a colorable edge has a competitive ratio between 0.4641 and 12, and that any online algorithm is at most 47-competitive.

Feige, Ofek, and Wieder [23] considered the k-edge coloring problem in the static setting and for multigraphs, motivated by a call-scheduling problem in satellite-based telecommunication networks. The authors show that for every k2, there exists an ϵk>0 such that it is NP-hard to approximate the problem within a ratio better than (1+ϵk). They also describe a static (1(11/k)k)1-approximation algorithm for general k as well as a 1310-approximation for k=2. The former algorithm applies a greedy strategy and works by repeatedly computing a maximum-cardinality matching M, then removing M from graph. As all edges in a matching can be colored with the same color, k repetitions yield a k-edge coloring. They also note that for a multigraph of multiplicity d, a k+dk-approximate solution can be obtained by first computing a k-matching, then coloring the subgraph using k+d colors (which is always possible, in analogy to Vizing’s theorem), and then discarding the d colors that color the fewest edges. For simple graphs (i.e., d=1), this yields an approximation ratio of k+1k. The authors also give an algorithm with an approximation ratio tending to 1α as k, where α denotes the best approximation ratio for the chromatic index in multigraphs.

Several improved approximation results for the cases where k=2 and k=3 exist. The currently best ratios are 65 for k=2 and 54 for k=3 [37].

The maximum k-edge coloring problem was first studied in the edge-weighted setting by Hanauer, Henzinger, Schmid, und Trummer [31]. Here, instead of finding a maximum-cardinality subset of the edges, the total weight of the colored edges is to be maximized. The authors describe several approximation and heuristic approaches to tackle the problem in practice and provide an extensive experimental performance evaluation on real-world graphs. They also show that a double-greedy approach, where successively k weighted matchings are computed by a greedy algorithm, yields a O(1)-approximation. In a follow-up work, Hanauer, Henzinger, Ost, and Schmid [30] design a collection of different dynamic and batch-dynamic algorithms for the weighted k-edge coloring. Their focus is again more on the practical side. Ferdous et al. [24] recently studied the problem in the streaming setting.

Matching.

The matching problem in the static setting has been subject to extensive research both in the unweighted and weighted case. The currently fastest deterministic algorithms for unweighted matching in general and bipartite graphs have a running time of O(mn) [40, 28, 33]. For weighted matching on general graphs, the currently best running time is O(n(m+nlogn)) [26]. An excellent overview, which also encloses approximation ratios, is given by Duan and Pettie [21].

For the dynamic setting, Onak and Rubinfeld [44] present a randomized O(1)-approximation algorithm with O(log2n) update time. The algorithm by Baswana, Gupta, and Sen [3] improves the running time to O(logn) and the approximation ratio to 2. Later, Solomon [47] reduced the amortized expected update time to O(1). Wajc [50] gives a metatheorem for rounding a dynamic fractional matching against an adaptive adversary and a (2+ϵ)-approximate algorithm with constant update time or O(poly(logn,ϵ1)) worst-case update time.

Neiman and Solomon [43] show that a 32-approximate matching can be maintained deterministically in O(m) worst-case update time. Bhattacharya, Henzinger, and Italiano [10] give a deterministic (3+ϵ)-approximation with O(m1/3ϵ2) amortized update time, as well as an (4+ϵ)-approximation with O(m1/3ϵ2) worst-case update time. An improved algorithm is given by Bhattacharya, Henzinger, and Nanongkai [12], which has O(poly(logn,1ϵ)) amortized update time and an approximation ratio of (2+ϵ). A (1+ϵ)-approximation algorithm with O(mϵ2) worst-case update time is given by Gupta and Peng [29] for ϵ<12. The authors also give an algorithm for the weighted case with the same approximation ratio and a worst-case update time of O(mϵ2O(1/ϵ)logW), where W is the largest weight of an edge in the graph.

For bipartite graphs, Bosek, Leniowski, Sankowski, and Zych [14] give a partially dynamic algorithm for either the insertions-only or deletions-only setting, which runs in O(mn) total time, thus matching the time of the Hopcroft-Karp static algorithm [33]. Due to the direct reduction of matching to maximum flow, the static case can now be solved in O(m1+o(1)) time thanks to a breakthrough result of Chen, Kyng, Liu and Peng [16].

Stubbs and Williams [48] show how to transform a dynamic α-approximation algorithm for the unweighted matching problem to a (2+ϵ)α-approximation algorithm for the weighted setting. The running time increases by a factor of ϵ2log2W, where W denotes the maximum weight of an edge. Bernstein, Dudeja, and Langley [5] improve on this result w.r.t. running time and show that a (1+ϵ)α-approximation algorithm can be obtained in the case of bipartite graphs.

Various results [4] also exist for the “value” version of the problem, where one is only interested in the maximum size or weight, but not in the set of edges.

b-Matching.

Gabow [25] gives a O(b1m)-time algorithm to compute a 𝐛-matching in the unweighted, static setting. If the 𝐛-matching is weighted, the running time is O(b1min(mlogn,n2)). Ahn and Guha [1] give an algorithm that computes an (1+ϵ)-approximation for 𝐛-matching and runs in O(mpoly(logn,ϵ1)) time.

For dynamic graphs, Bhattacharya, Henzinger, and Italiano [11] give a deterministic algorithm that maintains an O(1)-approximate fractional k-matching with O(log3n) amortized update time. This result is improved by Bhattacharya, Gupta, and Mohan [9], who show how to maintain an integral (2+ϵ)-approximate 𝐛-matching in expected amortized O(1/ϵ4) update time, against an oblivious adversary.