On -Matching and Fully-Dynamic Maximum -Edge Coloring
Abstract
Given a graph that undergoes a sequence of edge insertions and deletions, we study the Maximum -Edge Coloring problem (MkEC): Having access to different colors, color as many edges of as possible such that no two adjacent edges share the same color. While this problem is different from simply maintaining a -matching with , the two problems are related. However, maximum -matching can be solved efficiently in the static setting, whereas MkEC is NP-hard and even APX-hard for .
We present new results on both problems: For -matching, we show a new integrality gap result and we adapt Wajc’s matching sparsification scheme [50] for the case where is a constant.
Using these as basis, we give three new algorithms for the dynamic MkEC problem: Our MatchO algorithm builds on the dynamic -approximation algorithm of Bhattacharya, Gupta, and Mohan [9] for -matching and achieves a -approximation in update time against an oblivious adversary. Our MatchA algorithm builds on the dynamic -approximation algorithm by Bhattacharya, Henzinger, and Italiano [10] for fractional -matching and achieves a -approximation in update time against an adaptive adversary. Moreover, our reductions use the dynamic -matching algorithm as a black box, so any future improvement in the approximation ratio for dynamic -matching will automatically translate into a better approximation ratio for our algorithms. Finally, we present a greedy algorithm with update time, which guarantees a approximation factor.
Keywords and phrases:
dynamic algorithm, graph algorithm, matching, b-matching, edge coloringCopyright and License:
![[Uncaptioned image]](x1.png)
2012 ACM Subject Classification:
Theory of computation Graph algorithms analysisFunding:
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]](eulogo.png)
Editors:
Kitty Meeks and Christian ScheidelerSeries and Publisher:

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 where each node represents a data center rack and the edges indicate pairs of racks with high communication demand. We refer to as demand graph. Each set of connections realized by a single optical switch is a matching in , 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 optical switches, the problem hence amounts to finding a collection of pairwise edge-disjoint matchings , , with maximum total cardinality . We call this the maximum -disjoint matching problem. Identifying each matching with a unique color, it can equivalently be rephrased as a maximum -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 and , find a maximum-cardinality subset of edges such that each vertex is incident to at most edges in . Note that one can set to a constant for all , but this does not yield the MkEC problem: there is no requirement that can be edge-colored completely with colors. Consider, e.g., a graph that is a length-3 cycle. A solution to the -matching problem with contains all three edges of , while a solution to the maximum 2-edge coloring problem can only color two edges of . 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 for all . 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 are required is a well-known NP-hard problem [32] (Vizing [49] showed that every simple graph needs either or colors to color all edges). On bipartite graphs, however, colors always suffice.
Let be a graph with and . For the fully dynamic -matching problem, Bhattacharya, Henzinger, and Italiano [11] gave a constant approximation algorithm with update time which works against an adaptive adversary. If the adversary is oblivious, there also is a -approximation with 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 -approximation algorithm for the weighted case. Dropping the weights, we show how to significantly improve the update time to while achieving an approximation ratio to almost against an oblivious adversary and (for any ) against an adaptive adversary. The problem is known to be NP-hard and even APX-hard for [23].
Algorithm | Update Time | Approximation Ratio | Det.? | Adversary | Theorem | Sect. |
algorithms in [30] | or more | yes | – | |||
unknown | no | – | ||||
Greedy | yes | – | 14 | 7.1 | ||
MatchO | no | oblivious | 16 | 7.2.1 | ||
![]() |
no | oblivious | 17 | 7.2.1 | ||
MatchA | no | adaptive | 18 | 7.2.2 | ||
![]() |
no | adaptive | 19 | 7.2.2 |
Our contributions.
We show that the integrality gap for the -matching problem is where . In the case where is the constant vector with , 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 -matching111Whenever is the all- vector for some constant , we will refer to the problem as -matching instead of -matching. to an integral -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 -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 of maximum degree , its chromatic index is the smallest value such that all edges of can be colored with colors. Generally, [49], whereas [36] for bipartite graphs. Deciding whether or is NP-hard already for [32], even if is regular [38].
For an -vertex -edge graph , Gabow [27] gave an -time coloring algorithm that uses at most colors. Misra and Gries [41] gave an algorithm that needs running time, and which was improved to running time by Sinnamon [46]. A recent series of works further reduced the running time to (Assadi [2]), (Bhattacharya et al. [6]), and (Bhattacharya et al. [8]). Duan et al. [20] further reduced the time to as long as , but use up to colors. For bipartite graphs, Cole et al. [19] gave an optimal algorithm with running time. Cohen et al. [18] recently studied the problem in the online setting and proved various competitive ratio results.
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 and , and that any online algorithm is at most -competitive. Feige et al. [23] showed that for every , there exists an such that it is NP-hard to approximate the problem within a ratio better than . They also describe a static -approximation algorithm for general . The currently best approximation ratios are for and for [17, 34].
The maximum -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 -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 -approximate algorithm with update time or worst-case update time.
b-Matching.
Gabow [25] gives a -time algorithm to compute a -matching in the unweighted, static setting, and an -time algorithm for weighted graphs. Ahn and Guha’s algorithm [1] computes a -approximation for -matching and runs in time. Bienkowski et al. [13] give an online -approximate solution, which is asympotically optimal in the online setting.
For dynamic graphs, Bhattacharya et al. [11] give a deterministic algorithm that maintains an -approximate fractional -matching with amortized update time. This is improved by Bhattacharya et al. [9], who show how to maintain an integral -approximate -matching in expected amortized update time against an oblivious adversary.
3 Technical Overview
Our starting point is the following observation: The two problems -matching and -edge coloring seem very similar if is the vector having for every vertex . Indeed, the colored edges in a -edge coloring form a -matching. Vice versa, a maximum -matching always contains a -approximate -edge coloring, as one can always color the edges with 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 -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 time.
Our MatchO algorithm, which works against oblivious adversaries, is a combination of known algorithms: We use the aforementioned -approximation by Bhattarcharya et al. [9] to find a -matching. Duan et al.’s algorithm [20] colors the edges with colors. Discarding the least-used colors yields a -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 -approximation. The algorithm is based on a -approximate fractional -matching algorithm, whose solution is rounded. We present an alternative rounding approach and thus obtain an improved integral -matching algorithm that guarantees a -approximation, which is at most (for ). Following the same scheme as for MatchO, we thus obtain a -approximation for MkEC.
Our new rounding technique works as follows: Given a fractional -matching, we partition the edges of our graph by powers of according to their fractional value and maintain a -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 -edge coloring of the input graph colors edges, then the sparsified graph contains at most edges. Running Ahn and Guha’s algorithm [1] on the sparsified graph takes time and computes an integral -matching. We can thus afford to rerun Ahn and Guha’s algorithm every 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 -matching problem is and hence small. This ensures that the sparsified graph, which we show contains a large fractional -matching, also contains a large integral -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 , 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 . This allows us to prove that the integrality gap is , with .
On bipartite graphs, many aspects of the problem become easier: the integrality gap of the -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 time. This improves the approximation ratio of MatchO and MatchA to and respectively.
4 Preliminaries
Unless denoted otherwise, we consider an undirected, unweighted graph with and . 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. , , and 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 . We use to denote the maximum vertex degree in . If it is clear from the context, we may omit and just write .
Definition 1 (Edge Coloring).
Let be a graph, , and an edge coloring of the edges of . We say that:
-
1.
is a proper coloring of if for any adjacent edges , we have that either , or .
-
2.
is a total coloring of if . We say it is partial to emphasize it is not necessarily total, that is, may or may not be equal to .
-
3.
A color is free on node (according to ) if no edge incident to has color , that is, for every .
-
4.
An edge is colored if and uncolored otherwise.
Given and , the maximum -edge coloring problem consists in finding a proper coloring of such that the set of colored edges is maximized. In the rest of this paper, unless specified otherwise, every (-)coloring is proper and we use to denote an arbitrary (proper) (-)coloring, and to denote an optimal (-)coloring.
A matching is a subset of edges such that for every distinct pair , . Note that given a -edge coloring , is a matching for each . A set of edges is a -matching if for all , . Given an -dimensional vector , we say that a set of edges is a -matching if for every , . Thus, a -matching is a -matching where , and a matching is a -matching ().
Theorem 2 (Coloring an Approximate -Matching, extension of [23]).
Let be a graph and a subgraph such that is a solution of an -approximation algorithm for -matching on , for some . Let be a total coloring of using colors, with . Then, discarding the least used colors from yields an -approximate -edge coloring of . In particular, if and , the approximation ratio is .
Corollary 3.
Given a graph , let be the size of an optimum -matching in and let be the size of an optimum -edge coloring. Then .
5 The b-Matching Polytope
In this section, we will show the following theorem.
Theorem 4.
The integrality gap of the -matching polytope is , where . 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 be an undirected graph. The fractional -matching polytope is:
It is well-known that if is bipartite, then is integral, i.e., every vertex of the polytope has integer entries:
Lemma 6 ([45]).
Let be a bipartite graph. Then 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 . To do so, given a graph , we build a graph that is bipartite and show a relationship between vertices of and .
Lemma 7.
Let be a graph. Then is half-integral.
Next, we introduce a technique for rounding an optimal solution in to an integer solution that has similar total cost. This requires the following helper lemma:
Lemma 8.
Let be a graph that contains no even circuit. Then has no even cycles, and no two odd cycles in share a node.
We also recall the Euler partition of a graph:
Definition 9 (Euler Partition).
Let be a graph. A Euler Partition of 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 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 , where . 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 . We then consider a Euler partition of the union of edges whose value is . 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 , , so rounding up does not violate the condition at .
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- cycles, as the rounded solution is only 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 additive factor. This gives the result.
6 The Sparsification Scheme
Given a dynamic fractional -matching algorithm , this section provides a sparsification scheme for fractional -matching that enables us to give an algorithm that maintains an approximate integral -matching:
Theorem 10 (Sparsify and Round).
Let be a dynamic graph, , , and a dynamic algorithm that maintains an -approximate fractional -matching of in update time. Then there exists an algorithm that maintains an -approximate integral -matching in amortized update time against an adaptive adversary. If is bipartite, the approximation ratio reduces to .
This result will be particularly useful for the MatchA algorithm in Section 7.2.2. To prove the theorem, we consider a dynamic graph and assume we have access to a dynamic algorithm that has update time and maintains a fractional -matching with approximation factor . The goal is to maintain a sparse subgraph of that contains an integral -matching whose size is within an factor of the size of an optimal -matching in .
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 . 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 -matching maintained by of value . Let . We maintain subgraphs of , where and
Let . Note that is a subset of and does not contain edges such that . Hence, and we obtain
(1) |
In each , we maintain a proper, total -edge coloring. Since in , every edge satisfies , and is a -matching, we know that the maximum degree of can be no higher than . Hence, every edge modified in can be colored in expected constant time333By maintaining a hash table at each vertex of the free colors, since we have more than colors available. By picking a color at random, we have a probability higher than 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 can modify only edges, there are at most modifications in total to all subgraphs . The recoloring caused by each modification can be handled in expected constant time, which implies expected time per update to .
Request Scheme
We fix a parameter . Whenever we need access to the sparse graph , we obtain a set of edges from each by choosing uniformly at random without replacement up to colors, and setting to be the set of edges colored with those colors. Then, . Obtaining takes time.
We analyze the size of with respect to , the size of an optimal -edge coloring in . Let and be the size of a maximum -matching on . Each collection of colors in creates a -edge coloring in , and has thus size at most . We have such collections in , and hence . Therefore,
Together with Equation (1), Lemmas 12 and 13 below show that in expectation, contains a fractional -matching of total value at least . By our Integrality Gap Theorem (Theorem 4), then contains an integral -matching of cardinality greater than . Since the fractional dynamic algorithm outputs an -approximation of the optimal fractional solution, we have that . Therefore contains a -matching of cardinality greater than . We thus get the following theorem:
Theorem 11 (Sparsification).
Let be a dynamic graph, , and a dynamic algorithm that maintains an -approximate fractional -matching of in update time. Let be the size of an optimal -matching in G. Then the sparsification scheme maintains a sparsification of that runs in update time and request time. In expectation, contains an integral -matching of size at least and satisfies . If is bipartite, the approximation ratio reduces to .
We now prove the Sparsify and Round Theorem:
Proof of Theorem 10.
We build the algorithm that maintains an approximate integral -matching as follows: We use to maintain an -approximation of a fractional -matching in . At a given update, we compute a sparsification of using Theorem 11 of size that contains an integral -matching of size at least . We then run the Ahn-Guha algorithm [1] on in time to get a -approximate -matching of . Since every update only changes the size of an optimal solution by at most , the computed -matching remains a good approximation of the optimal solution over the next updates, which yields an amortized update time of .
Lemma 12.
Let , and be a graph. Let x be a fractional -matching on that satisfies , and . If , set . Otherwise, let be a total -edge coloring of . Sample colors uniformly at random (without replacement), and set to be the set of all edges colored by one of the sampled colors. Then each edge is sampled with probability such that
(2) |
Then, if , . Moreover, any two adjacent edges are negatively associated, that is, for any edges and that share a node, we have . Furthermore, the random variables are negatively associated for any .
Lemma 13 (Sparsification).
Let x be a fractional -matching on a graph , , and . Let be a subgraph of , where each edge of is sampled with probability , where if and
(3) |
Let . The edges need not be sampled independently, however two edges that are adjacent need to be negatively associated, that is, for any edges and that share a node, we have . We also require that for any , the random variables are negatively associated. Then, has a fractional -matching of expected value at least
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 is removed from the graph, we try to color one edge adjacent to each of its end nodes with color . This keeps the coloring maximal, and is thus a -approximation, as shown by Favrholdt and Nielsen [22]. If we maintain a table of free colors at every vertex, each insertion takes time, as we have to go through all used colors at the endpoints to find a free one. Every edge deletion takes time, as we have to check whether the color is free at the end of edges in the worst case.
Theorem 14 (Greedy Algorithm).
The Greedy algorithm is deterministic and maintains a -approximation of a maximum -edge coloring in 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 , where 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 -matchings. The idea is to maintain an approximate -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 , and assume we compute a coloring that colors edges of a graph . Then assume we have up to edge insertions and deletions to . Define a coloring on as follows: if was already in before the modifications, and otherwise. Then if is an -approximation of maximum -edge coloring before the updates, is a -approximation after the updates if .
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 -approximation of -matching against an oblivious adversary in update time.
Our MatchO algorithm works as follows: We use Bhattacharya et al.’s algorithm to maintain a -approximation for -matching, which is represented by a graph . Then, we compute a -edge coloring using Gabow’s coloring algorithm [27] on , and discard the least used color to obtain a -approximation of a -edge coloring, guaranteed by Theorem 2. We refrain from recomputing the coloring for the next updates, while continuing to update the -matching after each update operation. By the Amortization Lemma (Lemma 15), this yields a -approximation, which is a -approximation if . This is particularily efficient if .
If on the other hand , using the edge-coloring by Duan, He, and Zhang [20], we color all the edges of with colors. Discarding the colors that color the fewest edges among them, this yields a approximation of the maximum -edge coloring by Theorem 2.
Running time analysis. Let be the size of at the time of recoloring. Computing the recoloring (whether it is a or -edge coloring) and removing the least used color(s) gives a -edge coloring of size at least . Thus, .
Let us now analyze the amortized update time. For each update, we spend time to maintain the -matching. If , coloring the -matching with Gabow’s algorithm takes time. If on the other hand , coloring the -matching with Duan, He, and Zhang’s algorithm takes time. Either way, this can be amortized over the next updates, yielding an amortized update time of for the complete algorithm.
We hence have the following result:
Theorem 16 (MatchO Algorithm).
Against an oblivious adversary, the MatchO algorithm runs in amortized update time and maintains a -edge coloring that is in expectation a -approximation.
In the case of a bipartite graph, we can color the -matching with colors in 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 amortized update time and maintains a -edge coloring that is in expectation a -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 -approximate fractional -matching of the dynamic graph in 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 of . By the Sparsify and Round Theorem (Theorem 10), this takes update time and time to output when requested. Let be an optimal -edge coloring of of size . By Theorem 10, in expectation contains an integral -matching of size at least and .
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 in every round. More specifically, we use the amortization technique from Lemma 15 to determine in which rounds to recolor for the current graph. To recolor we run Ahn and Guha’s static algorithm for -matching [1] on to compute a -approximate (integral) -matching of . This ensures that the sparse graph has degree at most . Finally, we either compute a -edge coloring using Gabow’s algorithm for edge-coloring [27] of , if , or a -edge coloring using Duan, He, and Zhang’s Algorithm otherwise, and discard the least used colors to obtain a -approximation of the maximum cardinality -edge coloring of .
We refrain from recomputing the coloring for the next updates, while continuing to maintain the -matching. By Lemma 15, this yields an -approximation of the current , which is an -approximation if .
Running time analysis. Let us analyze the amortized update time. For each update, we must first spend time to maintain the fractional -matching and its sparsification. Requesting the sparse graph takes time. Finding a -matching in it takes time [1]. Let be the size of that -matching after the current update. Coloring the -matching with either Gabow’s or Duan, He, and Zhang’s algorithm takes 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 .
Let be the size of the optimum -matching after the current update. Recall that by Corollary 3. Thus, we have that . We also have . Hence, the total update time in an interval is
Note also that as we recolor every updates and each update changes the size of the -edge coloring by at most one. Thus it follows that
Hence we can amortize the total update time of an interval over the length of an interval, which consists of updates, to achieve an amortized update time of , resulting in the following theorem.
Theorem 18 (MatchA Algorithm).
Against an adaptive adversary, the MatchA algorithm runs in expected amortized update time and maintains a -edge coloring that is in expectation a -approximation.
Similarly to the previous section, in the case of a bipartite graph, we can color the -matching with colors in 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 factor in the approximation computation above. Moreover, the integrality gap for the -matching becomes 1, removing the factor. This yields a better approximation ratio:
Theorem 19 (Bipartite MatchA Algorithm).
Against an adaptive adversary, the bipartite MatchA algorithm runs in expected amortized update time and maintains a -edge coloring that is in expectation an -approximation.
8 Conclusion
In this work, we have initiated the study of fully dynamic approximation algorithms for the NP-hard -edge coloring problem by presenting and analyzing three dynamic algorithms. Moreover, we have demonstrated the close relationship between -matching and -edge coloring, making any advances in -matching to automatically translate into better results for -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 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 n 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 be the size of an optimum -matching in and let be the size of an optimum -edge coloring. Since any -edge coloring is a -matching, we have that . Let . The colors that color the smallest number of edges color at most edges, otherwise the average of colored edges by color exceeds . Let be the number of edges colored by the remaining colors. Then .
Proof of Theorem 4.
Since the -matching polytope is half-integral, we can find an optimal fractional -matching of such that is half-integral. Let be the subgraph of with . If , x is integral.
Otherwise, consider an Euler partition of . If it contains a trail which starts and ends at different nodes, write where each is adjacent to . Let be defined by
i.e., we alternatingly round up and down by along the trail. We clearly have that , since and for each node except the endpoints of , an equal number of edges incident to is rounded up and down. An end point of the trail might have at most one more edge that sees its value increase than decrease by . Since the node is of odd degree in , we have that , which implies , i.e. the condition is still satisfied. We moreover have that .
We can, hence, reduce the number of nodes of odd degree in by creating solutions that are as good as that have fewer and fewer odd degree nodes. We end up with having only even degree nodes. By Euler’s Theorem, there exists an Euler Circuit on every connected component of .
For every node , let , and let be a connected component of . If there exists a node such that , then , and we can write the connected component as an Eulerian circuit where each is adjacent to , and where is adjacent to . Then define:
We clearly have that , since , and for each node except for , we have that the number of edges adjacent to losing is equal to the number of edges adjacent to winning canceling out. Node has at most two more edge that sees its value increase than decrease by . Since , we have , the condition is still satisfied. We moreover have that .
We can also show that even if no satisfies , but has an even number of nodes, the number of edges in the component is even, and thus the Eulerian circuit of is of even length, and thus computing as above will yield an integer solution on . Note as well that if is of size , then contains no edges and is already integral on .
We end up with connected components of odd size at least , where every node satisfies . Each can be seen as an Eulerian circuit. We will now build an integer solution that approximates . For every , pick an arbitrary node , and write where each is adjacent to , and where is adjacent to . Define then:
We clearly have that , since and for each node , we have that the number of edges adjacent to losing is larger than the number of edges adjacent to winning , and thus . We moreover have that
However, we have that and that for each , and thus . Therefore:
Hence,
Since is integral, the theorem follows.
Proof of Lemma 7.
Let us write and . Define , where , and , where for each , if for some , then and are defined as and . Define such that for all .
Let be a vertex of . Then , defined as for every , satisfies . Indeed, for every we have that .
Since , and is bipartite, by Lemma 6, is a convex combination of some such that for each it holds that and all entries of are in . Let such that , and define for every , such that for every , which is half-integer. Note that for every , and, hence, . Thus, is a convex combination of . We are left with showing that belongs to for every . To do so note that for every ,
which implies that . Since is a vertex of and a convex combination of , it must be equal to one of them, say for some , and thus is half-integral.
Proof of Lemma 8.
Since every even cycle is an even circuit, it is straightforward to see that has no even cycle. Let us now assume that there exist two odd cycles and that share a node in . Suppose that and share no edge. Then, the circuit that starts at and visits the first cycle, then the second, is an even circuit, a contradiction. Thus, and share at least one edge. Let be a shared edge such that the other neighbor of in is different from its neighbor in (this edge must exists otherwise ). Consider the path in from to that does not go through . This path ends in . Let denote the first node on that path that is different from and is in . We now have three edge-disjoint paths from to : two in and one in . 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 , the random variables are negatively associated. Let be an edge of . We have three cases:
Case 1: If , then all colors are sampled and . Moreover, , and (2) holds trivially.
Case 2: If , then and in particular , we thus refer to the previous case.
Case 3: If and , then is sampled with probability . Since , we have that , and thus:
On the other hand, since , we have that . Therefore,
For the proof of Lemma 13, we need the following inequality:
Theorem 20 (Bernstein’s Inequality for Negatively Associated Variables).
Let be the sum of negatively associated random variables , with for each . Then, for and all ,
Proof of Lemma 13.
Let with . By equation (3),
(4) |
Therefore, is a good approximation for in the sense that . However, as we are scaling up to get for some edges , might not be a feasible fractional -matching. We obtain a feasible fractional -matching from as follows:
Claim 21.
is a feasible fractional -matching.
Proof.
Consider a node . If , then . Otherwise, if , then .
To complete the proof, we will now show that for every edge , we have . If , this trivially follows since and thus . We thus concentrate on the case and bound by the probability of the event , that is the event . In particular, we will consider the case .
Let be an endpoint of . We have that (because we choose such that ). Let such that . Since and are negatively correlated, we have that , by equation (3). Therefore:
Hence:
We therefore expect to not violate the constraint on . To bound the probability that does violate the constraint, we first compute the variance of , and in particular, for every , the variance of .
If is such that , then , and in particular . The variance of is therefore . On the other hand, if , then is a Bernoulli random variable scaled by , with success probability at most . Therefore, the variance of this random variable is at most
Summing over all edges, we get:
Since the variables are negatively associated, so are the variables , by closure of negative association under scaling by positive constants. Therefore, we can use Bernstein’s inequality (cf. Theorem 20).
For to go over , it needs to exceed its expectation by at least . Since for all such that is deterministic, this is equivalent to the sum only over edges such that exceeding its expectation by at least . In that case, . We thus have
which is at most since .
For , we thus have that, conditioned on , the probability of the constraints on each of the nodes of being violated is at most . By union bound, we thus have . Combined with Equation (4), we have:
We thus conclude that contains a fractional -matching of expected value at least times the value of the fractional -matching in .
Proof of Lemma 15.
Let be an optimal coloring before the updates, and be an optimal coloring after the updates. Let , , and . Since every deleted edge decreases the number of colored edges by at most , we have:
Similarly, since every added edge increases the size of the optimal coloring by at most , we have:
If is an -approximation, then . Therefore, as long as :
Hence, whenever we compute a partial coloring of a dynamic graph of size , we can charge the cost of that computation to the next updates without recomputing anything, and while losing a approximation factor at most.
Appendix B Related Work
In this section, we give a more extensive overview over related work. As the maximum -edge coloring problem is also closely related to various matching problems, we include relevant results for these problems.
Edge Coloring.
Given a graph , its chromatic index is the smallest value such that all edges of can be colored with colors. It is straightforward that , where denotes the maximum vertex degree in . Vizing [49] showed that . For bipartite graphs, [36]. In general, it is NP-hard to decide whether a given graph has or already for [32], and even if is regular [38]. Note that if , then ’s edges form a matching, whereas if , then is a collection of cycles and paths and iff all cycles have even length. Another lower bound on the chromatic index is given by the odd density , where denotes the set of edges in the subgraph induced by : As all edges of the same color form a matching, at most edges of can share the same color, so at least colors are necessary to color . Edmonds [39] showed that the fractional chromatic index is equal to .
Misra and Gries [41] designed an algorithm that uses at most colors. It processes the edges in arbitrary order and colors each in time, thus resulting in an running time overall. If new edges are added to the graph, they can be colored in time. Their algorithm improved on an earlier approach by Gabow [27], which has a running time of . Simmanon [46] reduces the time for finding a -edge coloring to . By allowing more colors – up to colors – Duan, He and Zhang [20] further reduce the running time to as long as . For bipartite graphs, Cole, Ost, and Schirra [19] gave an optimal algorithm (it uses colors) with 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 -edge coloring in worst-case update time. They also show that a -edge coloring can easily be maintained with expected update time. If , Duan, He and Zhang [20] maintain an edge-coloring using colors in amortized update time.
Maximum k-Edge Coloring.
For the maximum -edge coloring problem, the number of available colors is limited to some and the task is to find a maximum-cardinality subset of the edges such that for the subgraph restricted to , , .
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 and , and that any online algorithm is at most -competitive.
Feige, Ofek, and Wieder [23] considered the -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 , there exists an such that it is NP-hard to approximate the problem within a ratio better than . They also describe a static -approximation algorithm for general as well as a -approximation for . The former algorithm applies a greedy strategy and works by repeatedly computing a maximum-cardinality matching , then removing from graph. As all edges in a matching can be colored with the same color, repetitions yield a -edge coloring. They also note that for a multigraph of multiplicity , a -approximate solution can be obtained by first computing a -matching, then coloring the subgraph using colors (which is always possible, in analogy to Vizing’s theorem), and then discarding the colors that color the fewest edges. For simple graphs (i.e., ), this yields an approximation ratio of . The authors also give an algorithm with an approximation ratio tending to as , where denotes the best approximation ratio for the chromatic index in multigraphs.
Several improved approximation results for the cases where and exist. The currently best ratios are for and for [37].
The maximum -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 weighted matchings are computed by a greedy algorithm, yields a -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 -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 [40, 28, 33]. For weighted matching on general graphs, the currently best running time is [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 -approximation algorithm with update time. The algorithm by Baswana, Gupta, and Sen [3] improves the running time to and the approximation ratio to . Later, Solomon [47] reduced the amortized expected update time to . Wajc [50] gives a metatheorem for rounding a dynamic fractional matching against an adaptive adversary and a -approximate algorithm with constant update time or worst-case update time.
Neiman and Solomon [43] show that a -approximate matching can be maintained deterministically in worst-case update time. Bhattacharya, Henzinger, and Italiano [10] give a deterministic -approximation with amortized update time, as well as an -approximation with worst-case update time. An improved algorithm is given by Bhattacharya, Henzinger, and Nanongkai [12], which has amortized update time and an approximation ratio of . A -approximation algorithm with worst-case update time is given by Gupta and Peng [29] for . The authors also give an algorithm for the weighted case with the same approximation ratio and a worst-case update time of , where 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 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 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 -approximation algorithm for the weighted setting. The running time increases by a factor of , where 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 -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 -time algorithm to compute a -matching in the unweighted, static setting. If the -matching is weighted, the running time is . Ahn and Guha [1] give an algorithm that computes an -approximation for -matching and runs in time.
For dynamic graphs, Bhattacharya, Henzinger, and Italiano [11] give a deterministic algorithm that maintains an -approximate fractional -matching with amortized update time. This result is improved by Bhattacharya, Gupta, and Mohan [9], who show how to maintain an integral -approximate -matching in expected amortized update time, against an oblivious adversary.