Fast Distributed Approximation for Max-Cut

Fast Distributed Approximation for Max-Cut

Keren Censor-Hillel Computer Science Department, Technion, Haifa 3200003, Israel. E-mail: {ckeren,rinalevy,hadas} research is supported in part by the Israel Science Foundation (grant 1696/14).    Rina Levy Computer Science Department, Technion, Haifa 3200003, Israel. E-mail: {ckeren,rinalevy,hadas}    Hadas Shachnai Computer Science Department, Technion, Haifa 3200003, Israel. E-mail: {ckeren,rinalevy,hadas}

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 Max-Cut 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 Max-Cut on bipartite graphs in the model, and on general graphs in the model.

We further present efficient deterministic algorithms, including a -approximation for Max-Dicut in our models, thus improving the best known (randomized) ratio of . Our algorithms make non-trivial use of the greedy approach of Buchbinder et al. (SIAM Journal on Computing, 2015) for maximizing an unconstrained (non-monotone) submodular function, which may be of independent interest.

Distributed graph algorithms, Max-Cut, Coloring, Clustering, Approximation Algorithms

1 Introduction

Max-Cut 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 NP-complete problems [24]. Since then, Max-Cut 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]).

Max-Cut 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 mix-tx-rx 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 Max-Cut in each time slot. A maximum cut contains the set of non-conflicting links that can be activated at the same time, i.e, they adhere to the no mix-tx-rx 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 Max-Cut, and other applications in wireless networks, can be found in [48, 50, 26, 47, 49].111Max-Cut naturally arises also in VLSI [8], statistical physics [4] and machine learning [46].

Surprisingly, Max-Cut 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 Max-Cut 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 Max-Cut 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 Max-Cut, and a -approximation for Max-Dicut, defined on directed graphs (see, e.g., [36, 37]).222In Max-Dicut we seek the maximum size edge-set 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 Max-Cut algorithms. The huge gap between the above results raises the following natural questions: How well can Max-Cut 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 Max-Cut?

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 Max-Cut on -regular triangle-free 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 Max-Cut and Max-Dicut 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 Max-Cut 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 2-coloring of an even-sized cycle. In an even cycle, the maximum cut contains all edges. Therefore, finding a Max-Cut is equivalent to finding a 2-coloring 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 Max-Cut in the distributed setting.

As mentioned above, a -approximation for Max-Cut 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 mid-1990’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 Max-Cut, achieving a ratio of to the optimum, for any . Adapting this algorithm to our distributed setting seems non-trivial, 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 Max-Cut, 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 Max-Cut, as well as Max-Dicut. Our first technique relies on the crucial observation that the cut value is additive for edge-disjoint sets of vertices. Exploiting this property, we design clustering-based algorithms, in which we decompose the graph into small-diameter 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 small-diameter 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 Max-Cut and Max-Dicut, 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 clustering-based algorithm, which does not require large messages. The algorithm achieves a -approximation for Max-Cut 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 coloring-based technique, which makes non-trivial use of the greedy approach of [7] for maximizing an unconstrained submodular function, yields deterministic -approximation and -approximation algorithms for Max-Cut and Max-Dicut, respectively, and a randomized -approximation algorithm for Max-Dicut. 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 coloring-based technique to low-degree vertices, and the clustering-based technique to high-degree vertices, allows as to design faster deterministic algorithms with approximation ratios of and for Max-Cut and Max-Dicut, respectively, requiring communication rounds. Table 1 summarizes our results.

Algorithm Properties Approximation Ratio Rounds Deterministic Model Graph Max-Cut Max-Dicut no communication any 1/2 1/4 folklore bipartite new any new any new any new any new

Table 1: A summary of our results.

1.3 Background and Related Work

The weighted version of Max-Cut is one of Karp’s NP-complete problems [24]. The unweighted version that we study here is also known to be NP-complete [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 NP-hard. In the sequential setting, one cannot obtain an approximation ratio better than for Max-Cut, or an approximation ratio better than for Max-Dicut, unless [45, 19].

Choosing a random cut, i.e., assigning each vertex to or with probability , yields a -approximation for Max-Cut, and -approximation for Max-Dicut. 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 Max-Cut, until in 1995, Goemans and Williamson [16] achieved the currently best known approximation ratio for Max-Cut, 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 Max-Dicut. This ratio was improved later by Matuura et al. [32], to 0.863. Using spectral techniques, a -approximation algorithm for Max-Cut was given by Trevisan [44]. In [22] Kale and Seshadhri present a combinatorial approximation algorithm for Max-Cut 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.

Max-Cut and Max-Dicut 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 Max-Cut and Max-Dicut. 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 Max-Cut 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 Max-Dicut problem, the given graph is directed, and the cut is defined only as the edges which are directed from to . As in the Max-Cut problem, the goal is to obtain the largest cut.

Max-Cut and Max-Dicut can be described as the problem of maximizing the submodular function , where for Max-Dicut 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:

  1. For any :

  2. For any and :

For Max-Cut and Max-Dicut, the submodular function also satisfies the following equality: For every disjoint sets such that , we have that . Note that for Max-Cut, 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 .333This 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 Max-Cut 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 Clustering-Based Algorithms

In this section we present clustering-based algorithms for Max-Cut and Max-Dicut. Our technique uses the observation that Max-Cut 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 small-diameter 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.444Our 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.

2:choose at random from
5:for  iterations do
6:     send
7:     for every received from  do
8:         if  OR AND  then
11:         end if
12:     end for
13:end for
Algorithm 1 Distributed Decomposition, code for vertex

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 .


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 .


Note that

By Lemma 2, . Applying the union bound on the result of Lemma 1, we have that . Therefore

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 .


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 Max-Cut 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. 555This 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 Max-Cut problem on a bipartite graph in communication rounds with high probability.

Theorem 3.2

Bipartite Max-Cut is a randomized -approximation for Max-Cut, requiring communication rounds in the model w.h.p.


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.∎

2:apply Distributed Decomposition on G, with
3:for each component obtained by the decomposition do
4:     build a BFS tree from the vertex with the lowest id
5:     assign to or with equal probability, assign the rest of the vertices to alternating sides
6:end for
Algorithm 2 Bipartite Max-Cut

3.3 A Randomized -Approximation Algorithm for General Graphs

We present below a -approximation algorithm for Max-Cut 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.

2:apply Distributed Decomposition on G, with
3:for each component obtained by the decomposition do
4:     gather the component topology at the vertex with the lowest id.
5:     let find an optimal solution and determine the value output by the component’s vertices.
6:end for
Algorithm 3 Decomposition-Based Max-Cut
Theorem 3.3

Decomposition-Based Max-Cut is a randomized -approximation for Max-Cut, requiring communication rounds in the model.


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 Decomposition-Based Max-Cut. 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 Max-Dicut. The difference comes from the fact that for Max-Dicut it holds that for every graph . The rest of the analysis is similar to the analysis for Max-Cut. Hence, we have

Theorem 3.4

Decomposition-Based Max-Dicut is a randomized -approximation for Max-Dicut, requiring communication rounds in the model.

4 Coloring-Based Algorithms

Many of the sequential approximation algorithms for Max-Cut 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/2-Approximation Algorithm for Max-Cut

We start by presenting a simple deterministic distributed greedy algorithm that yields a 1/2-approximation for Max-Cut. The algorithm is inspired by the sequential greedy Max-Cut algorithm of [41]. The greedy Max-Cut 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 666Note that a faster -coloring algorithm will not improve the running time of Distributed Greedy Max-Cut, 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/2-approximation.

Algorithm 4 gives a pseudocode of the algorithm.

1:color the graph using colors
2:for i=1 to  do
3:     if  then
4:         if  then
5:              State() =
6:              send 1
7:         else
8:              State() =
9:              send 0
10:         end if
11:     end if
12:end for
13:output State
Algorithm 4 Distributed Greedy Max-Cut
Theorem 4.1

The Distributed Greedy Max-Cut algorithm outputs a -approximation in rounds.


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/3-Approximation Algorithm for Max-Dicut

Next, we turn our attention to the Max-Dicut problem. Buchbinder et al. [7] present a sequential deterministic greedy 1/3-approximation algorithm for maximizing unconstrained submodular functions which runs in linear time. Inspired by this algorithm, we present a distributed deterministic 1/3-approximation algorithm for Max-Dicut 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 Max-Dicut. 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 non-negative 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].

3:for i=1 to n do
6:     if  then
9:     else
12:     end if
13:end for
Algorithm 5 Deterministic Sequential Max-Dicut

We give below a sketch of the analysis 777See 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

Using Lemmas 4,5, one can prove the following theorem.

Theorem 4.2 (following from [7])

The Deterministic Sequential Max-Dicut algorithm gives a 1/3-approximation for the Max-Dicut problem in linear time.

4.2.2 The Distributed Algorithm

Inspired by the sequential algorithm, we design a distributed algorithm which gives a 1/3-approximation for the Max-Dicut 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.

2:color the graph using colors
3:for i=1 to  do
4:     if  then
7:         if  then
8:              State() =
9:              send 1
10:         else
11:              State() =
12:              send 0
13:         end if
14:     end if
15:     for each vertex in in parallel do
16:          sent 1
17:          sent 0
18:     end for
19:end for
20:output State
Algorithm 6 Distributed Greedy Max-Dicut

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 1-neighborhood.

Lemma 6

Let be a subset of vertices, and let be a vertex such that . Then .


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 .


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 Max-Dicut gives a 1/3-approximation for the Max-Dicut problem in communication rounds in the model.


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 Max-Dicut . 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/2-Approximation Algorithm for Max-Dicut

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.

2:color the graph using colors
3:for i=1 to  do
4:     if  then
8:         with probability do
9:         State() =
10:         send 1
11:         else (with probability ) do
12:         State() =
13:         send 0
14:     end if
15:     for each vertex in in parallel do
16:          sent 1
17:          sent 0
18:     end for
19:end for
20:output State
Algorithm 7 Distributed Randomized Max-Dicut

We first show the equivalent of Lemma 7, and then prove our main theorem for our algorithm.

Lemma 8

For every , it holds that:


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 Max-Dicut outputs a 1/2-approximation for Max-Dicut in communication rounds.


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 coloring-based 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, two-step, deterministic algorithm for Max-Cut that requires communication rounds in the model. The pseudocode is given in Algorithm 8.

We call a vertex a low-degree vertex, if , and a high-degree vertex, if . Define , and as the graphs induced by the low-degree vertices and the high-degree vertices, respectively. The idea is to solve the problem separately for and for .

In the first step, the algorithm deletes every high-degree vertex, if there are any, and its adjacent edges, creating . The deletion means that the low-degree vertices ignore the edges that connect them to high-degree vertices, and do not communicate over them. Then, the algorithm approximates the Max-Cut on , using one of the coloring-based algorithms described in Section 4.

In the second step, the problem is solved optimally within each connected component in . However, the high-degree ve