Fast Distributed Approximation for MaxCut
Abstract
Finding a maximum cut is a fundamental task in many computational settings. Surprisingly, it has been insufficiently studied in the classic distributed settings, where vertices communicate by synchronously sending messages to their neighbors according to the underlying graph, known as the or models. We amend this by obtaining almost optimal algorithms for MaxCut on a wide class of graphs in these models. In particular, for any , we develop randomized approximation algorithms achieving a ratio of to the optimum for MaxCut on bipartite graphs in the model, and on general graphs in the model.
We further present efficient deterministic algorithms, including a approximation for MaxDicut in our models, thus improving the best known (randomized) ratio of . Our algorithms make nontrivial use of the greedy approach of Buchbinder et al. (SIAM Journal on Computing, 2015) for maximizing an unconstrained (nonmonotone) submodular function, which may be of independent interest.
Keywords:
Distributed graph algorithms, MaxCut, Coloring, Clustering, Approximation Algorithms1 Introduction
MaxCut is one of the fundamental problems in theoretical computer science. A cut in an undirected graph is a bipartition of the vertices, whose size is the number of edges crossing the bipartition. Finding cuts of maximum size in a given graph is among Karp’s famous 21 NPcomplete problems [24]. Since then, MaxCut has received considerable attention, in approximation algorithms [41, 16, 18, 44], parallel computation [43], parameterized complexity (see, e.g., [42] and the references therein), and streaming algorithms (see, e.g., [23]).
MaxCut has a central application in wireless mesh networks (WMNs). The capacity of WMNs that operate over a single frequency can be increased significantly by enhancing each router with multiple transmit (Tx) or receive (Rx) (MTR) capability. Thus, a node will not experience collision when two or more neighbors transmit to it. Yet, interference occurs if a node transmits and receives simultaneously. This is known as the no mixtxrx constraint. The set of links activated in each time slot, defining the capacity of an MTR WMN, is governed by a link scheduler. As shown in [9], link scheduling is equivalent to finding MaxCut in each time slot. A maximum cut contains the set of nonconflicting links that can be activated at the same time, i.e, they adhere to the no mixtxrx constraint. The induced bipartition of the vertices at each time slot defines a set of transmitters and a set of receivers in this slot. Link scheduling algorithms based on approximating MaxCut, and other applications in wireless networks, can be found in [48, 50, 26, 47, 49].^{1}^{1}1MaxCut naturally arises also in VLSI [8], statistical physics [4] and machine learning [46].
Surprisingly, MaxCut has been insufficiently studied in the classic distributed settings, where vertices communicate by synchronously sending messages to their neighbors according to the underlying graph, known as the or models. Indeed, there are known distributed algorithms for MaxCut using MapReduce techniques [5, 34, 35]. In this setting, the algorithms partition the ground set among machines and obtain a solution using all the outputs. However, despite a seemingly similar title, our distributed setting is completely different.
In this paper we address MaxCut in the classic distributed network models, where the graph represents a synchronous communication network. At the end of the computation, each vertex decides locally whether it joins the subset or , and outputs or , respectively, so as to obtain a cut of largest possible size.
It is well known that choosing a random cut, i.e., assigning each vertex to or with probability , yields a approximation for MaxCut, and a approximation for MaxDicut, defined on directed graphs (see, e.g., [36, 37]).^{2}^{2}2In MaxDicut we seek the maximum size edgeset crossing from to . Thus, a local algorithm, where each vertex outputs or with probability , yields the above approximation factors with no communication required. On the other hand, we note that a single vertex can find an optimal solution, once it has learned the underlying graph. However, this requires a number of communication rounds that depends linearly on global network parameters (depending on the exact model considered). This defines a tradeoff between time complexity and the approximation ratio obtained by distributed MaxCut algorithms. The huge gap between the above results raises the following natural questions: How well can MaxCut be approximated in the distributed setting, using a bounded number of communication rounds? Or, more precisely: How many communication rounds are required for obtaining an approximation ratio strictly larger than half, or even a deterministic approximation for MaxCut?
To the best of our knowledge, these questions have been studied in our distributed network models only for a restricted graph class. Specifically, the paper [21] suggests a distributed algorithm for MaxCut on regular trianglefree graphs, that requires a single communication round and provides a approximation.
The key contribution of our paper is in developing two main techniques for approximating MaxCut and MaxDicut in distributed networks, with any communication graph. Below we detail the challenges we face, and our methods for overcoming them.
1.1 The Challenge
In the model, where message sizes and the local computation power are unlimited, every standard graph problem can be solved in communication rounds. For MaxCut it also holds that finding an optimal solution requires communication rounds. This lower bound follows from Linial’s seminal lower bound [30, Theorem 2.2] for finding a 2coloring of an evensized cycle. In an even cycle, the maximum cut contains all edges. Therefore, finding a MaxCut is equivalent to finding a 2coloring of the graph.
An approach that proved successful in many computational settings in tackling hard problems is to relax the optimality requirement and settle for approximate solutions. Indeed, in the distributed setting, many approximation algorithms have been devised to overcome the costs of finding exact solutions (see, e.g., [28, 31, 15, 27, 20, 38, 2, 1, 29, 3], and the survey of Elkin [10]). Our work can be viewed as part of this general approach. However, we face crucial hurdles attempting to use the known sequential toolbox for approximating MaxCut in the distributed setting.
As mentioned above, a approximation for MaxCut can be obtained easily with no need for communication. While this holds in all of the above models, improving the ratio of is much more complicated. In the sequential setting, an approximation factor strictly larger than was obtained in the mid1990’s using semidefinite programming [16] (see Section 1.3). Almost two decades later, the technique was applied by [43] to obtain a parallel randomized algorithm for MaxCut, achieving a ratio of to the optimum, for any . Adapting this algorithm to our distributed setting seems nontrivial, as it relies heavily on global computation. Trying to apply other techniques, such as local search, unfortunately leads to linear running time, because of the need to compare values of global solutions.
Another obstacle that lies ahead is the lack of locality in MaxCut, due to strong dependency between the vertices. The existence of an edge in the cut depends on the assignment of both of its endpoints. This results in a chain of dependencies and raises the question whether cutting the chain can still guarantee a good approximation ratio.
1.2 Our Contribution
We develop two main techniques for approximating MaxCut, as well as MaxDicut. Our first technique relies on the crucial observation that the cut value is additive for edgedisjoint sets of vertices. Exploiting this property, we design clusteringbased algorithms, in which we decompose the graph into smalldiameter clusters, find an optimal solution within each cluster, and prove that the remaining edges still allow the final solution to meet the desired approximation ratio. An essential component in our algorithms is efficient graph decomposition to such smalldiameter clusters connected by few edges (also known as a padded partition), inspired by a parallel algorithm of [33] (see also [11, 12]).
For general graphs, this gives approximation algorithms for MaxCut and MaxDicut, requiring communication rounds in the model. For the special case of a bipartite graph, we take advantage of the graph structure to obtain an improved clusteringbased algorithm, which does not require large messages. The algorithm achieves a approximation for MaxCut in rounds, in the more restricted model.
For our second technique, we observe that the contribution of a specific vertex to the cut depends only on the vertex itself and its immediate neighbors. We leverage this fact to make multiple decisions in parallel by independent sets of vertices. We find such sets using distributed coloring algorithms. Our coloringbased technique, which makes nontrivial use of the greedy approach of [7] for maximizing an unconstrained submodular function, yields deterministic approximation and approximation algorithms for MaxCut and MaxDicut, respectively, and a randomized approximation algorithm for MaxDicut. Each of these algorithms requires communication rounds in the model, where is the maximal degree of the graph, and ignores polylogarithmic factors in .
Finally, we present algorithms which combine both of our techniques. Applying the coloringbased technique to lowdegree vertices, and the clusteringbased technique to highdegree vertices, allows as to design faster deterministic algorithms with approximation ratios of and for MaxCut and MaxDicut, respectively, requiring communication rounds. Table 1 summarizes our results.
1.3 Background and Related Work
The weighted version of MaxCut is one of Karp’s NPcomplete problems [24]. The unweighted version that we study here is also known to be NPcomplete [14].
While there are graph families, such as planar and bipartite graphs, in which a maximum cut can be found in polynomial time [18, 17], in general graphs, even approximating the problem is NPhard. In the sequential setting, one cannot obtain an approximation ratio better than for MaxCut, or an approximation ratio better than for MaxDicut, unless [45, 19].
Choosing a random cut, i.e., assigning each vertex to or with probability , yields a approximation for MaxCut, and approximation for MaxDicut. In the sequential setting there are also deterministic algorithms yielding the above approximation ratios [41, 39]. For 20 years there was no progress in improving the constant in the approximation ratio for MaxCut, until in 1995, Goemans and Williamson [16] achieved the currently best known approximation ratio for MaxCut, using semidefinite programming. They present a approximation algorithm, which is optimal assuming the Unique Game Conjecture holds [25]. In the same paper, Goemans and Williamson also give a approximation algorithm for MaxDicut. This ratio was improved later by Matuura et al. [32], to 0.863. Using spectral techniques, a approximation algorithm for MaxCut was given by Trevisan [44]. In [22] Kale and Seshadhri present a combinatorial approximation algorithm for MaxCut using random walks, which gives a approximation, where is some positive constant which appears also in the running time of the algorithm. In particular, for and times, the algorithm achieves approximation factors of and , respectively.
MaxCut and MaxDicut can also be viewed as special cases of submodular maximization, which has been widely studied. It is known that choosing a solution set uniformly at random yields a approximation, and a approximation for a general and for symmetric submodular function, respectively [13]. This corresponds to the known random approximation ratios for MaxCut and MaxDicut. Buchbinder et al. [7] present determinstic approximation algorithms for both symmetric and asymmetric submodular functions. These algorithms assume that the submodular function is accessible through a black box returning for any given set (known as the value oracle model).
In the recent years, there is an ongoing effort to develop distributed algorithms for submodular maximization problems, using MapReduce techniques [5, 34, 35]. Often, the inputs consist of large data sets, for which a sequential algorithm may be inefficient. The main idea behind these algorithms is to partition the ground set among machines, and have each machine solve the problem optimally independently of others. After all machines have completed their computations, they share their solutions. A final solution is obtained by solving the problem once again over a union of the partial solutions. The algorithms achieve performance guarantees close to the sequential algorithms while decreasing the running time, where the running time is the number of communication rounds among the machines. As mentioned above, these algorithms do not apply to our classic distributed settings.
2 Preliminaries
The MaxCut problem is defined as follows. Given an undirected graph , one needs to divide the vertices into two subsets, and , such that the size of the cut, i.e., the number of edges between and the complementary subset , is as large as possible. In the MaxDicut problem, the given graph is directed, and the cut is defined only as the edges which are directed from to . As in the MaxCut problem, the goal is to obtain the largest cut.
MaxCut and MaxDicut can be described as the problem of maximizing the submodular function , where for MaxDicut counts only the edges directed from to . Given a finite set , a submodular function is a function , where denotes the power set of , which satisfies the equivalent definitions:

For any :

For any and :
For MaxCut and MaxDicut, the submodular function also satisfies the following equality: For every disjoint sets such that , we have that . Note that for MaxCut, the function is also symmetric, i.e., .
Model: We consider a distributed system, modeled by a graph , in which the vertices represent the computational entities, and the edges represent the communication channels between them. We assume that each vertex has a unique identifier of size , where .
The communication between the entities is synchronous, i.e., the time is divided into rounds. In each round, the vertices send messages simultaneously to all of their neighbors and make a local computation based on the information gained so far. This is the classic model [40], which focuses on analyzing how locality affects the distributed computation. Therefore, the messages size and local computation are unlimited, and the complexity is measured by the number of communication rounds needed to obtain a solution. It is also important to study what can be done in the more restricted model [40], in which the message size is bounded to .
We assume that each vertex has preliminary information including the size of the network , its neighbors, and the maximal degree of the graph .^{3}^{3}3This assumption is needed only for the coloring algorithm [6] used in Section 4; it can be omitted (see [6]), increasing the running time by a constant factor.
Each vertex runs a local algorithm in order to solve the MaxCut problem. Along the algorithm, each vertex decides locally whether it should be in or in , and outputs or respectively. We define the solution of the algorithm, as the set of all outputs. Note that each vertex does not hold the entire solution, only local information. The solution is defined as the size of the cut induced by the solution. We show that this value approximates the size of the maximum cut.
3 ClusteringBased Algorithms
In this section we present clusteringbased algorithms for MaxCut and MaxDicut. Our technique uses the observation that MaxCut is a collection of edges having their endpoints in different sets; therefore, it can be viewed as the union of cuts in the disjoint parts of the graph.
Given a graph , we first eliminate a small fraction of edges to obtain smalldiameter connected components. Then, the problem is solved optimally within each connected component. For general graphs, this is done by gathering the topology of the component at a single vertex. For the special case of a bipartite graph, we can use the graph structure to propagate less information. Since the final solution, consisting of all the vertices local decisions, is at least as good as the sum of the optimal solutions in the components, and since the fraction of eliminated edges is small, we prove that the technique yields a approximation.
3.1 A Randomized Distributed Graph Decomposition
We start by presenting the randomized distributed graph decomposition algorithm. The algorithm is inspired by a parallel graph decomposition by Miller et al. [33] that we adapt to the distributed model as we describe next.^{4}^{4}4Our algorithm can be viewed as one phase of the distributed algorithm presented by Elkin et al. in [11] with some necessary changes.. The PRAM algorithm of [33] generates a strong padded partition of a given graph, namely, a partition into connected components with strong diameter , for some , such that the fraction of edges that cross between different clusters of the partition is at most . As we prove next, the distributed version guarantees the same properties with high probability and requires only communication rounds in the model.
The distributed version of the graph decomposition algorithm works as follows: Let be a random value that vertex chooses from an exponential distribution with parameter . Define the shifted distance from vertex to vertex as . Along the algorithm each vertex finds a vertex within its neighborhood, where is a constant, that minimizes . We define this vertex as ’s center. This step creates the difference between the parallel and the distributed decomposition, as in the parallel algorithm each vertex chooses its center from the entire ground set . However as we prove next, the process still generates a decomposition with the desired properties. Furthermore, w.h.p. the distributed algorithm outputs a decomposition identical to the one created by the parallel algorithm. A pseudocode of the algorithm is given in Algorithm 1.
We prove that the fraction of edges between different components is small. In order to do so, we bound the probability of an edge to be between components, i.e., the probability that the endpoints of the edge choose different centers. We consider two cases for an edge . In the first case, we assume that both and choose the center that minimizes their shifted distance, , over all the vertices in the graph. In other words, if the algorithm allowed each vertex to learn the entire graph, they would choose the same center as they did in the current algorithm. In the second case, we assume that at least one of and chooses differently if given a larger neighborhood.
Define the ideal center of a vertex as . In the following lemma we bound from above the probability that a vertex does not choose its ideal center.
Lemma 1
Let be the ideal center of vertex , then the probability that , i.e., vertex does not join its ideal center, is at most .
Proof
Since is the ideal center of vertex , we have that . Therefore, which implies that . That is, the distance between each vertex to its ideal center is bounded from above by , and hence . Using the cumulative exponential distribution, we have that . ∎
Corollary 1
The Distributed Decomposition algorithm generates a decomposition identical to the decomposition created by the parallel decomposition algorithm with probability at least
Define an exterior edge as an edge connecting different vertex components, and let denote the set of exterior edges. Let denote the event that both and choose their ideal centers.
Lemma 2
The probability that an edge is an exterior edge, given that and choose their ideal centers, is at most .
The lemma follows directly from [33], where indeed the algorithm assigns to each vertex its ideal center. We can now bound the probability of any edge to be an exterior edge.
Lemma 3
The probability that an edge is in is at most .
Proof
We can now prove the guarantees of the Distributed Decomposition algorithm. Recall that the weak diameter of a set is defined as .
Theorem 3.1
The Distributed Decomposition algorithm requires communication rounds in the model, and partitions the graph into components such that in expectation there are exterior edges. Each of the component is of weak diameter , and with high probability also of strong diameter .
Proof
Clearly, as every vertex chooses a center from its neighborhood, the distance between two vertices that choose the same center, i.e., belong to the same component, over the graph is at most . Therefore, the weak diameter of every component is at most . As we proved in Corollary 1, with probability at least the algorithm creates a partition identical to the one created by the parallel algorithm, and therefore with the exact same properties, which implies that the strong diameter of every component is at most as well.
Using the linearity of expectation, and Lemma 3 we have that Since , we have that for every , . Finally, as can be seen from the code, the algorithm requires communication rounds.∎
3.2 A Randomized Approximation Algorithm for MaxCut on a Bipartite Graph
Clearly, in a bipartite graph the maximum cut contains all of the edges. Such a cut can be found by selecting arbitrarily a root vertex, and then simply putting all the vertices of odd depth in one set and all the vertices of even depth in the complementary set. However, this would require a large computational time in our model, that depends on the diameter of the graph. We overcome this by using the above decomposition, and finding an optimal solution within each connected component. In each component , we find an optimal solution in communication rounds, where is the diameter of . First, the vertices in each component search for the vertex with the lowest id. ^{5}^{5}5This can be done by running a BFS in parallel from all vertices. Each vertex propagates the information from the root with lowest id it knows so far, and joins its tree. Thus, at the end of the process, we have a BFS tree rooted at the vertex with the lowest id.Second, the vertex with the lowest id joins or with equal probability and sends its decision to its neighbors. When a vertex receives a message from one of its neighbors, it joins the opposite set, outputs its decision, and sends it to its neighbors. Since finding the optimal solution within each component does not require learning the entire component topology, the algorithm is applicable to the more restricted model. The algorithm yields a approximation for the MaxCut problem on a bipartite graph in communication rounds with high probability.
Theorem 3.2
Bipartite MaxCut is a randomized approximation for MaxCut, requiring communication rounds in the model w.h.p.
Proof
After applying the decomposition algorithm, we have that each connected component has a diameter of at most w.h.p (Theorem 3.1). Building a BFS tree in a component clearly takes communication rounds. Assigning the vertices to sets after constructing a tree takes as well. Therefore, the algorithm finds an optimal solution in each of the components in communication rounds. Since every connected component is a bipartite graph itself, all the edges within it are in the cut. Therefore, as there are at most exterior edges, the algorithm obtain a cut of at least edges. Since the optimal cut in a bipartite graph contains all the edges, the algorithm achieves a approximation. Choosing proves the theorem.∎
3.3 A Randomized Approximation Algorithm for General Graphs
We present below a approximation algorithm for MaxCut in general graphs, using communication rounds. As before, the algorithm consists of two parts, decomposition and solution. Although the decomposition part itself works even in the model, the algorithm works in the model, since for general graphs the components created by the decomposition are not necessarily sparse, and learning the components topology is expensive in the model.
Theorem 3.3
DecompositionBased MaxCut is a randomized approximation for MaxCut, requiring communication rounds in the model.
Proof
Let be the set of edges that belong to some maximum cut in , and let be the set of edges in the cut obtained by DecompositionBased MaxCut. Let be the component induced by the vertices which choose as their center, and denote by the set of components that algorithm Distributed Decomposition constructs. Then The last inequality follows from the fact that for every graph it holds that .
The graph decomposition requires communication rounds, and outputs components with weak diameter at most . Therefore, finding the optimal solution within each component takes as well. The time bound follows.∎
By taking , one can now obtain a approximation algorithm for MaxDicut. The difference comes from the fact that for MaxDicut it holds that for every graph . The rest of the analysis is similar to the analysis for MaxCut. Hence, we have
Theorem 3.4
DecompositionBased MaxDicut is a randomized approximation for MaxDicut, requiring communication rounds in the model.
4 ColoringBased Algorithms
Many of the sequential approximation algorithms for MaxCut perform iterations. Each vertex, in its turn, makes a greedy decision so as to maximize the solution value. We present below distributed greedy algorithms which achieve the approximation ratios of the sequential algorithms much faster. We first prove that the greedy decisions of vertices can be done locally, depending only on their immediate neighbors. Then we show how to parallelize the decision process, such that in each iteration an independent set of vertices completes. The independent sets are generated using coloring; then, for iterations, all the vertices of the relevant color make their parallel independent decisions. All algorithms run in the model.
4.1 A Deterministic 1/2Approximation Algorithm for MaxCut
We start by presenting a simple deterministic distributed greedy algorithm that yields a 1/2approximation for MaxCut. The algorithm is inspired by the sequential greedy MaxCut algorithm of [41]. The greedy MaxCut algorithm iterates through the vertices in some arbitrary order. In iteration , the algorithm decides whether to assign vertex to or to , based on which placement maximizes the cut size. In our algorithm the process is similar, except that, in each iteration, instead of considering a single vertex, we consider an independent set of vertices. As the vertices are independent, their decisions are also independent, and the approximation ratio still holds.
To divide the vertices into independent sets, we color them using colors, where is the maximum degree in the graph. The best deterministic coloring algorithm known in the model, due to Barenboim [6], requires communication rounds, where ignores polylogarithmic factors in ^{6}^{6}6Note that a faster coloring algorithm will not improve the running time of Distributed Greedy MaxCut, since the running time of the algorithm depends on the number of colors, which is ..
Define a coloring such that for every . Let and denote the neighbors of vertex with lower colors. In iteration , all vertices with color decide in parallel whether to join or , depending on the choices their neighbors made in previous rounds. In order to maximize the cut locally, vertex chooses to join the subset that was chosen by the minority of its neighbors in . As we show next, this guarantees the 1/2approximation.
Algorithm 4 gives a pseudocode of the algorithm.
Theorem 4.1
The Distributed Greedy MaxCut algorithm outputs a approximation in rounds.
Proof
We first show that the algorithm gives a approximation. Consider an edge , if , then we say that is for edge . Denote by the set of edges vertex is responsible for. In other words, contains the edges between and vertices in . Since the color groups are independent, every edge has exactly one responsible vertex, therefore . When vertex makes its decision, it chooses to join the set that is not chosen by at least half of its neighbors in , and hence adds at least half of the edges in to the cut. Upon termination of the algorithm, we have that . Since the size of the optimal cut cannot be larger than , the algorithm yields a approximation.
The algorithm colors the graph in rounds and iterates for rounds, which yields the time bound.∎
4.2 A Deterministic 1/3Approximation Algorithm for MaxDicut
Next, we turn our attention to the MaxDicut problem. Buchbinder et al. [7] present a sequential deterministic greedy 1/3approximation algorithm for maximizing unconstrained submodular functions which runs in linear time. Inspired by this algorithm, we present a distributed deterministic 1/3approximation algorithm for MaxDicut that requires communication rounds in the model.
4.2.1 The sequential Algorithm
We first give a brief overview of the sequential algorithm of [7] for MaxDicut. Given a graph , where , the algorithm examines the vertices in an arbitrary order . In iteration , the algorithm decides greedily whether to include in the final solution, for . The algorithm maintains two sets of vertices, and . Initially, and . At the begining of the th iteration, the algorithm defines , then, the algorithm decides whether to add the th vertex to , or to remove it from . The decision is made by calculating the marginal profit of both options and choosing the more profitable one. By definition, upon termination of the algorithm we have that , and this set is output as the solution. Let be the size of the directed cut induced by a subset of vertices , i.e., the number of edges directed from to . Then is a nonnegative submodular function. Let and denote the marginal profit gained by adding the vertex to , or removing it from respectively. Algorithm 5 gives the pseudocode of the sequential algorithm of [7].
We give below a sketch of the analysis ^{7}^{7}7See the details in [7].. The following lemma implies that in each iteration, one can only increase the value of the solution.
Lemma 4
[7, Lemma 2.1] For every , it holds that .
Let denote the set that maximizes the dicut size. Define . In other words, agrees with and on the first elements, and agrees with on the rest. Hence, and . The following lemma shows that in each iteration, the damage to the optimal solution value, i.e., , is bounded.
Lemma 5
[7, Lemma 2.2] For every , it holds that
Theorem 4.2 (following from [7])
The Deterministic Sequential MaxDicut algorithm gives a 1/3approximation for the MaxDicut problem in linear time.
4.2.2 The Distributed Algorithm
Inspired by the sequential algorithm, we design a distributed algorithm which gives a 1/3approximation for the MaxDicut problem. As in Subsection 4.1, we start by ()coloring the graph. Then, for iterations, the vertices make their decisions, one color class at a time. In each iteration, the corresponding vertices calculate the marginal profit gained by their two possible decisions, and take the one which maximizes the profit. As in the sequential algorithm, the distributed algorithm maintains two solutions and ; and as before. and represent the state of the solutions after iterations, and is defined as .
Define , and . It is easy to see that as defined in the sequential algorithm equals . Similarly, . Using this notation, Algorithm 6 gives the pseudocode of the distributed algorithm.
There are two key ingredients in our analysis. We first prove that the marginal profits and can be computed locally. Then, we need to show that running the procedures in parallel does not affect the approximation ratio.
The next lemma shows that the marginal profits of ’s possible decisions depends only on its 1neighborhood.
Lemma 6
Let be a subset of vertices, and let be a vertex such that . Then .
Proof
Given such that , let denote the number of edges directed from vertices in to vertices in . We start by proving that for every subset and it holds that:
() 
Note that since is connected by edges only to its neighbors,
As , and , using we have that
which proves the lemma.∎
We now prove that making the decision to join or in parallel for independent sets does not affect the approximation ratio.
Lemma 7
For every , it holds that .
Proof
Let be an independent set of color . We show that iteration of the distributed algorithm is equivalent to iterations of the sequential one.
We can simulate the th iteration of the distributed algorithm as sequential iterations, where in the th iteration, vertex makes the exact same decision it makes in the distributed algorithm. Let represent the state of and after the th iteration of the simulation. Using the above notation, we prove the lemma by showing that:
For this, it suffices to show that , for all .
Since is an independent set, it holds that and for every , i.e. the decision of every vertex does not depend on the decisions made by the other vertices in . By Lemma 6, , and for every vertex . Therefore, given and , an iteration of the sequential algorithm is equivalent to the th iteration of the simulation. We now complete the proof using Lemma 5.∎
Theorem 4.3
The algorithm Distributed Greedy MaxDicut gives a 1/3approximation for the MaxDicut problem in communication rounds in the model.
Proof
We start by showing the approximation ratio. By Lemma 7, for all . Summing up the inequality for every gives:
As we saw in the sequential case, this is a telescopic sum that after cancellation gives:
The last equality follows from the fact that in the case of MaxDicut . Hence the output .
We now analyze the number of communication rounds needed. Coloring the graph using the algorithm of [6] takes communication rounds. After the coloring, the algorithm runs for () iterations, each one takes O(1) communication rounds, and hence, the time complexity follows.∎
4.3 A Randomized 1/2Approximation Algorithm for MaxDicut
As shown in [7], using random decisions improves the approximation ratio. The randomized algorithm differs from the deterministic algorithm in the decision making process. Rather than taking the most profitable decision, the algorithm takes each of the possible decisions with a probability proportional to its value. A formal description of the algorithm is given in Algorithm 7. The variables and are defined as in the deterministic distributed algorithm.
We first show the equivalent of Lemma 7, and then prove our main theorem for our algorithm.
Lemma 8
For every , it holds that:
() 
Proof
As shown in [7], for the sequential randomized algorithm, where in each step only one vertex makes a decision, it holds that . Also, as shown in the proof for Lemma 7, denoting by the independent set of vertices colored with , the th iteration of the distributed algorithm can be simulated by iterations of the sequential algorithm. Since the inequality holds for one iteration of the sequential algorithms, it holds for iterations, and therefore holds for the distributed algorithm.∎
Theorem 4.4
The algorithm Distributed Randomized MaxDicut outputs a 1/2approximation for MaxDicut in communication rounds.
Proof
The proof is very similar to the proof of Theorem 4.3. Using , and taking a summation over all , we have
Noting that the sum is telescopic, most of the terms cancel out, and we have
Therefore, since , we have that the output satisfies . The time complexity analysis is identical to the one for the deterministic algorithm.∎
5 A Deterministic Algorithm
Our coloringbased algorithms may become inefficient for high degree graphs, due to the strong dependence on . Consider a clique in this model. The above algorithms require a linear number of communication rounds, while learning the entire graph and finding an optimal solution requires only communication rounds in the model. Indeed, there is a tradeoff between the graph diameter and the average degree of its vertices. Based on this tradeoff, we propose a faster, twostep, deterministic algorithm for MaxCut that requires communication rounds in the model. The pseudocode is given in Algorithm 8.
We call a vertex a lowdegree vertex, if , and a highdegree vertex, if . Define , and as the graphs induced by the lowdegree vertices and the highdegree vertices, respectively. The idea is to solve the problem separately for and for .
In the first step, the algorithm deletes every highdegree vertex, if there are any, and its adjacent edges, creating . The deletion means that the lowdegree vertices ignore the edges that connect them to highdegree vertices, and do not communicate over them. Then, the algorithm approximates the MaxCut on , using one of the coloringbased algorithms described in Section 4.
In the second step, the problem is solved optimally within each connected component in . However, the highdegree ve