Combinatorial Algorithm for Restricted MaxMin Fair Allocation
Abstract
We study the basic allocation problem of assigning resources to players so as to maximize fairness. This is one of the few natural problems that enjoys the intriguing status of having a better estimation algorithm than approximation algorithm. Indeed, a certain ConfigurationLP can be used to estimate the value of the optimal allocation to within a factor of . In contrast, however, the best known approximation algorithm for the problem has an unspecified large constant guarantee.
In this paper we significantly narrow this gap by giving a approximation algorithm for the problem. Our approach develops a local search technique introduced by Haxell [Hax95] for hypergraph matchings, and later used in this context by Asadpour, Feige, and Saberi [AFS12]. For our local search procedure to terminate in polynomial time, we introduce several new ideas such as lazy updates and greedy players. Besides the improved approximation guarantee, the highlight of our approach is that it is purely combinatorial and uses the ConfigurationLP only in the analysis.
eq(LABEL:*#1) \newrefformatlemLemma LABEL:*#1 \newrefformatdefDefinition LABEL:*#1 \newrefformatthmTheorem LABEL:*#1 \newrefformatcorCorollary LABEL:*#1 \newrefformatchaChapter LABEL:*#1 \newrefformatsecSection LABEL:*#1 \newrefformatappAppendix LABEL:*#1 \newrefformattabTable LABEL:*#1 \newrefformatfigFigure LABEL:*#1 \newrefformathypHypothesis LABEL:*#1 \newrefformatalgAlgorithm LABEL:*#1 \newrefformatremRemark LABEL:*#1 \newrefformatitemItem LABEL:*#1 \newrefformatstepstep LABEL:*#1 \newrefformatconjConjecture LABEL:*#1 \newrefformatfactFact LABEL:*#1 \newrefformatpropProposition LABEL:*#1 \newrefformatprobProblem LABEL:*#1 \newrefformatclaimClaim LABEL:*#1 \newrefformatrelaxRelaxation LABEL:*#1 \newrefformatredReduction LABEL:*#1 \newrefformatpartPart LABEL:*#1
Keywords: approximation algorithms, fair allocation, efficient local search
1 Introduction
We consider the MaxMin Fair Allocation problem, a basic combinatorial optimization problem, that captures the dilemma of how to allocate resources to players in a fair manner. A problem instance is defined by a set of indivisible resources, a set of players, and a set of nonnegative values where each player has a value for a resource . An allocation is simply a partition of the resource set and the valuation function for any player is additive, i.e., Perhaps the most natural fairness criterion in this setting is the maxmin objective which tries to find an allocation that maximizes the minimum value of resources received by any player in the allocation. Thus, the goal in this problem is to find an allocation that maximizes
This problem has also been given the name Santa Claus problem as interpreting the players as kids and the resources as presents leads to Santa’s annual allocation problem of making the least happy kid as happy as possible.
A closely related problem is the classic scheduling problem of Scheduling on Unrelated Parallel Machines to Minimize Makespan. That problem has the same input as above and the only difference is the objective function: instead of maximizing the minimum we wish to minimize the maximum. In the scheduling context, this corresponds to minimizing the time at which all jobs (resources) are completed by the machines (players) they were scheduled on. In a seminal paper, Lenstra, Shmoys, and Tardos [LST90] showed that the scheduling problem admits a approximation algorithm by rounding a certain linear programming relaxation often referred to as the AssignmentLP. Their approximation algorithm in fact has the often stronger guarantee that the returned solution has value at most , where is the maximum value of a job (resource).
From the similarity between the two problems, it is natural to expect that the techniques developed for the scheduling problem are also applicable in this context. What is perhaps surprising is that the guarantees have not carried over so far, contrary to expectation. While a rounding of the AssignmentLP has been shown [BD05] to provide an allocation of value at least , this guarantee deteriorates with increasing . Since in hard instances of the problem (when ) there can be players who are assigned only one resource in an optimal allocation, this result provides no guarantee in general. The lack of guarantee is in fact intrinsic to the AssignmentLP for MaxMin Fair Allocation as the relaxation is quite weak. It has an unbounded integrality gap i.e., the optimal value of the linear program can be a polynomial factor larger than the optimal value of an integral solution.
To overcome the limitations of the AssignmentLP, Bansal and Sviridenko [BS06] proposed to use a stronger relaxation, called ConfigurationLP, for MaxMin Fair Allocation. Their paper contains several results on the strength of the ConfigurationLP, one negative and many positive. The negative result says that even the stronger ConfigurationLP has an integrality gap that grows as . Their positive results apply for the interesting case when , called Restricted MaxMin Fair Allocation. For this case they give an approximation algorithm, a substantial improvement over the integrality gap of the AssignmentLP. Notice that the restricted version has the following natural interpretation: each resource has a fixed value but it is interesting only for some subset of the players.
Bansal and Sviridenko further showed that the solution to a certain combinatorial problem on set systems would imply a constant integrality gap. This was later settled positively by Feige [Fei08a] using a proof technique that repeatedly used the Lovász Local Lemma. At the time of Feige’s result, however, it was not known if his arguments were constructive, i.e., if it led to a polynomial time algorithm for finding a solution with the same guarantee. This was later shown to be the case by Haeupler et al. [HSS11], who constructivized the various applications of the Lovász Local Lemma in the paper by Feige [Fei08a]. This led to the first constant factor approximation algorithm for Restricted MaxMin Fair Allocation, albeit with a large and unspecified constant. This approach also requires the solution of the exponentially large ConfigurationLP obtained by using the ellipsoid algorithm.
A different viewpoint and rounding approach for the problem was initiated by Asadpour, Feige, and Saberi [AFS12]. This approach uses the perspective of hypergraph matchings where one can naturally interpret the problem as a bipartite hypergraph matching problem with bipartitions and . Indeed, in a solution of value , each player is matched to a subset of resources of total value at least which corresponds to a hyperedge . Previously, Haxell [Hax95] provided sufficient conditions for bipartite hypergraphs to admit a perfect matching, generalizing the well known graph analog, viz., Hall’s theorem. Her proof is algorithmic in the sense that when the sufficient conditions hold, then a perfect matching can be found using a local search procedure that will terminate after at most exponentially many iterations. Haxell’s techniques were successfully adapted by Asadpour et al. [AFS12] to the Restricted MaxMin Fair Allocation problem to obtain a beautiful proof showing that the ConfigurationLP has an integrality gap of at most . As the ConfigurationLP can be solved to any desired accuracy in polynomial time, this gives a polynomial time algorithm to estimate the value of an optimal allocation up to a factor of , for any . Tantalizingly, however, the techniques of [AFS12] do not yield an efficient algorithm for finding an allocation with the same guarantee.
The above results lend the Restricted MaxMin Fair Allocation problem an intriguing status that few other natural problems enjoy (see [Fei08b] for a comprehensive discussion on the difference between estimation and approximation algorithms). Another problem with a similar status is the restricted version of the aforementioned scheduling problem. The techniques in [AFS12] inspired the last author to show [Sve12] that the ConfigurationLP estimates the optimal value within a factor improving on the factor of by Lenstra et al. [LST90]. Again, the algorithm in [Sve12] is not known to terminate in polynomial time. We believe that this situation illustrates the need for new tools that improve our understanding of the ConfigurationLP especially in the context of basic allocation problems in combinatorial optimization.
Our results
Our main result improves the approximation guarantee for the Restricted MaxMin Fair Allocation problem. Note that .
Theorem 1.
For every , there exists a combinatorial approximation algorithm for the Restricted MaxMin Fair Allocation problem that runs in time where is the size of the instance.
Our algorithm has the advantage of being completely combinatorial. It does not solve the exponentially large ConfigurationLP. Instead, we use it only in the analysis to compare the value of the allocation returned by our algorithm against the optimum. As our hidden constants are small, we believe that our algorithm is more attractive than solving the ConfigurationLP for a moderate . Our approach is based on the local search procedure introduced in this context by Asadpour et al. [AFS12], who in turn were inspired by the work of Haxell [Hax95]. Asadpour et al. raised the natural question if local search procedures based on alternating trees can be made to run in polynomial time. Prior to this work, the best running time guarantee was a quasipolynomial time alternating tree algorithm by Poláček and Svensson [PS12]. The main idea in that paper was to show that the local search can be restricted to alternating paths of length (according to a carefully chosen length function), where is the number of players and resources. This restricts the search space of the local search giving the running time of . To further reduce the search space seems highly nontrivial and it is not where our improvement comes from. Rather, in contrast to the previous local search algorithms, we do not update the partial matching as soon as an alternating path is found. Instead, we wait until we are guaranteed a significant number of alternating paths, which then intuitively guarantees large progress. We refer to this concept as lazy updates. At the same time, we ensure that our alternating paths are short by introducing greedy players into our alternating tree: a player may claim more resources than she needs in an approximate solution.
To best illustrate these ideas we have chosen to first present a simpler algorithm in Section 3. The result of that section still gives an improved approximation guarantee and a polynomial time local search algorithm. However, it is not combinatorial as it relies on a preprocessing step which in turn uses the solution of the ConfigurationLP. Our combinatorial algorithm is then presented in Section 4. The virtue of explaining the simpler algorithm first is that it allows us to postpone some of the complexities of the combinatorial algorithm until later, while still demonstrating the key ideas mentioned above.
Further related work
As mentioned before, the ConfigurationLP has an integrality gap of for the general MaxMin Fair Allocation problem. Asadpour and Saberi [AS07] almost matched this bound by giving a approximation algorithm; later improved by Saha and Srinivisan [SS10] to . The current best approximation is due to Bateni et al. [BCG09] and Chakraborty et al. [CCK09]; for any their algorithms run in time . This leaves a large gap in the approximation guarantee for the general version of the problem as the only known hardness result says that it is NPhard to approximate the problem to within a factor less than [BD05]. The same hardness also holds for the restricted version.
2 The ConfigurationLP
Recall that a solution to the MaxMin Fair Allocation problem of value is a partition of the set of resources so that each player receives a set of value at least , i.e., for . Let be the set of configurations that player can be allocated in a solution of value . The ConfigurationLP has a decision variable for each player and each . The intuition is that the variable takes value if and only if she is assigned the bundle . The ConfigurationLP is now a feasibility linear program with two sets of constraints: the first set says that each player should receive (at least) one configuration and the second set says that each item should be assigned to at most one player. The formal definition is given in the left box of Figure 1.
It is easy to see that if is feasible, then so is for all . We say that the value of the ConfigurationLP is if it is the largest value such that the above program is feasible. Since every feasible allocation is a feasible solution of the ConfigurationLP, is an upper bound on the value of the optimal allocation and therefore constitues a valid relaxation.
We note that the LP has exponentially many variables; however, it is known that one can approximately solve it to any desired accuracy by designing a polynomial time (approximate) separation algorithm for the dual [BS06]. For our combinatorial algorithm, the dual shall play an important role in our analysis. By associating the sets of variables and to the constraints in the primal corresponding to players and resources respectively, and letting the primal have the objective function of minimizing the zero function, we obtain the dual of shown in the right box of Figure 1.
3 Polynomial time algorithm
To illustrate our key ideas we first describe a simpler algorithm that works on clustered instances. This setting, while equivalent to the general problem up to constant factors, allows for a simpler exposition of our key ideas. Specifically, we will prove the following theorem in this section.
Theorem 1.
There is a polynomial time approximation for restricted maxmin fair allocation.
We note, however, that producing such clustered instances requires solving the ConfigurationLP. To avoid solving it, and get a purely combinatorial algorithm, we will show how to bypass the clustering step in Section 4.
Before describing our algorithm formally, we begin by giving an informal overview of how it works, while pointing out the key ideas behind it.
3.1 Intuitive Algorithm Description and Main Ideas
Our first step towards recovering an approximate solution to an instance of restricted maxmin fair allocation, is guessing the value of the ConfigurationLP by performing a binary search over the range of its possible values. For a particular guess , assuming that is feasible, our goal now is to approximately satisfy each player. That is, we will allocate for each player a disjoint collection of resources, whose value for that player is at least . Towards this end, we design a local search procedure, that we will apply iteratively in order to find such a approximate allocation. The input to this procedure will be a partial allocation that satisfies some (possibly empty) subset of the players, and an unsatisfied player. Then, our local search procedure will extend the allocation in order to satisfy the input player as well; hence, applying this procedure iteratively will satisfy all the players.
We now illustrate some key aspects of this local search procedure through an example that appears in Figure 2; for simplicity, in this example we consider only resources of value less than . Given a partial allocation of resources to a subset of the players, we wish to extend this to satisfy an additional player . If there are free resources (i.e., not already appearing in our partial allocation) of total value for , then we just satisfy by assigning those resources to her. Otherwise, we find a set of resources whose value for is at least ; these resources constitute a bundle (or, as we will refer to it later on, an edge) we would wish to include in our partial allocation in order to satisfy . However, we cannot include this edge right away because there already exist edges in our partial allocation that share resources with ; in other words, such edges are blocking the inclusion of into our partial allocation. In Figure 2(a), is the gray edge, and its blocking edges are the white ones.
At this point, we should make note of the fact that the size of is considerably larger than our goal of ; this is by design and due to our greedy strategy. By considering edges whose size exceeds our goal, we are able to increase the rate at which blocking edges are inserted into our local search; indeed, in Figure 2(a), a single greedilyconstructed edge () introduced 3 blocking edges. Ultimately, this will allow us to bound the running time of our local search.
Now, since our goal is to include in our partial allocation, we are required to free up some of ’s resources by finding an alternative way of satisfying the players included in ’s blocking edges. The steps we take towards this end appear in Figure 2(b): for each player in ’s blocking edges, we find a new edge that we would wish to include into our partial allocation. But these new gray edges might also be blocked by existing edges in our partial allocation. Therefore this step introduces a second layer of edges comprising a set of edges we would like to include in our allocation, and their corresponding blocking edges; these layers are separated by dashed lines in the example.
Next, we observe that 2 of the 3 gray edges in the second layer actually have a lot of resources that do not appear in any blocking edge. In this case, as one can see in Figure 2(c), we select a subset of free resources from each edge of size at least (drawn with dashed lines), and swap these edges for the existing white edges in our partial allocation. We call this operation a collapse of the first layer, only to be left with and a single blocking edge in the first layer. The way we decide when to collapse a layer, is dictated by our strategy of lazy updates: similar to Figure 2(c), we will only collapse a layer if that would mean that a large fraction of its blocking edges will be removed.
Finally, in Figure 2(d), a significant amount of resources of has now been freed up. Then, we choose a subset of these resources (again, drawn with a dashed line), and allocate them to . At this point, we have satisfied , and managed to extend our partial allocation to satisfy one more player.
We proceed by formally defining and analyzing the local search algorithm we sketched above.
3.2 Parameters
Let be a guess on the value of the ConfigurationLP. Our algorithm will use the following setting of parameters:
(3.1) 
Here, is the approximation guarantee, determines the “greediness” of the edges introduced into the layers, and determines the “laziness” of the updates of our algorithm. As our goal is to expose the main ideas, we have not optimized the constants in this section.
We shall show that whenever is feasible, our algorithm will terminate with a solution of value at least for the given instance of restricted maxmin fair allocation. Combining this with a standard binary search then yields a approximation algorithm.
3.3 Thin and fat edges, and matchings
We partition the resource set into and , fat and thin resources respectively. Note that in a approximate solution, a player is satisfied if she is assigned a single fat resource whereas she needs several thin resources. We will call a pair , for any and such that where , an edge. Notice that this definition implies that every resource in is a resource that player is interested in. We now define thin and fat edges.
Definition 2 (Thin and fat edges).
We will call an edge , where and , fat, if contains a single fat resource that is interested in; this already implies that . On the other hand, we will call an edge , where and , thin, if is a set of thin resources that is interested in.
Finally, for any , we will call an edge , where and , a edge, if is a minimal set (by inclusion) of resources of value at least for , i.e., .
Remark 3.
A thin edge has value at most due to the minimality of the edge.
As we have already mentioned, the goal of our local search algorithm is to iteratively extend a partial matching:
Definition 4 (Matchings).
A set of edges is called a matching if each player appears in at most one edge and the set of resources used by the edges in are pairwise disjoint. We say that matches a player if there exists an edge in that contains . Moreover, it is called a perfect matching if each player is matched by , and otherwise it is called a partial matching.
Using the above terminology, our goal is to find a perfect matching yielding our desired allocation of value . Our approach will be to show that as long as the matching does not match all players in we can extend it to obtain a matching that matches one more player. This ensures that starting with an empty partial matching and repeating this procedure times we will obtain an allocation of value at least . Thus, it suffices to develop such an algorithm. This is precisely what our algorithm will do. We first state a preprocessing step in Section 3.4 before describing the algorithm in Section 3.5.
3.4 Clustering step
This preprocessing phase produces the clustered instances referred to earlier. The clustering step that we use is the following reduction due to Bansal and Sviridenko.
Theorem 5 (Clustering Step [Bs06]).
Assuming that is feasible, we can partition the set of players into clusters in polynomial time such that

Each cluster is associated with a distinct subset of fat items from such that they can be assigned to any subset of players in , and

there is a feasible solution to such that for each cluster , where denotes the set of configurations for player comprising only thin items.
Note that the player that is not assigned a fat item can be chosen arbitrarily and independently for each cluster in the above theorem. Therefore, after this reduction, it suffices to allocate a thin edge for one player in each cluster to obtain a approximate solution for the original instance. Indeed, Theorem 5 guarantees that we can assign fat edges for the remaining players. For the rest of the section we assume that our instance has been grouped into clusters by an application of Theorem 5. The second property of these clusters is that each cluster is fractionally assigned LPvalue of thin configurations. We will use this to prove the key lemma in this section, Lemma 6.
We now focus only on allocating one thin edge per cluster and forget about fat items completely. This makes the algorithm in Section 3.5 simpler than our final combinatorial algorithm, where we also need to handle the assignment of fat items to players.
3.5 Description of the algorithm
Notation: Recall that it suffices to match exactly one player from each cluster with a thin edge. With this in mind, we say that a cluster is matched by if there exists some player such that is matched by . For a set of edges, we let denote the union of the resources of these edges and we let denote the union of players of these edges. To ease notation, we abbreviate by in the description of the algorithm and its analysis. Finally, for any family of sets we denote by .
The input to Algorithm 1 is a partial matching that matches at most one player from each cluster , and a cluster that is not matched by ; our goal is to extend our partial matching by matching .
The state of the algorithm is described by a (dynamic) tuple , where is the current partial matching and is a list of pairs of sets of “added” and “blocking” edges that is of length/depth . We shall refer to as the ’th layer^{1}^{1}1The edges of the algorithm naturally form layers as described in Section 3.1 and as depicted in Figure 2. The edges in are added so as to try to “replace” edges in in the matching . are then the edges of that are blocking the edges in ..
Invariants
The description of our algorithm appears as Algorithm 1. The algorithm is designed to (apart from extending the matching) maintain the following invariants at the start of each iterative step: for ,

is a set of thin edges that are pairwise disjoint, i.e., for two different edges we have and . In addition, each edge has (its resources are not shared with edges from earlier iterations or edges in ).

contains those edges of that blocks edges in , where we say that an edge blocks an edge if .

The players of the edges in belong to different clusters and any cluster with a player that appears in an edge in has a player (that may equal ) that appears in an edge in .

where, as in Step 3 of Algorithm 1, is defined to be those edges that have sufficient amount of unblocked resources so as to be added to the matching.
In what follows, we further explain the steps of the algorithm and why the invariants are satisfied. It will then also be clear that the algorithm outputs an extended matching whenever it terminates. We then analyze its running time in the next section.
First the algorithm initializes by selecting an arbitrary player in the cluster that we wish to match. Then each iteration proceeds in two steps. In the build phase, the algorithm adds thin edges (at most one for each cluster with a player in ) to . Notice that the resources of these edges are disjoint from and from each other. We therefore maintain the first invariant. At the end of the build phase, we define to satisfy the second invariant. The third invariant is also satisfied since we only iterate through the clusters with a player in and add at most one edge to for each such cluster. So after the build phase, the first three invariants are satisfied.
The collapse phase will ensure the fourth invariant while not introducing any violations of the first three. Indeed, the whileloop runs until the fourth invariant is satisfied so we only need to worry about the first three still being satisfied. The first and third invariants remain satisfied because any set that was affected in the collapse phase is discarded from the algorithm and if was changed then was also discarded. For the second invariant, note that after updating the matching , we remove the edge that was removed from the matching from . Hence, still only contains edges of the new matching that blocks edges in . Moreover, by the first invariant, the newly introduced edge in the matching does not share any resources with edges in . Hence, the second invariant also remains true. Finally, we note that remains a matching during the update procedure that matches all clusters that were initially matched. Indeed, when is removed an edge is added to the matching with being from the same cluster as (or the algorithm terminates by having successfully matched a player in ). The added edge is a edge and its resources are disjoint from all edges in since (1) is a subset of , (2) contains all blocking edges of with respect to the matching before the collapse phase, and (3) the edges in are disjoint so is disjoint from any other edges added to the matching in the same collapse phase. We thus maintain a valid matching, in which all edges are pairwise disjoint, and the output is an extended matching that also matches the cluster .
3.6 Analysis of the algorithm
We now proceed to show that the algorithm in Section 3.5 terminates in polynomial time, which then implies Theorem 1. Recall that is the parameter that regulates the “greediness” of the players while is the approximation guarantee, and dictates when we collapse a layer.
The key lemma that we prove in this section is that in each layer , the number of edges in is large compared to the number of blocking edges (or, similarly, the number of players) of lower layers.
Lemma 6.
Assuming that is feasible, at the beginning of each iterative step, for each
We defer the proof of this statement for now and explain its consequences. As thin items are of value less than , and each edge in is a thin edge of value at least , this implies that must be quite large, using from the fourth invariant. This means that the number of blocking edges will grow quickly as we prove in the next lemma.
Lemma 7 (Exponential growth).
Assuming that is feasible, at the beginning of the iterative step for
Proof.
Fix an such that . By the fourth invariant, at the beginning of the iterative step. This means that there are at least many edges in which are not in . As each edge in has resources of value at least that are blocked (i.e., contained in ), we can lower bound the total value of blocked resources appearing in by
Further, since each edge in is of value at most by minimality, the total value of such resources is upper bounded by In total,
where we have used Lemma 6 to bound by from below. ∎
Since the number of blocking edges grows exponentially as a function of the layer index, an immediate consequence of Lemma 7 is that the total number of layers in the list at any step in the algorithm is at most This means that we have to satisfy the condition in the whileloop of the collapse phase after at most logarithmically many iterative steps. When this happens, Algorithm 1 selects the smallest satisfying the condition and then proceeds to update and . Note that, by the condition of the whileloop, and since each edge in will be updated in the forloop (using the third invariant), a constant fraction (at least as defined in (3.1)) of the edges in are removed. We refer to these steps of the algorithm as the collapse of layer . Furthermore, due to the algorithm’s first invariant, we know that the edges that compose are pairwise disjoint; therefore, we are able to insert all of them simultaneously into our matching, which means that the size of our matching does not decrease during the collapse operation. On the contrary, if is part of the edges that are inserted into , then we have actually achieved to extend our matching . Intuitively we make large progress whenever we update during the collapse of a layer. We prove this by maintaining a signature vector during the execution of the algorithm, where
Lemma 8.
The signature vector always reduces in lexicographic value across each iterative step, and the coordinates of the signature vector are always nondecreasing, i.e., .
Proof.
Let and be the signature vectors at the beginning and at the end of some iterative step. We now consider two cases depending on whether a collapse operation occurs in this iterative step.

No layer was collapsed. Clearly, has smaller lexicographic value compared to .

At least one layer was collapsed. Let denote the index corresponding to the newly created layer in the build phase. Let be the most recent index chosen in the whileloop during the collapse phase. As a result of the collapse operation suppose the layer changed to . Then we know that Since none of the layers with indices less than were affected during this procedure, where This shows that the lexicographic value of the signature vector decreases.
In both cases, the fact that the coordinates of are nondecreasing follows from Lemma 7 and the definition of the coordinates of the signature vector. ∎
Choosing the “” coordinate of the signature vector to be some value larger than (so that Lemma 8 still holds), we see that each coordinate of the signature vector is at most and the number of coordinates is also at most where . Thus, the sum of the coordinates of the signature vector is always upper bounded by . We now prove that the number of such signature vectors is polynomial in .
A partition of an integer is a way of writing as the sum of positive integers (ignoring the order of the summands). The number of partitions of an integer can be upper bounded by by a result of Hardy and Ramanujan [HR18]^{2}^{2}2The asymptotic formula for the number of partitions of is [HR18].. Using that the coordinates of our signature vectors are nondecreasing, each signature vector corresponds to a partition of an integer of value at most , and vice versa: given a partition of an integer of size , the largest number of the partition will correspond to the th coordinate, the second largest to the th coordinate, and so on. Therefore, we can upper bound the total number of signature vectors by Since each iteration of the algorithm takes only polynomial time along with Lemma 8 this proves Theorem 1.
Before we return to the proof of the key lemma in this section, Lemma 6, let us note an important property of the algorithm which follows from that in the buildphase we add an edge for each cluster as long as it is disjoint from the already added resources.
Fact 9.
Let be a player from some cluster . Notice that if a player is part of some blocking edge in the layer, i.e., , and further there is no edge with then it means that none of the players in have a set of resources of value at least disjoint from the resources .
Proof of Lemma 6.
Notice that since the set is discarded if it is modified or any of the sets , is modified, it is sufficient to verify the inequality when we construct the new layer in the build phase. The proof is now by contradiction. Suppose after the build phase. Let be the clusters that have a player in an edge but no player in an edge in . We have that,
Recall that denotes the set of configurations for player comprising only thin items. By Theorem 5 there exists an that is feasible for such that for each cluster . Now form the bipartite hypergraph where we have vertices for clusters in and thin items in , and edges for every cluster and thin configuration such that and . To each edge in assign the weight . The total weight of edges in is at least Let denote the thin items appearing in the edges of and . Let denote their value. Now remove all these items from the hypergraph to form which has edges for each edge in . The weight of is similarly defined to be
Let us upper bound the total value of thin items appearing in . Consider some layer . The total value of resources in thin edges in is at most by the minimality of the edges. The value of resources in not already present in some edge in is at most also by minimality of the thin edges in . Therefore, is at most
As the sum of the edge weights in is at least , the sum of edge weights in is at least . And by Fact 9, the sum of edge weights in must be strictly smaller than . Thus,
(*) 
Note that appears with a larger negative coefficient (in absolute terms) on the lefthandside than on the righthandside. Therefore, if (* ‣ 3.6) holds then it also holds for an upper bound of . We shall compute such a bound and reach a contradiction.
We start by computing an upper bound on for . The fourth invariant says that except for at most edges in , the remainder have at least value of resources blocked by the edges in . Using this,
Rearranging terms we have,
4 Combinatorial Algorithm
In the previous section, we described a approximation algorithm for restricted maxmin fair allocation; however, this algorithm required us to solve the ConfigurationLP. In this section, we will design and analyze a purely combinatorial approximation algorithm, for any (for reference, note that ). This will prove our main result, Theorem 1.
We start by providing an informal overview of how the combinatorial algorithm works.
4.1 Intuitive Algorithm Description
To begin with, the general framework of our combinatorial algorithm is similar to that of the simpler algorithm we described in Section 3: we guess an optimal value for the ConfigurationLP, and we then try to find an allocation of resources which approximately satisfies every player, i.e., assigns to each player a set of resources of total value at least for that player. To do so, we will again design a local search procedure, whose goal will be to extend a given partial allocation of resources, so as to satisfy one more player.
An example execution of our combinatorial algorithm appears in Figure 3: there, given a partial allocation of resources to players, we want to extend this allocation to satisfy player . Naturally, if there is a set of resources, that do not appear in the given partial allocation, and whose total value for is at least , we will assign these resources to player . Otherwise, we find an edge whose total value for is at least (the bottom gray edge in Figure 3(a)), and consider all the edges in our given partial allocation that share resources with that set (the white edges intersecting in Figure 3(a)); these edges constitute the first layer that is shown in Figure 3(a).
At this point, we should make note of the fact that, similar to the simpler algorithm we described in Section 3, we will again be using a greedy strategy with respect to the edges we wish to include in our partial matching. Specifically, even though we wish to only assign resources of total value at least to each player, the gray edges we attempt to include in our matching are significantly more valuable (i.e., of total value at least ). Again, this will imply that every gray edge will intersect with multiple white/blocking edges, which will eventually help us prove that the algorithm’s running time is polynomial in the size of the input.
Next, similar to the simpler algorithm we described in Section 3, we want to free up the resources that appear in edge . We do this by finding disjoint sets of resources that satisfy the players appearing in the white edges of the first layer. However, here we encounter the first major difference compared to our previous algorithm: some of the players that appear in the white edges of the first layer can be satisfied by using fat resources, i.e., resources whose value for their corresponding players is at least . Since every fat edge we would like to include in our partial allocation can only be blocked by exactly one edge that already belongs to our allocation, alternating paths of fat edges are created. Such a path, that ends in a gray thin edge, is displayed in Figure 3(b); if we wish to include the gray edge that contains into our partial allocation, then we would have to replace the white fat edges with the gray ones.
However, considering such alternating paths of fat edges brings up one issue: since, as is shown in Figure 3(a), the alternating paths that originate at players and end at two distinct gray thin edges, if we were to include both of these edges into our matching, then we would have to guarantee that we will not use the same fat resource to satisfy two different players. In order to do this, we will include the gray edges that contain players and into our partial allocation, only if the alternating paths that end in these players are vertexdisjoint, as is the case in Figure 3(c).
Next, since we have solved the problem of deciding if we can update our partial matching by replacing white edges with gray ones, the question that arises is when should we do that. Similar to our simpler algorithm, we will employ the strategy of lazy updates. In other words, we will be replacing the white edges of some layer with gray ones (or, as we will call this operation, collapse a specific layer), only if that would mean that a significant amount of the white edges gets replaced. Replacing a significant amount of white (i.e., blocking) edges then implies that we make significant progress towards matching player .
Finally, after we update our partial allocation, by inserting the gray edges containing players and , inserting the gray fat edges that belong to the corresponding alternating paths, and removing the white fat edges that belong to the corresponding alternating paths, we have managed to free up a significant amount of resources of edge . Hence, we choose a subset of the resources contained in , whose total value is at least , and include it into our partial allocation. At this point, we have managed to extend our partial allocation to include one more player, namely, player .
4.2 Parameters
Let be a guess on the value of the ConfigurationLP, and fix some . Our algorithm will use the following setting of parameters:
(4.1) 
Similar to our simpler algorithm, is the approximation guarantee, determines the “greediness” of the algorithm, and determines the “laziness” of the updates of our algorithm.
We shall show that whenever is feasible, our algorithm will terminate with a solution of value at least for the given instance of restricted maxmin fair allocation. Combining this with a standard binary search then yields a approximation algorithm.
4.3 Description of the Algorithm
We begin by noting that we will be reusing the definitions of fat and thin edges, edges, and (partial) matchings that we introduced in Section 3.3. However, we remind the reader that the parameters we used in the above definitions have now changed, see (4.1).
The goal of our algorithm will be to find a perfect matching. Similar to our simpler algorithm, the way we do this is by designing an augmenting algorithm, that will extend any given partial matching to satisfy one more player. Thus, starting from an empty matching and iteratively applying the augmenting algorithm will yield a perfect matching that corresponds to a approximate allocation. We remark that for the purposes of our algorithm, any partial matching we consider contains the maximum number of fat resources possible. In order to enforce this condition, we find a maximum matching between fat resources and players; this will be our initial partial matching. Starting from this partial matching, we proceed to iteratively extend it, by matching one more player at a time while never decreasing the number of fat items in our allocation.
We proceed to define the concepts of Disjoint Path Networks and Canonical Decompositions, that are necessary to state our combinatorial algorithm. These concepts will be used to implement the idea of updating our partial matching using vertexdisjoint alternating paths, that we mentioned in Section 4.1. We then state our algorithm formally, and we analyze its running time in the subsequent sections.
Disjoint Path Networks
As we discussed in the overview of our combinatorial algorithm, we need a way to ensure that the alternating paths we use to update our partial matching are disjoint. We say that two paths are disjoint if they are vertexdisjoint. To do so, we employ a structure called Disjoint Path Networks.
Given a partial matching , let be the directed graph defined as follows: there is a vertex for each player in and each fat resource in ; and, there is an arc from a player in to a fat resource if is interested in unless the arc appears in in which case there is an arc . Note that the graph depends only on the assignment of fat resources to players in .
Now, let be a set of sources and sinks respectively that are not necessarily disjoint. Let denote the flow network we get if we place unit capacities on the vertices of , and use and as sources and sinks respectively. Furthermore, let denote the value of an optimal solution, i.e., the maximum number of disjoint paths from the sources to the sinks in the graph .
In our algorithm, and will contain only vertices in corresponding to players in . However, to specify a sink we sometimes abuse notation and specify an edge since the corresponding sink vertex can be deduced from it. For example, if we write , for some set of players and some set of edges , then we mean the maximum number of disjoint paths that start at a player in and end in a player that appears in some edge in .
For basic concepts related to flows, such as flow networks and augmenting paths, we refer the reader to the textbook by Cormen, Leiserson, Rivest and Stein [CLRS09].
State of the Algorithm
The state of the algorithm is described by a dynamic tuple , where is the current partial matching, is a list of layers and is a set of "immediately addable" edges. Each layer consists of a set of "added" edges , a set of "blocking" edges , and a positive integer . We note that is redundant for the formal statement of our algorithm, but will be handy in our analysis.
Canonical Decompositions
We proceed to define the last concept necessary to describe our combinatorial algorithm. Recall that we denote by , for some sequence of sets , and that denotes the players that appear in . Moreover, for a set of edges we use to denote the set of players that appear in an edge in and we use to denote the set of resources that appear in an edge in .
Definition 1 (Canonical Decomposition of ).
Given a state of the algorithm, we call a collection of disjoint subsets of a canonical decomposition if it satisfies the following conditions:

For , .

There exists an optimal solution to such that, for , paths in go from players to the sinks in . We denote these paths by . We also refer to as the canonical solution corresponding to the decomposition.
As we will see in Section 4.4, canonical decompositions and their corresponding canonical solutions can be computed in polynomial time.
Algorithm Statement
The combinatorial algorithm behind the proof of Theorem 1 is stated as Algorithm 2. We remark that the computation of canonical decompositions and solutions to flow networks that are carried out in Steps 3 and 3.b respectively can be carried out in polynomial time; this fact is proved in Section 4.4.

For , is a set of thin edges and each edge has (its resources are not shared with edges from earlier iterations, edges in , or edges in ).

For any edge , it holds that