Abstract 1 Introduction 2 A 𝟐-approximation for normalized functions 3 A 𝟐-approximation for three agents with unnormalized functions 4 A 𝟓𝟑-approximation for three agents with normalized functions 5 Conclusion References

Maximizing Social Welfare Among EF1 Allocations at the Presence of Two Types of Agents

Jiaxuan Ma Hangzhou Dianzi University, China Yong Chen ORCID Hangzhou Dianzi University, China Guangting Chen ORCID Zhejiang University of Water Resources and Electric Power, Hangzhou, China Mingyang Gong ORCID University of Alberta, Edmonton, Canada Guohui Lin ORCID University of Alberta, Edmonton, Canada An Zhang ORCID Hangzhou Dianzi University, China
Abstract

We study the fair allocation of indivisible items to n agents to maximize the utilitarian social welfare, where the fairness criterion is envy-free up to one item and there are only two different utility functions shared by the agents. We present a 2-approximation algorithm when the two utility functions are normalized, improving the previous best ratio of 16n shown for general normalized utility functions; thus this constant ratio approximation algorithm confirms the APX-completeness in this special case previously shown APX-hard. When there are only three agents, i.e., n=3, the previous best ratio is 3 shown for general utility functions, and we present an improved and tight 53-approximation algorithm when the two utility functions are normalized, and a best possible and tight 2-approximation algorithm when the two utility functions are unnormalized.

Keywords and phrases:
Fair allocation, utilitarian social welfare, envy-free up to one item, envy-cycle elimination, round robin, approximation algorithm
Copyright and License:
[Uncaptioned image] © Jiaxuan Ma, Yong Chen, Guangting Chen, Mingyang Gong, Guohui Lin, and An Zhang; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Design and analysis of algorithms
Funding:
Supported by the NSERC Canada, the NNSF of China (Grants 12471301, 12371316), the PNSF of Zhejiang China (Grant LZ25A010001), and the China Scholarship Council (Grant No. 202508330173).
Related Version:
Full Version: https://doi.org/10.48550/arXiv.2509.09641
Editors:
Ho-Lin Chen, Wing-Kai Hon, and Meng-Tsung Tsai

1 Introduction

We study a special case of the fair allocation of indivisible items to a number of agents to maximize their utilitarian social welfare, where the agents fall into two types and the fairness criterion is envy-free up to one item. We present a set of approximation algorithms that each improves the previous best one when reduced to this special case, or is the best possible for this special case.

Throughout this paper, we denote by {a1,a2,,an} the set of n agents and by M={g1,g2,,gm} the set of m indivisible items or goods. An allocation of items is an n-tuple 𝒜=(A1,A2,,An), where Ai is the pair-wise disjoint bundle/subset of items allocated/assigned to ai. The allocation is complete if i=1nAi=M, i.e., every item is allocated, or otherwise it is partial. Each agent ai has a non-negative additive utility (or valuation) function ui:M0. Extending to 2M, for any subset SM, ui(S)=gSui(g). If ui(M)=1 for all i, then the utility functions are said normalized; otherwise, they are unnormalized. The utilitarian social welfare of the allocation 𝒜=(A1,A2,,An) is defined as i=1nui(Ai).

The allocation 𝒜=(A1,A2,,An) is envy-free up to one item (EF1), if for any ij, ui(Ai)ui(Ajg) holds for some item gAj. Between two agents ai and aj, if ui(Ai)ui(Aj), then ai does not envy aj; otherwise, ai envies aj. Similarly, if ui(Ai)ui(Ajg) for some gAj, then ai does not strongly envy aj; otherwise, ai strongly envies aj.

In this paper, we study the optimization problem to find an EF1 allocation with the maximum utilitarian social welfare, denoted as USW-EF1, and we focus on the special case where there are only two types of agents, or equivalently speaking only two distinct utility functions shared by the agents. W.l.o.g., we assume that the first j agents a1,a2,,aj use the utility function u1, referred to as the first type of agents, and the last nj agents aj+1,aj+2,,an use the second utility function un, for some 1j<n. Let 𝒜 be the allocation produced by an approximation algorithm and 𝒜 be an optimal allocation. We denote by SOL=i=1nui(Ai) and OPT=i=1nui(Ai) their objective values, respectively. The algorithm is an α-approximation if the ratio OPT/SOLα for all instances. We remark that this two-types-of-agents special case is important for several reasons, for example, most hardness and inapproximability results are proven for this special case, and this special case also models some real application scenarios such as individual versus business investors and faculty members versus administration staff.

1.1 Related work

Discrete fair division aims to allocate a set of indivisible items to a set of agents so that all the agents feel “fair” with respect to their heterogeneous preferences over the items. Typical fairness criteria include envy-freeness (EF) [12] and proportionality [11]. By an EF allocation, each agent ai does not envy any other agent aj. Since an EF allocation does not always exist, one relaxation of EF is envy-freeness up to one item (EF1) proposed in [9, 7]. Formally speaking, for each pair of agents ai,aj, agent ai does not envy aj after the removal of some item from the bundle allocated to aj. Replacing the quantifier “for some” by “for any” leads to another more restricted relaxation envy-freeness up to any item (EFX) [8].

A complete EF1 allocation can be computed in polynomial time by the envy-cycle elimination (ECE) algorithm proposed by Lipton et al. [9] or by the round-robin (RR) algorithm proposed by Caragiannis et al. [8]. In brief, in the ECE algorithm, an envy digraph is constructed on the agents where agent ai points to agent aj (i.e., the arc (ai,aj) exists) if ai envies aj; whenever there is a cycle in the digraph, the bundles allocated to the agents on the cycle are rotated to eliminate the cycle; afterwards the algorithm assigns an unallocated item to an agent not envied by anyone else, and the iteration goes on. In the RR algorithm, the agents are ordered cyclically and the agent at the head of the order picks its most preferred item from the pool of unassigned items and then lines up at the back of the order, until no item is left.

Besides the existence of EF1 allocations, the price of such fair allocations is an interesting concern in economics and social science. Given that the utilitarian social welfare measures the efficiency of an allocation, the price of EF1 is defined as the ratio between the maximum utilitarian social welfare across all allocations and the maximum utilitarian social welfare among only EF1 allocations. The price of EF1 for normalized utility functions is Θ(n): Barman et al. [4] first showed that the price is at most O(n), and later Bei et al. [5] showed that the price is at least Ω(n). The price of EF1 for unnormalized utility functions is n: Barman et al. [4] showed that the price is Θ(n), and later Bu et al. [6] constructed an instance to show that it is at least n.

For the optimization problem USW-EF1, Barman et al. [4] proved that it is already NP-hard for two agents even when the valuation function of an agent is a scaled version of that of the other, and it is NP-hard to approximate within a factor of m1ϵ for any ϵ>0 for n agents and m items when both n and m are part of the input. When the utility functions are normalized, the problem remains NP-hard for n agents when n2 is a fixed integer [3, 6]. Moreover, Bu et al. [6] showed several hardness results when n3 that, firstly the problem is NP-hard to approximate within the factor 4n3n+1 for normalized functions when one agent uses a utility function and the other agents use a common second utility function; secondly it is NP-hard to approximate within the factor 1+4n32 for unnormalized functions when one agent uses a utility function, two other agents use a common second utility function, and all the other agents (if any) use a common third utility function; and thirdly it is NP-hard to approximate within the factor m12ϵ or within the factor n13ϵ, for any ϵ>0, for normalized utility functions when both n and m are part of the input.

On the positive side, Barman et al. [4] presented a 16n-approximation algorithm when n is a fixed integer and the utility functions are normalized. Aziz et al. [3] proposed a pseudo-polynomial time exact algorithm for the same variant. Bu et al. [6] gave a fully polynomial-time approximation scheme (FPTAS) for two agents and an n-approximation algorithm for n3 agents with unnormalized utility functions.

We remark that we reviewed in the above only those directly related work, but not the entire body of the literature on fair division of indivisible goods. For example, the Nash social welfare (NSW) objective, the geometric mean of the agents’ utilities, has been extensively studied, and it is known that an allocation which maximizes NSW is EF1 [8] though approximate solutions are not necessarily EF1. One may refer to [2, 1] for an excellent survey on recent progress and open questions.

1.2 Our contribution and organization of the paper

In this paper, we aim to design approximation algorithms for the special case of USW-EF1 where there are only two distinct utility functions shared by the agents, i.e., there are two types of agents. Note that when all agents share the same utility function, a complete EF1 allocation returned by the ECE or RR algorithm is optimal. Also, given that the above two lower bounds on the approximation ratios [6] are proven for two or three utility functions, our study on the special case may shed lights on the general case. In particular, we demonstrate the use of the item preference order in all our three approximation algorithms.

We first present in the next section a 2-approximation algorithm for any number of agents with normalized utility functions. Then, in Section 3, we present a tight 2-approximation algorithm for three agents with unnormalized utility functions, which is the best possible by the lower bound 1+4n32 [6]. Section 4 contains an improved and tight 53-approximation algorithm for three agents with normalized utility functions. Due to page limit, we leave the third case for three agents with unnormalized utility functions to the full arXiv version [10]. We conclude our paper in Section 5.

In all our three algorithms, the items are firstly sorted, and thus we assume w.l.o.g. that they are given, in the non-increasing order of their preferences, where the preference of an item g is defined as u1(g)/un(g) (Definition 1) that measures the extent of preference of the first type of agents over the second type of agents. Intuitively, in an efficient allocation, items at the front of this order should be allocated to the first type of agents, while items at the back should be allocated to the second type of agents. This is exactly the main design idea.

2 A 𝟐-approximation for normalized functions

Recall that agents a1,,aj share the first utility function u1() and agents aj+1,,an share the second utility function un(). For each item gM, we assume w.l.o.g. that its two values u1(g),un(g) are not both 0.

Definition 1.

The preference of item g is defined as ρ(g)=u1(g)/un(g), where if un(g)=0 then ρ(g)=.

Extending to a non-empty set of items SM, the preference of S is defined as ρ(S)=u1(S)/un(S), where if un(S)=0 then ρ(S)=.

Specially, the preference of an empty set is ±, indicating that it is less than but also greater than any real value.

We assume w.l.o.g. that ρ(g1)ρ(g2)ρ(gm), i.e., the items are given in the non-decreasing preference order. Our algorithm, denoted as Approx1, uses two variables k1 and k2 to store the smallest and the largest indices of the unassigned items, which are initialized to 1 and m, respectively. In each iteration, the algorithm finds the agent as (at, resp.) having the minimum utility among the first (second, resp.) type of agents. (Comment: These two agents as and at will be proven not to envy each other.) If as is not envied by at, then as takes the item gk1 and k1 is incremented by 1; otherwise, at is not envied by as, at takes gk2 and k2 is decremented by 1. The algorithm terminates when all items are assigned (i.e., k1>k2), of which a high-level description is depicted in Algorithm 1.

Algorithm 1 Approx1 for normalized utility functions.

Input: n3 agents of two types and a set of m indivisible items ρ(g1)ρ(g2)ρ(gm).

Output: A complete EF1 allocation.

We next prove that inside each iteration, the found two agents as and at do not envy each other, and thus Approx1 produces a complete EF1 allocation. To this purpose, we introduce the following definition.

Definition 2.

For two item sets A,BM, if mingABρ(g)maxgBAρ(g), then we say A precedes B and denote it as AB. That is, excluding the common items, every item of A (if any) comes before any item of B (if any) in the item preference order.

An allocation 𝒜 is good if AsAt for every pair (s,t) with sj<t. (Comment: Since AsAt=, this implies ρ(As)ρ(At).)

Recall that ρ()=±, if As= then both AsAt and AtAs hold.

Lemma 3.

Given a good allocation 𝒜, two agents of different types do not mutually envy each other.

Proof.

Assume to the contrary that for a pair (s,t) with sj<t, as and at envy each other, that is, u1(As)<u1(At) and un(At)<un(As). It follows that none of As and At is and ρ(As)=u1(As)/un(As)<u1(At)/un(At)=ρ(At), which contradicts the definition of a good allocation.

Note that there are exactly m iterations inside the algorithm Approx1, and we let 𝒜0=(,,) and let 𝒜i=(A1i,,Ani) denote the allocation at the end of the i-th iteration. The final produced allocation is 𝒜=𝒜m.

Lemma 4.

The allocation 𝒜i is good and EF1, for each i=0,1,,m.

Proof.

We prove by induction.

The initial empty allocation 𝒜0 is clearly good and EF1. Assume 𝒜i is good and EF1 for some i<m, and let as and at be the agents found in the (i+1)-st iteration.

Consider the case where as is not envied by at (the other case is symmetric), in which the algorithm updates As to As{gk1}. By the description of Approx1, As{gk1} is a non-empty subset of {g1,,gk1} and Ai{gk2+1,,gm} for every ij+1. By Definitions 1 and 2 and k1k2, As{gk1}Ai for every ij+1, and thus 𝒜i+1 is good.

Since at the beginning of the iteration as is not envied by at, un(At)un(As). Also, by the definition of s and t, u1(Ai)u1(As) for every ij and un(Ai)un(At)un(As) for every ij+1. That is, no agent envies as in the allocation 𝒜i, and thus does not strongly envy as in the allocation 𝒜i+1 (by removing the item gk1). Note that in this iteration only as gets an item. Therefore, 𝒜i+1 is EF1 as 𝒜i is EF1.

Theorem 5.

Approx1 is a 2-approximation algorithm.

Proof.

For the optimal allocation 𝒜, we have

OPT=i=1nui(Ai)=u1(i=1jAi)+un(i=j+1nAi)u1(M)+un(M)=2.

Note from Lemma 4 that the final allocation 𝒜 produced by Approx1 is complete, good and EF1. By Definition 2, we have ρ(i=1jAi)ρ(i=j+1nAi). Therefore, either ρ(i=1jAi)1 or ρ(i=j+1nAi)<1; or equivalently, either u1(i=1jAi)un(i=1jAi) or u1(i=j+1nAi)<un(i=j+1nAi). In the first case, we have

SOL=i=1nui(Ai)=u1(i=1jAi)+un(i=j+1nAi)=u1(i=1jAi)un(i=1jAi)+un(M)1.

In the second case, we have

SOL=u1(i=1jAi)+un(i=j+1nAi)=u1(M)u1(i=j+1nAi)+un(i=j+1nAi)>1.

Therefore, SOL12OPT always holds.

3 A 𝟐-approximation for three agents with unnormalized functions

We continue to assume w.l.o.g. that the items are given in their preference order, that is, ρ(g1)ρ(g2)ρ(gm), and use the definitions of precedence and good allocation in Definition 2. Since there are only three agents categorized into two types, we assume w.l.o.g. that j=1, i.e., agent a1 is of the first type and agents a2 and a3 are of the second type.

For ease of presentation we partition the items into two sets based on their preference:

X={gM:u1(g)u3(g)},Y={gM:u1(g)<u3(g)}. (1)

We first examine the structure of a fixed optimal EF1 allocation, denoted as (A1,A2,A3). Denote the item g=argmaxgA1u3(g), i.e., the most valuable to a2 and a3 among those items allocated to a1. The following lemma establishes an important upper bound on u3(A1g).

Lemma 6.

u3(A1g)13u3(Mg).

Proof.

Suppose to the contrary that u3(A1g)>13u3(Mg). Then we have

u3(A2A3)=u3(M)u3(A1)=u3(Mg)u3(A1g)<2u3(A1g).

It follows that at least one of u3(A2) and u3(A3) is less than u3(A1g). W.l.o.g., we assume u3(A2)<u3(A1g), and thus by the definition of g agent a2 strongly envies a1, a contradiction to EF1.

We next present an upper bound on the optimal total utility OPT. To this purpose, we define what a critical set is below. We remark that although the definition relies on the fixed optimal EF1 allocation 𝒜, we can actually compute a critical set for any item, by the procedure Algo2 presented in Subsection 3.1.

Definition 7.

An item set K is critical for an item g if the following three conditions are satisfied:

  1. 1.

    gK and KgX;

  2. 2.

    Kg A1g;

  3. 3.

    u3(Kg)min{u3(Xg),13u3(Mg)}.

Lemma 8.

For any critical set K for g, we have OPTu1(K)+u3(MK).

Proof.

We partition the items of A1g into two sets according to Eq. (1):

B1=(A1g)X,B2=(A1g)Y.

One sees from B2Y that u1(B2)u3(B2). Since KgA1g and B1A1g, KgB1 too. Let C=(Kg)B1; then ρ(K{gC})ρ(B1C). Since KgX, ρ(Kg)1. In summary, we have

ρ(K{gC})max{ρ(B1C),1}.

By the third condition in Definition 7 and Lemma 6, we have

u3(K{gC}) min{u3(Xg),13u3(Mg)}u3(C)
min{u3(Xg),u3(A1g)}u3(C)
u3(B1C).

The above inequalities together give rise to

u1(A1g)u3(A1g) u1(B1)u3(B1) (2)
= u1(C)u3(C)+u1(B1C)u3(B1C)
= u1(C)u3(C)+u3(B1C)(ρ(B1C)1)
u1(C)u3(C)+u3(K{gC})(ρ(K{gC})1)
= u1(Kg)u3(Kg).

It follows from the above Eq. (2) that

OPT = u1(g)+u1(A1g)+u3(A2A3)
u1(g)+u3(A1g)+u1(Kg)u3(Kg)+u3(A2A3)
= u1(K)+u3(MK).

This proves the lemma.

The next lemma states an important property for any allocation in which agent a1 is envied, by the fact that a2 and a3 share the same utility function u3.

Lemma 9.

Suppose 𝒜 is an allocation in which agent a1 is envied. If a2 (a3, resp.) is not envied by a3 (a2, resp.), then a2 envies a1, i.e., u3(A2)<u3(A1) (a3 envies a1, i.e., u3(A3)<u3(A1), resp.).

Proof.

We prove the lemma for a2 (for a3 it is symmetric), that is, agent a2 is not envied by a3, but a1 is envied by at least one of a2 and a3.

If a2 does not envy a1, then a3 envies a1, i.e., u3(A2)u3(A1)>u3(A3), a contradiction to a2 not envied by a3.

3.1 Producing a critical set for every item

Recall that the items are given in the preference order ρ(g1)ρ(g2)ρ(gm); and we see from Eq. (1) that XY. For any ordered item set, if the order inherits the given preference order, then it is regular.

Note from Lemma 8 that a critical set for the item g plays an important role, but we have no knowledge of A1 or g. Below we construct a critical set for every item giM, in the procedure Algo2 depicted in Algorithm 2. The key idea is, excluding gi, the critical set matches a prefix of the item preference order.

Algorithm 2 Algo2 for computing a critical set.

Input: The item preference order S=g1,,gm and an item giM.

Output: A critical set K for gi.

Lemma 10.

Algo2 produces a critical set K for the item gi.

Proof.

Consider the index t in Line 1 of the procedure Algo2. Clearly, t|X|. If t<i, then giK and Kgi={g1,,gt}. Therefore, KgiX and KgiA1gi. Lastly, u3(Kgi)=j=1tu3(gj)min{u3(Xgi),13u3(Mgi)}. All the three conditions in Definition 7 are satisfied and thus K is a critical set for gi.

If ti, then t in Line 5 exists and |X|tti. Therefore, giK, KX and KgiA1gi. Lastly, u3(Kgi)=j=1tu3(gj)u3(gi)min{u3(Xgi),13u3(Mgi)}. All the three conditions in Definition 7 are satisfied and thus K is a critical set for gi.

Given that the procedure Algo2 is able to produce a critical set for any item, by enumerating the items we will have a critical set K for the item g, and thus by Lemma 8 to bound the OPT. From K, we will also design algorithms to return a complete EF1 allocation of total utility at least half of this bound and thus at least 12OPT.

In the next three subsections, we deal with the critical set K produced by Algo2 for an item gi, separately for three possible cases. Let k=|K|. When maxgKu1(g)<12u1(K), K contains at least three items, i.e., k3; if the index of the item gi is ik, then we modify the item order S by moving the item gi to the (k1)-st position, and denote the new order as S=g1,,gm. Note that the net effect is, if ik, then the items gk1,,gi1 are moved one position forward to become gk,,gi; otherwise S is identical to S. In either case, Sgk1 is regular and K contains the first k items in the order S, summarized in Remark 11.

The three distinguished cases are (due to space limit, Case 3 is dealt with in detail in the full arXiv version [10]):

  1. 1.

    maxgKu1(g)12u1(K);

  2. 2.

    maxgKu1(g)<12u1(K) and u3(gk)>u3(MK);

  3. 3.

    maxgKu1(g)<12u1(K) and u3(gk)u3(MK).

 Remark 11.

In Cases 2 and 3, i.e., maxgKu1(g)<12u1(K) and thus k=|K|3, for the new item order S, gkgi, Sgk1 is regular, K={g1,g2,,gk}, and j=1k1u3(gj)<13u3(Mgi)+u3(gi).

Proof.

We only need to prove the last inequality j=1k1u3(gj)<13u3(Mgi)+u3(gi).

If K is outputted in Line 3 of the algorithm Algo2, then k=t+1 and j=1k1u3(gj)=j=1t1u3(gj)+u3(gi)<13u3(Mgi)+u3(gi), i.e., the inequality holds. If K is outputted in Line 6 of the algorithm Algo2 and i<t=k, then j=1k1u3(gj)=j=1t1u3(gj)<13u3(Mgi)+u3(gi), i.e., the inequality holds. If K is outputted in Line 6 of the algorithm Algo2 and i=t=t=k, then j=1k1u3(gj)j=1t1u3(gj)+u3(gi)<13u3(Mgi)+u3(gi), i.e., the inequality holds. This proves the last inequality.

3.2 Case 1: 𝐦𝐚𝐱𝒈𝑲𝒖𝟏(𝒈)𝟏𝟐𝒖𝟏(𝑲)

Recall that K is the critical set for the item gi produced by the procedure Algo2. This case where maxgKu1(g)12u1(K) is considered easy, and we present an algorithm Approx3 to produce a complete EF1 allocation.

The algorithm starts with the allocation 𝒜=({g},,), where the item g is one such that u1(g)12u1(K). 𝒜 is trivially EF1 and u1(A1)12u1(K). In fact, 𝒜 is well-defined with permutation (1,2,3), formally defined below.

Definition 12.

An allocation 𝒜 is well-defined with permutation (i1,i2,i3) if

  1. 1.

    𝒜 is EF1;

  2. 2.

    u1(A1)12u1(K) and u3(A1)u3(K);

  3. 3.

    (i1,i2,i3){(1,2,3),(3,1,2)} such that agent ai1 does not envy ai2 or ai3, and ai2 does not envy ai3.

Given the well-defined allocation 𝒜=({g},,) with permutation (1,2,3), let U=M(A1A2A3) be the unassigned item set. The algorithm Approx3 fixes the agent order a3,a2,a1 to apply the Round-Robin (RR) algorithm to distribute the items of U. A high-level description of the algorithm is depicted in Algorithm 3, which accepts a general well-defined allocation.

Algorithm 3 Approx3 for a complete EF1 allocation.

Input: A well-defined allocation 𝒜=(A1,A2,A3) with permutation (i1,i2,i3).

Output: A complete EF1 allocation.

Lemma 13.

Given a well-defined allocation 𝒜=(A1,A2,A3) with permutation (i1,i2,i3), Approx3 produces a complete EF1 allocation with total utility at least 12u1(K)+12u3(MK).

Proof.

Note from the RR algorithm that the returned allocation (A1U1,A2U2,A3U3) is complete.

The initial allocation 𝒜=(A1,A2,A3) is EF1 by Definition 12. Consider any two agents as and at, where s precedes t in the permutation (i1,i2,i3). That is, as does not envy at, and thus us(As)us(At). Since the RR algorithm uses the agent order ai3,ai2,ai1, we have us(Us)us(Ut)us(g), where g is the first item picked by agent at; and thus us(AsUs)us(AtUt)us(g) for the same gUt. That is, as does not strongly envy at. Similarly, since 𝒜 is EF1, ut(At)ut(As)ut(g) for some gAs; we have ut(Ut)ut(Us) by the RR algorithm. Thus ut(AtUt)ut(AsUs)ut(g) for the same gAs, that is, at does not strongly envy as. Therefore, the returned allocation is EF1.

We estimate the total utility of the returned allocation as follows. Since the agent index 1 precedes 2 in the permutation (i1,i2,i3){(1,2,3),(3,1,2)}, we have u3(U2)u3(U1) from the RR algorithm; we also have u1(A1)12u1(K) and u3(A1)u3(K) from Definition 12 of well-defined allocation, the total utility of the returned allocation is u1(A1U1)+u3(A2A3U2U3), which is at least

12u1(K)+12u3(MA1)=12u1(K)+12u3(M)12u3(A1)12u1(K)+12u3(MK).

This proves the lemma.

Theorem 14.

Let K be the critical set of the item g produced by the procedure Algo2. If maxgKu1(g)12u1(K), then Approx3 returns a complete EF1 allocation with its total utility at least 12OPT.

Proof.

For this set K, the allocation 𝒜=({g},,) is well-defined with the permutation (1,2,3), where g=argmaxgKu1(g). The theorem follows from Lemmas 13 and 8.

3.3 Case 2: 𝐦𝐚𝐱𝒈𝑲𝒖𝟏(𝒈)<𝟏𝟐𝒖𝟏(𝑲) and 𝒖𝟑(𝒈𝒌)>𝒖𝟑(𝑴𝑲)

Recall that K is the critical set of an item gi produced by the procedure Algo2. In this case, k=|K|3 and we work with the new item order S such that Sgk1 is regular, and gkgi. Adding the last inequality j=1k1u3(gj)<13u3(Mgi)+u3(gi) from Remark 11 and u3(gk)>u3(MK) together gives

u3(gk)>13u3(Mgi)u3(K{gk,gi}), and thus u3(gk)>12u3(Kgi). (3)

One sees from the above three lower bounds on u3(gk) that the item gk is very valuable to agents a2 and a3. We design another algorithm called Approx7 for this case to construct a complete EF1 allocation, in which gk is the only item assigned to a3.

Inside the algorithm Approx7, the first procedure Algo4 produces a partial EF1 and good allocation. It starts with the allocation 𝒜=({g1},,{gk}), which is EF1 and good (see Definition 2), and uses the order S to allocate the items in the two sets K{g1gk} and MK to the agents a1 and a2, respectively, till exactly one of them becomes empty. A detailed description of the procedure is depicted in Algorithm 4.

Algorithm 4 Algo4 for a partial EF1 and good allocation.

Input: The critical set K for item gi satisfying maxgKu1(g)<12u1(K), the new item order S in which gkgi, and u3(gk)>u3(MK).

Output: A partial EF1 allocation 𝒜.

Lemma 15.

Given the critical set K for item gi produced by the procedure Algo2 satisfying maxgKu1(g)<12u1(K), k=|K|, the new item order S in which gkgi, and u3(gk)>u3(MK), Algo4 produces a partial EF1 and good allocation.

Proof.

Note from the description that when Algo4 terminates, either k1=k<k2 or k1<k=k2, i.e., at least one item remains unassigned, and thus the returned allocation 𝒜 is incomplete.

We remark that since the procedure starts with the allocation ({g1},,{gk}), and allocates the items in the two sets K{g1gk} and MK to the agents a1 and a2, respectively, the bundle A1A2 and A1A3 throughout the procedure, and thus the allocation maintains good (see Definition 2). Also throughout the procedure, since A3={gk} contains a single item, no one strongly envies a3; since u3(gk)>u3(MK) and Eq. (3), agent a3 does not strongly envy any of a1 or a2.

We show next that throughout the procedure, between a1 and a2, no one strongly envies the other, and thus the final allocation is EF1. This is true for the starting allocation ({g1},,{gk}). Assume this is true for the allocation at the beginning of an iteration of the while-loop; since the allocation is good, by Lemma 3 a1 and a2 do not envy each other. If a1 is not envied by a2, then the item gk1Kgk is assigned to a1, and thus a2 does not strongly envy a1 due to gk1 at the end of the iteration; a1 remains not strongly envy a2, also due to gk1 at the end of the iteration. If a2 is not envied by a1, then the item gk2MK is assigned to a2, and thus a1 does not strongly envy a2 due to gk2 at the end of the iteration; a2 remains not strongly envy a1, also due to gk2 at the end of the iteration.

If the procedure Algo4 terminates at k1<k=k2, then the returned allocation is 𝒜=({g1,,gk11},MK,{gk}) and the unassigned item set is U={gk1,,gk1}. The next procedure Algo5 continues on to assign the items of U to produce a complete EF1 allocation, by re-setting k2=k1. A detailed description of Algo5 is depicted in Algorithm 5. Basically, if at least one of a1 and a2 is not envied by any of the other two agents, then the procedure allocates an unassigned item to such a non-envied agent; otherwise, both a1 and a2 are envied by some agent and the procedure allocates all the remaining unassigned items to a1. That is, either gk1 is assigned to a1, or gk2 is assigned to a2, or all of the items of U={gk1,,gk2} are assigned to a1, respectively. One sees that the allocation 𝒜 remains good before the last item is assigned (in fact, the allocation loses being good only if the last item is gk1=gi and it is assigned to a1) in the procedure Algo5, and consequently a1 and a2 do not envy each other by Lemma 3 before the last item is assigned.

Algorithm 5 Algo5 for a complete EF1 allocation.

Input: The critical set K for item gi satisfying maxgKu1(g)<12u1(K), the new item order S in which gk1=gi, and u3(gk)>u3(MK); the EF1 and good allocation 𝒜=({g1,,gk11},MK,{gk}) returned by Algo4, where k1<k.

Output: A complete EF1 allocation 𝒜.

Lemma 16.

Algo5 produces a complete EF1 allocation.

Proof.

Since there will not be any unassigned item at the end of the procedure, the returned allocation is complete. We remind the readers that during the execution of Algo5, the allocation 𝒜 remains good before the last item is assigned.

The starting allocation 𝒜=({g1,,gk11},MK,{gk}), which is returned by Algo4, is EF1 and good. At the beginning of an iteration of the while-loop, if a1 is not envied by any other agent (the case where a2 is not envied by any other agent is symmetric), then after gk1 is allocated to a1 no agent will strongly envy a1. That is, the updated allocation is EF1 too.

Consider the last case of the while-loop, i.e., at the beginning of the last iteration 𝒜=(A1,A2,{gk}) is the EF1 and good allocation in which both a1 and a2 are envied by some agent.

We claim that a3 envies a2. If not, i.e., u3(gk)u3(A2), then a2 is envied by a1, and thus by Lemma 3, a2 does not envy a1, i.e., u3(A2)u3(A1). It follows that a3 does not envy a1. That is, a1 is not envied by any agent, a contradiction.

In the final allocation 𝒜=(A1U,A2,{gk}), a1 does not strongly envy any of a2 or a3 for sure, and none of a2 and a3 strongly envies the other. From Eq. (3) a3 does not strongly envy a1. Since a3 envies a2, a2 does not strongly envy a1 either.

In summary, no agent strongly envies another agent in the final allocation 𝒜.

The allocation returned by the procedure Algo5 is complete and EF1. The next procedure Algo6 takes in a complete EF1 allocation 𝒜=(A1,A2,A3), and if in which agent a1 envies a2, i.e., u1(A1)<u1(A2), then outputs the allocation between 𝒜 and (A2,A1,A3) with a larger total utility. In general, for a complete EF1 allocation 𝒜=(A1,A2,A3), the allocation (A2,A1,A3) after bundle swapping might not be EF1. We nevertheless show in the next lemma that the allocation returned by the procedure Algo6 is EF1.

Algorithm 6 Algo6 for a larger total utility.

Input: The complete EF1 allocation 𝒜=(A1,A2,A3) returned by Algo5.

Output: A complete EF1 allocation.

Lemma 17.

Algo6 produces a complete EF1 allocation.

Proof.

Note that 𝒜=(A2,A1,{gk}) can be returned only if u1(A1)<u1(A2). We show that in such a case, none of a1 and a2 strongly envies the other in (A2,A1,{gk}) (noting that a3 does not strongly envy a1 or a2, the same as in 𝒜, and none of a1 and a2 strongly envies a3 who is allocated with the single item gk). Because u1(A2)>u1(A1), a1 does not envy a2 in the allocation (A2,A1,{gk}).

Let g be the last item allocated to A2, done either by Algo4 or by Algo5. If this is done by Algo4, then (g is gk+1 and) by Lines 6–7 in the description at that moment a2 envies a1, and thus u3(A2g)<u3({g1,,gk11}u3(A1). If g is allocated by Algo5, then by Lines 5–6 in the description at that moment a1 is envied by some agent and a2 is not envied by any agent, and thus by Lemma 9 u3(A2g)<u3({g1,,gk11}u3(A1). Therefore, we always have u3(A1)>u3(A2g), i.e., a2 does not strongly envy a1 in the allocation (A2,A1,{gk}). This proves the lemma.

The algorithm, denoted as Approx7, for producing a complete EF1 allocation for Case 2, is depicted in Algorithm 7, which utilizes the three procedures introduced in the above. When Algo4 terminates at k1=k<k2, the returned partial allocation is 𝒜=(Kgk,A2,{gk}) where A2MK, which is completed by calling the Envy Cycle Elimination (ECE) algorithm to assign the rest of the items, i.e., gk+1,,gk2.

Algorithm 7 Approx7 for a complete EF1 allocation.

Input: The critical set K for item gi satisfying maxgKu1(g)<12u1(K), the new item order S in which gkgi, and u3(gk)>u3(MK).

Output: A complete EF1 allocation.

Lemma 18.

Approx7 produces a complete EF1 allocation.

Proof.

If the procedure Algo4 terminates at k1=k<k2, then since the returned partial allocation is EF1 by Lemma 15, the ECE algorithm continues from there to produce a complete EF1 allocation [9].

If the procedure Algo4 terminates at k1<k=k2, then the final allocation is returned by Algo6 and by Lemma 17 is complete and EF1.

Theorem 19.

Given the critical set K for the item g produced by the procedure Algo2 satisfying maxgKu1(g)<12u1(K), k=|K|, the new item order S in which gkg, and u3(gk)>u3(MK), Approx7 constructs a complete EF1 allocation with its total utility at least 12OPT.

Proof.

By Lemma 18 the final allocation is complete and EF1.

If the procedure Algo4 terminates at k1=k<k2, then SOLu1(Kgk)+u3(gk). Since u1(gk)<12u1(K) and u3(gk)>u3(MK), the total utility is greater than 12u1(K)+u3(MK)12OPT where the last inequality holds by Lemma 8.

If the procedure Algo4 terminates at k1<k=k2, then let 𝒜=(A1,A2,{gk}) denote the allocation returned by the procedure Algo5, in which A1Kgk and A2Mgk. We distinguish to whom gk1 is allocated.

If gk1A1, then A1=Kgk, and the above argument for the first termination condition applies too, so that SOL>12OPT, by noting that the procedure Algo6 never reduces the total utility.

If gk1A2, then (MK){gk1,gk}A2A3. By j=1k1u3(gj)<13u3(Mg)+u3(g) from Remark 11, u3(A2)+u3(A3)>23u3(Mg). When u1(A1)<u1(A2), the procedure Algo6 outputs 𝒜 or (A2,A1,A3) with a larger total utility, which is

SOL12u1(A1A2)+12u3(A1A2)+u3(A3)12u1(Mgk)+12u3(M).

When u1(A1)u1(A2), 𝒜 is the final allocation with its total utility

SOL12u1(A1A2)+u3(A2)+u3(A3)>12u1(Mgk)+23u3(Mg).

Noting from gkg, u3(gk)>13u3(Mg) in Eq. (3), and u3(A1g)13u3(Mg) in Lemma 6, we have gkA1. Therefore, u1(A1)u1(Mgk) and then since gA1,

SOL12u1(Mgk)+min{12u3(M),23u3(Mg)}12u1(A1)+12u3(A2A3)=12OPT.

This proves the theorem.

3.4 Case 3: 𝐦𝐚𝐱𝒈𝑲𝒖𝟏(𝒈)<𝟏𝟐𝒖𝟏(𝑲) and 𝒖𝟑(𝒈𝒌)𝒖𝟑(𝑴𝑲)

Recall that K is the critical set of item gi produced by the procedure Algo2. The same as in Case 2, here we also have k=|K|3 and we work with the new item order S such that K={g1,,gk}, Sgk1 is regular, and gkgi. Note the difference from Case 2 that, here we have u3(gk)u3(MK). We design an algorithm denoted Approx9 for this case to construct a complete EF1 allocation, summarized in the following. Due to space limit, the complete design and analysis for Case 3 is in the full arXiv version [10].

Theorem 20.

Given the critical set K for the item g produced by the procedure Algo2 satisfying maxgKu1(g)<12u1(K), k=|K|, the new item order S in which gkg, and u3(gk)u3(MK), Approx9 constructs a complete EF1 allocation with its total utility at least 12OPT.

3.5 An instance to show the tightness of ratio 𝟐

We provide an instance below to show that the approximation ratio 2 of the combination of the three algorithms, Approx3, Approx7 and Approx9, for the case of three agents with two unnormalized utility functions is tight. In this instance there are only five items in the order ρ(g1)>ρ(g2)>ρ(g3)>1>ρ(g4)=ρ(g5), with their values to the three agents listed as follows, where ϵ>0 is a small value:

g1 g2 g3 g4 g5
a1 ϵ 1 1 0 0
a2,a3 0 ϵ 2ϵ ϵ ϵ

We continue to use the same notations introduced in Section 3. One sees that X={g1,g2,g3}, and thus 𝒜=({g1,g2,g3},{g4},{g5}) is an optimal EF1 allocation of total utility 2+3ϵ.

For each of g1 and g2, u3(Xgi)>13u3(Mgi)43ϵ; the critical set produced by Algo2 is K={g1,g2,g3}. One can verify that maxgKu1(g)<12u1(K), and the new item order is the same as the original preference order. Since u3(g3)=u3(MK), it falls into Case 3. In this case, Algo8 starts with the allocation ({g1},{g3},): In the first iteration, a1 is not envied by a2 or a3, the allocation is updated to ({g1,g2},{g3},) and the procedure terminates with k1>k2. Since ({g1,g2},{g3},) is well-defined with permutation (1,2,3), Approx3 calls the RR algorithm that assigns g4 and g5 one to each of a3 and a2, achieving the final allocation either ({g1,g2},{g3,g5},{g4}) or ({g1,g2},{g3,g4},{g5}) of total utility 1+5ϵ.

For g3, u3(Xg3)=13u3(Mg3)=ϵ; the critical set produced by Algo2 is also K={g1,g2,g3}, and the new item order is S=g1,g3,g2,g4,g5. Since u3(g2)<u3(MK), it falls into Case 3 too. In this case, Algo8 starts with the allocation ({g1},{g2},): In the first iteration, a1 is not envied by a2 or a3, the allocation is updated to ({g1,g3},{g2},) and the procedure terminates with k1>k2. Since ({g1,g3},{g2},) is well-defined with permutation (1,2,3), Approx3 calls the RR algorithm that assigns g4 and g5 one to each of a3 and a2, achieving the final allocation either ({g1,g3},{g2,g5},{g4}) or ({g1,g3},{g2,g4},{g5}) of total utility 1+4ϵ.

For g4 (g5 can be identically discussed), u3(Xg4)=3ϵ>13u3(Mg4)=43ϵ; the critical set produced by Algo2 is K={g1,g2,g3,g4}, and the new item order is S=g1,g2,g4,g3,g5. Since u3(g3)>u3(MK), it falls into Case 2. In this case, Algo4 starts with the allocation ({g1},,{g3}): In the first iteration, a1 is not envied by a2, the allocation is updated to ({g1,g2},,{g3}); in the second iteration, a1 is envied by a2, the allocation is updated to ({g1,g2},{g5},{g3}), and the procedure terminates with k1<k=k2. Since in ({g1,g2},{g5},{g3}) a1 is not envied, Algo5 assigned g4 to a1, achieving the complete allocation ({g1,g2,g4},{g5},{g3}). Lastly, Algo6 confirms the final allocation is ({g1,g2,g4},{g5},{g3}), of total utility 1+4ϵ.

Therefore, we have SOLmax{1+4ϵ,1+5ϵ}=1+5ϵ. It follows that OPT/SOL(2+3ϵ)/(1+5ϵ)=27ϵ/(1+5ϵ)2, when ϵ tends to 0.

4 A 𝟓𝟑-approximation for three agents with normalized functions

Recall that the algorithm Approx1 is a 2-approximation for n agents with normalized functions. In this section, we consider the special case where n=3, and again assume w.l.o.g. that agent a1 uses the utility function u1() and a2 and a3 use u3(). We continue to assume the items are given in the preference order ρ(g1)ρ(g2)ρ(gm).

We also continue to use some notations and definitions introduced earlier, such as the sets X={gM:u1(g)u3(g)} and Y=MX defined in Eq. (1), a good allocation defined in Definition 2, and so on. Additionally, for any subset AM, we define the quantity

Δ(A)=u1(A)u3(A). (4)

Since now u1(M)=u3(M)=1, we have Δ(X)+Δ(Y)=0 and

OPTu1(X)+u3(Y)=u1(X)u3(X)+u3(M)=Δ(X)+1=1Δ(Y). (5)

In the rest of the section we distinguish two cases on maxgXu1(g), the most value of a single item in X to agent a1, and we design two different, but similar, algorithms, respectively.

4.1 Case 1: 𝐦𝐚𝐱𝒈𝑿𝒖𝟏(𝒈)𝟏𝟑

The design idea of our algorithm Approx10 is similar to Approx1, with a change that, after all the items of X have been allocated, i.e., both to-be-allocated items gk1 and gk2 are in Y, agent at has the priority to receive gk2 if it is not envied by a1. The detailed description of the algorithm Approx10 is presented in Algorithm 8.

Algorithm 8 Approx10 for three agents with normalized utility functions.

Input: Three agents of two types and a set of m indivisible items ρ(g1)ρ(g2)ρ(gm), where maxgXu1(g)13.

Output: A complete EF1 allocation.

Lemma 21.

Approx10 produces a good, complete and EF1 allocation.

Proof.

The returned allocation by Approx10 is clearly complete from the while-loop termination condition. We prove that at the end of each iteration of the while-loop in the algorithm, the updated allocation is good and EF1, similar to Lemma 4. Note that the initial empty allocation is trivially good and EF1.

Assume that at the beginning of the iteration the allocation denoted as 𝒜=(A1,A2,A3) is good and EF1; note that the to-be-allocated items are gk1 and gk2 with k1k2.

Consider the case where k1>|X| and at is not envied by a1 (we intentionally pick this case to prove, the other three cases are symmetric), in which the algorithm updates A1 to At{gk2}. By the description of Approx10, A1={g1,,gk11} and Ai{gk2+1,,gm} for i=2,3. By Definitions 1 and 2 and k1k2, A1Ai{gk2} for i=2,3, and thus the updated allocation is good.

Since at the beginning of the iteration at is not envied by a1, u1(A1)u3(At). Also, by the definition of t, u3(Ai)u3(At) for the third agent ai. That is, no agent envies at in the allocation 𝒜, and thus does not strongly envy at in the updated allocation (by removing the item gk2, if necessary). Note that in this iteration only at gets the item gk2. Therefore, the updated allocation is EF1.

Let us examine one scenario of the final allocation returned by Approx10 in the next lemma, and leave the other to the main Theorem 23.

Lemma 22.

In the final allocation 𝒜=(A1,A2,A3) returned by Approx10, if XA1, then SOL23OPT.

Proof.

If A1=X, then 𝒜 is optimal, i.e., SOL=OPT.

Below we consider the scenario where a1 receives some items from Y. This means when Approx10 terminates, k1>|X|+1 and A1={g1,,gk11}. Let Y1={g|X|+1,,gk11}, that is, A1=XY1.

We claim min{Δ(X),Δ(Y1)}12. Assume to the contrary, then u1(X)Δ(X)>12 and u3(Y1)Δ(Y1)>12. Consider the iteration where a1 is allocated with the last item gk11. Since at the beginning of the iteration the allocation is good, by Lemma 3, a1 and a2 do not envy each other, so do a1 and a3. From gk11Y and Lines 9–13 in the algorithm description, at is envied by a1, and thus u1(A1gk11)<u1(A2A3). It follows from A2A3=YY1 and Eq. (1) that

u1(X)<u1(A2A3)<u3(A2A3)=u3(Y)u3(Y1)<112=12, a contradiction.

Since A2A3Y, we have u1(A2A3)<u3(A2A3), and therefore SOL=u1(A1)+u3(A2A3)>u1(A1)+u1(A2A3)=1.

Using the claimed min{Δ(X),Δ(Y1)}12, if Δ(X)12, then by Eq. (5), OPT3232SOL; if Δ(X)>12, then Δ(Y1)12<Δ(X), and thus SOL=u1(A1)u3(A1)+u3(M)=Δ(X)+Δ(Y1)+1>23(Δ(X)+1)23OPT, where the last inequality is by Eq. (5). This proves the lemma.

Theorem 23.

If maxgXu1(g)13, then Approx10 produces a complete EF1 allocation with its total utility SOL35OPT.

Proof.

Lemma 21 states that the final allocation 𝒜=(A1,A2,A3) returned by the algorithm is complete and EF1. If XA1, then by Lemma 22 the total utility of 𝒜 is at least 23OPT.

We next consider the other scenario where A1X, i.e., the algorithm Approx10 terminates with k1|X|. Let X1={gk1,,g|X|}, then A1={g1,,gk11}=XX1 and A2A3=X1Y.

We claim that Δ(X1)23, and prove it by contradiction to assume Δ(X1)>23. It follows that u1(X1)>23 and thus u1(A1)u1(MX1)<13.

From Lines 4–8 in the description of the algorithm, the item gk1 is assigned to agent at in the last iteration of the while-loop (in which k2=k1 at the beginning of the iteration and k2 is decremented afterwards leading to the termination condition k2<k1). That is, gk1 is the last item received by at. Denote the other agent as ai, i.e., {t,i}={2,3}. Since a1 is envied at the beginning of the iteration, a1 is envied by at; further because the allocation is good, a1 does not envy at. To summarize,

u3(Atgk1)u3(Ai), u3(Atgk1)<u3(A1), and u1(A1)u1(Atgk1). (6)

It follows from A1X that

u3(Atgk1)<u3(A1)u1(A1)<13. (7)

One sees that if agent ai also receives some items from X1, then the above argument applies too for the last item ai receives, denoted as g, such that Eq. (7) holds, i.e., u3(Aig)<13.

Subsequently, if A2X1 and A3X1, then

Δ(X1)Δ(X)=Δ(Y)u3(Atgk1)+u3(Aig)<23, a contradiction.

If X1At, then by Eq. (6),

u1(gk1)u1(At)u1(A1)u1(X1)u1(A1)>13, contradicting to maxgXu1(g)13.

We have thus proved the claim that Δ(X1)23.

We linearly combine Δ(X1)23 and Δ(X1)Δ(X) to have Δ(X1)3523+25Δ(X)=25+25Δ(X), and thus by Eq. (5)

SOL=u1(XX1)+u3(X1Y)=1+Δ(X)Δ(X1)35(1+Δ(X))35OPT.

This proves the theorem.

4.2 Case 2: 𝐦𝐚𝐱𝒈𝑿𝒖𝟏(𝒈)>𝟏𝟑

In this case, we let g=argmaxgXu1(g); thus u1(g)>13, which is so big that it is assigned to agent a1 immediately. On the other hand, we can use g to bound OPT as follows:

OPTu1(X)+u3(Y)u1(X)+u3(M)u3(g)2u3(g)<53+Δ(g). (8)

Our algorithm for this case is very similar to Approx10, with two changes: One is the starting allocation set to be ({g},,), and the other is, when k2=|X|, the while-loop terminates and the algorithm switches to the Envy-Cycle Elimination (ECE) algorithm to assign the rest of items. The detailed description of the algorithm, denoted as Approx11, is presented in Algorithm 9.

Algorithm 9 Approx11 for three agents with normalized utility functions.

Input: Three agents of two types and a set of m indivisible items ρ(g1)ρ(g2)ρ(gm), where g=argmaxgXu1(g) and u1(g)>13.

Output: A complete EF1 allocation.

Theorem 24.

If maxgXu1(g)>13, then Approx11 produces a complete EF1 allocation with its total utility SOL35OPT, and the approximation ratio 35 is tight.

Proof.

We distinguish the two termination condition of the while-loop in Approx11.

In the first scenario, the while-loop terminates at k1>k2, that is, all the items are assigned and k2|X| implying XA1 in the returned allocation 𝒜=(A1,A2,A3). Note that the while-loop body is the same as the while-loop body in Approx10. It follows from Lemma 21 that 𝒜 is good, complete and EF1, and from Lemma 22 that its total utility is SOL23OPT.

In the other scenario, the while-loop terminates at k1k2=|X|, that is, all the items of Y have been assigned to a2 and a3 (i.e., YA2A3), and the unassigned items are gk1,,gk2 excluding g. By Lemma 21, the achieved allocation 𝒜 is good and EF1. Since gA1, we have Δ(A1)Δ(g).

We claim that the ECE algorithm does not decrease Δ(A1). To prove the claim, we assume in an iteration of the ECE algorithm, with the allocation 𝒜=(A1,A2,A3) at the beginning, agent a1 gets the bundle A2 or A3 due to the existence of an envy cycle. Further assume w.l.o.g. that a1 gets bundle A2, which means a1 envies a2 and the envy cycle is either (1231) or (121). Either way, u1(A1)<u1(A2) and u3(A2)(<u3(A3))<u3(A1). Therefore, Δ(A1)<Δ(A2). This proves the claim.

The final allocation 𝒜=(A1,A2,A3) returned from the ECE algorithm has its total utility

SOL=u1(A1)+u3(A2A3)Δ(A1)+u3(M)Δ(g)+1>35OPT,

where the last inequality is by Eq. (8). We thus prove that the approximation ratio of Approx11 is at least 35.

We next provide an instance below to show that this approximation ratio is tight. In this instance, there are five items given in the order ρ(g1)>ρ(g2)>ρ(g3)>1>ρ(g4)=ρ(g5), with their values to the three agents listed as follows, where ϵ>0 is a small value:

g1 g2 g3 g4 g5
a1 13 13ϵ 13+ϵ 0 0
a2,a3 ϵ ϵ 13 13ϵ 13ϵ

One sees that the instance is normalized, X={g1,g2,g3}, and A=({g1,g2},{g3,g4},{g5}) is an optimal EF1 allocation of total utility 533ϵ.

Since u1(g3)>13, Approx11 is executed which starts with the allocation ({g3},,): In the first iteration, a1 is envied by a2 and a3, and the allocation is updated to ({g3},,{g5}) or ({g3},{g5},); in the second iteration, a1 and a3 (resp., a1 and a2) are envied by a2 (resp., a3), and the allocation is updated to 𝒜=({g3},{g4},{g5}); the procedure terminates with k2=|X|=3.

Next, the ECE algorithm is called on 𝒜 to continue to assign the items g1 and g2: In the first iteration, since in ({g3},{g4},{g5}) only a1 is still envied by a2 and a3, a2 and a3 are not envied, the ECE algorithm assigns g1 to a2 (or to a3, symmetrically) resulting in the updated allocation ({g3},{g1,g4},{g5}); in the second iteration, the ECE algorithm assigns the last item g2 to a3, ending at the complete allocation 𝒜=({g3},{g1,g4},{g2,g5}). This final allocation 𝒜=({g3},{g1,g4},{g2,g5}) has total utility 1. Therefore, we have OPT/SOL=(533ϵ)/153, when ϵ tends to 0.

5 Conclusion

Fair division of indivisible goods is an interesting problem which has received a lot of studies, from multiple research communities including artificial intelligence and theoretical computer science. Finding an EF1 allocation to maximize the utilitarian social welfare from the perspective of approximation algorithms emerges most recently. Despite EF1 being one of the most simplest fairness criteria, the design and analysis of approximation algorithms for this problem in the general case seems challenging [4, 6]. In this paper, we focused on the special case where agents are of only two types, and we hope our work may shed lights on and inspire more studies for the general case. For this special case, we presented a 2-approximation algorithm for any number of agents with normalized utility functions; by the lower bound of 4n3n+1 from [6], our result shows the problem in this special case is APX-complete. When there are only three agents, we presented an improved 53-approximation algorithm. When there are only three agents but the utility functions are unnormalized, we presented a tight 2-approximation algorithm which is the best possible by the lower bound of 1+4n32 from [6]. In all three algorithms, we demonstrate the use of the item preference (Definition 1) order, which can be explored further for improved algorithms.

We remark that the lower bound of 4n3n+1 on the approximability in [6] is proven for a more restricted case where the two utility functions are normalized, agent a1 uses a utility function and all the other agents use the other function. It would be interesting to narrow the gap for either the special case we study or this more restricted case; we expect some improved lower bounds or some approximation ratios as functions in n1 and n2, where n1 agents use a common utility function and the other n2=nn1 use the second utility function.

References

  • [1] G. Amanatidis, H. Aziz, G. Birmpas, A. Filos-Ratsikas, B. Li, H. Moulin, A. A. Voudouris, and X. Wu. Fair division of indivisible goods: Recent progress and open questions. Artificial Intelligence, 322:Article 103965, 2023.
  • [2] G. Amanatidis, G. Birmpas, A. Filos-Ratsikas, and A. Voudouris. Fair division of indivisible goods: A survey. In Proceedings of IJCAI 2022, pages 5385–5393, 2022.
  • [3] H. Aziz, X. Huang, N. Mattei, and E. Segal-Halevi. Computing welfare-maximizing fair allocations of indivisible goods. European Journal of Operational Research, 307:773–784, 2023. doi:10.1016/J.EJOR.2022.10.013.
  • [4] S. Barman, U. Bhaskar, and N. Shah. Optimal bounds on the price of fairness for indivisible goods. In Proceedings of WINE 2020, pages 356–369, 2020.
  • [5] X. Bei, X. Lu, P. Manurangesi, and W. Suksompong. The price of fairness for indivisible goods. Theory of Computing Systems, 65:1069–1093, 2021. doi:10.1007/S00224-021-10039-8.
  • [6] X. Bu, Z. Li, S. Liu, J. Song, and B. Tao. Approximability landscape of welfare maximization within fair allocations. In Proceedings of EC 2025, pages 412–440, 2025.
  • [7] E. Budish. The combinatorial assignment problem: Approximate competitive equilibrium from equal incomes. Journal of Political Economy, 119:1061–1103, 2011.
  • [8] I. Caragiannis, D. Kurokawa, H. Moulin, A. Procaccia, N. Shah, and J. Wang. The unreasonable fairness of maximum Nash welfare. ACM Transactions on Economics and Computation, 7:12:1–12:32, 2019. doi:10.1145/3355902.
  • [9] R. Lipton, E. Markakis, E. Mossel, and A. Saberi. On approximately fair allocations of indivisible goods. In Proceedings of EC 2004, pages 125–131, 2004.
  • [10] J. Ma, Y. Chen, G. Chen, M. Gong, G. Lin, and A. Zhang. Maximizing social welfare among EF1 allocations at the presence of two types of agents. CoRR, 2025. arXiv:2509.09641.
  • [11] H. Steinhaus. Sur la division pragmatique. Econometrica, 17:315–319, 1949.
  • [12] H. Varian. Equity, envy and efficiency. Journal of Economic Theory, 9:63–91, 1974.