Abstract 1 Introduction 2 Technical Overview 3 Notation 4 An Algorithm for Identical Capacities 5 An Algorithm for Arbitrary Capacities 6 Hardness Result 7 Conclusion and Discussion References

Near-Tight Approximation Algorithms for Bottleneck Multiple Knapsack Problems

Lin Chen ORCID Zhejiang University, Hangzhou, China    Tingwei Hu ORCID Zhejiang University, Hangzhou, China    Yuchen Mao ORCID Zhejiang University, Hangzhou, China    Yong Chen ORCID Hangzhou Dianzi University, China    Lili Mei ORCID Hangzhou Dianzi University, China    An Zhang ORCID Hangzhou Dianzi University, China    Guangting Chen ORCID Zhejiang University of Water Resources and
Electric Power, Hangzhou, China
   Guochuan Zhang ORCID Zhejiang University, Hangzhou, China
Abstract

In the bottleneck multiple knapsack problem, we are given a set of items and a set of knapsacks, where each item has a profit and a weight, and each knapsack has a capacity. Our goal is to assign items to knapsacks so as to maximize the minimum profit received by any knapsack subject to the capacity constraint. When all knapsacks have identical capacity, we give a (23ε)-approximation algorithm for any constant ε>0. This result almost matches the (23+ε) inapproximability bound for the bottleneck multiple subset sum problem (Caprara et al., 2000). When the knapsacks can have arbitrary capacities, we propose a (12ε)-approximation algorithm for any constant ε>0. We also prove a hardness bound of (12+ε) for any constant ε>0.

Keywords and phrases:
Bottleneck multiple knapsack, approximation algorithms
Category:
Track A: Algorithms, Complexity and Games
Funding:
Lin Chen: National Natural Science Foundation of China [Project No. 6257070197]
Yuchen Mao: National Natural Science Foundation of China [Project No. 62402436]
Guochuan Zhang: National Natural Science Foundation of China [Project No. 12271477]
Copyright and License:
[Uncaptioned image] © Lin Chen, Tingwei Hu, Yuchen Mao, Yong Chen, Lili Mei, An Zhang,
Guangting Chen, and Guochuan Zhang; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Approximation algorithms analysis
Related Version:
Full Version: http://arxiv.org/abs/2605.05233
Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele Puppis

1 Introduction

Maximizing the minimum profit received by multiple agents is a central objective in the study of fairness and equitable resource allocation. In this paper, we study this objective in the context of knapsack-type constraints.

We consider the bottleneck multiple knapsack problem (BMKP), which can be viewed as a max-min variant of the classical multiple knapsack problem (MKP). Given items with profits and weights and multiple knapsacks with capacities, the classical multiple knapsack problem (MKP) maximizes the sum of profits among all knapsacks. In BMKP, the objective changes to maximizing the minimum total profit received by any knapsack. Our results address two settings: identical capacities and arbitrary capacities.

The bottleneck (max–min) objective has been studied in a special case of MKP, namely the multiple subset sum problem (MSSP), where each item has profit equal to its weight and all knapsacks have identical capacities. Caprara, Kellerer, and Pferschy [5] presented a polynomial-time approximation scheme (PTAS) for the max-sum objective in MSSP and gave a 23-approximation for bottleneck MSSP. They also showed that, for any ε>0, achieving a (23+ε)-approximation is impossible unless P=NP. For the max-sum objective, PTASs for MKP have been studied extensively with successive improvements in running time (see [5, 6, 7, 21, 9, 19, 20]). In contrast, the bottleneck objective for MKP remains far less understood. It remains open whether the same 23 ratio can be attained for the more general bottleneck multiple knapsack problem, or whether stronger inapproximability results hold.

The bottleneck (max-min) objective also arises naturally in the literature on fair allocation of indivisible goods. A central notion in this area is the maximin share (MMS), which measures the largest value an agent can guarantee for herself by partitioning the items into feasible bundles and then receiving the least valuable bundle. The MMS criterion has been extensively studied under a variety of feasibility constraints, including cardinality [4, 18], matroid [13, 14], and knapsack-type constraints [11, 17], as a fundamental benchmark for fairness.

Recently, Hummel [17] studied MMS guarantees in hereditary set system valuations, a generalization of the identical-capacity knapsack (budget) setting. His result implies a 25-approximation algorithm for identical-capacity BMKP, which is the best previously known guarantee and still far from the 23 hardness barrier. And it is unclear what approximation ratio can be achieved for arbitrary-capacity BMKP.

For max-sum objectives, one may lose an ε fraction of the total profit by sacrificing the total profits of a few knapsacks. For instance, under the identical setting, one may apply the APTAS for bin packing [10] to pack guessed items into at most (1+ε)m+1 bins where m is the number of knapsacks, and then discard the extra bins at an ε-fraction loss in the overall objective [6]. Such a strategy fails for the bottleneck objective, as the loss must be controlled for every knapsack, which calls for finer per-knapsack structure.

1.1 Our Contributions

We give nearly tight approximation guarantees for BMKP in both the identical-capacity and arbitrary-capacity settings. In the identical-capacity setting, we obtain a (23ε)-approximation algorithm, which nearly matches the (23+ε) inapproximability under the assumption that PNP [5]. Let |I| denote the input size.

Theorem 1.

In the identical-capacity setting, for any constant ε>0, there is a polynomial-time (23ε)-approximation algorithm for the bottleneck multiple knapsack problem with running time |I|2O(1/εlog(1/ε)).

In the arbitrary-capacity setting, we establish a nearly tight approximation guarantee at 12. We give a (12ε)-approximation algorithm for any constant ε>0, and show that no polynomial-time (12+ε)-approximation is possible unless P=NP.

Theorem 2.

For any constant ε>0, there is a polynomial-time (12ε)-approximation algorithm for the bottleneck multiple knapsack problem with running time 22poly(1/ε)poly(|I|).

Theorem 3.

Unless P=NP, the bottleneck multiple knapsack problem has no polynomial-time (12+ε)-approximation algorithm for any constant ε>0.

The following table summarizes the results of approximation algorithms for multiple knapsack problems under different objectives and capacity settings.

MKP (max-sum objective) BMKP (max-min objective)
Negative Positive Negative Positive
Identical capacity NP-hard 1ε [9, 19, 20] 23+ε [5] 23ε (Theorem 1)
Arbitrary capacity NP-hard 1ε [9, 19, 20] 12+ε (Theorem 3) 12ε (Theorem 2)

1.2 Related Work

We briefly review approximation schemes for the multiple subset sum problem (MSSP) and the multiple knapsack problem (MKP) with the objective of maximizing the total profit. Caprara et al. [5] gave the first PTAS for MSSP, and also showed that MSSP admits no FPTAS even for two knapsacks unless P=NP. Subsequent work extended the PTAS to MKP under the arbitrary capacity setting as well as reduce its running time (see [5, 6, 7, 21, 9, 19, 20]). So far, the best-known result is due to Jansen [20], which is a PTAS for MKP where knapsacks can have arbitrary capacities, and has a running time of poly(|I|)+2O(1/ε(log(1/ε))4). This PTAS is near-optimal in the sense that there is no poly(|I|)+2o(1/ε) time PTAS assuming ETH (Exponential Time Hypothesis).

Machine scheduling problems can be viewed as a lower-dimensional analogue of multiple knapsack, where one primarily focuses on the profit dimension (i.e., the processing time of jobs). For identical parallel machines, Hochbaum and Shmoys [15] gave a PTAS for the objective of minimizing the maximum completion time (makespan). Woeginger [26] presented a PTAS for maximizing the minimum completion time. For related machines, PTASs are known for both the max-min and min-max objectives [1, 12]. For unrelated machines, Lenstra, Shmoys and Tardos [23] gave a 2-approximation algorithm for makespan minimization, and also proved that no polynomial-time algorithm can achieve an approximation ratio better than 3/2 unless P=NP.

The max–min variant of scheduling on unrelated machines is commonly known as the Santa Claus problem. Interpreting machines as agents and jobs as items with agent-dependent values, the goal is to allocate items so as to maximize the minimum total value received by any agent. The best approximation algorithm known for this problem is due to Chakrabarty et al. [8] achieving an approximation ratio of Ω~(1nε), where n is the number of items. And the best known hardness of approximation stands at 12 [3, 8]. For more results of the Santa Claus problem, please refer to e.g. [2, 24, 22].

2 Technical Overview

Our framework.

Our algorithms follow the standard framework of the PTASs for MKP [9, 19, 20]. Assume that the optimal objective value OPT is known. We classify items into two categories:

  • Expensive items: items whose profit is large (say, at least εOPT);

  • Cheap items: items whose profit is small (say, less than εOPT).

By this classification, we may assume that each knapsack contains at most 1/ε expensive items. If some knapsack contains more than 1/ε expensive items, then we can discard the extra ones and still maintain optimality.

Since there are constant number of expensive items per knapsack, we can apply the standard round-and-guess approach to them. We round profits and weights so that each expensive item belongs to one of constantly many types. We then show that there exists a feasible solution in which every expensive item is replaced by its (rounded) type. This allows us to guess, for each knapsack, how many items of each type it receives (i.e., a configuration), and to pack expensive items according to the guessed configuration while losing only a small amount of profit.

To handle cheap items, we formulate a linear programming. Since each cheap item has profit below εOPT, losing only O(1) cheap items per knapsack decreases the objective by at most O(ε)OPT. Thus, it suffices to show that we can round an LP solution to an integral assignment while discarding only a constant number of cheap items per knapsack.

For our max–min objective, the main technical challenge can be phrased as follows:

Is it possible to round the items in such a way that there exists a solution in which, for every knapsack, feasibility is preserved and the loss in profit is small?

We discuss the challenges and techniques for the identical capacity setting and the arbitrary capacity setting separately.

2.1 Identical Capacities

Without loss of generality, we assume the knapsack capacity B=1 and OPT=1. Our goal is to find an assignment such that each knapsack receives total profit at least (23ε). Let m be the number of knapsacks.

Challenges.

Consider an optimal solution. The main difficulty is that weight rounding (in particular, rounding up) may force us to drop some items to restore feasibility, and the resulting profit loss in a single knapsack may exceed (1/3+ε). This can happen for items that are highly sensitive to weight rounding, including

  • Heavy items: items with weight close to 1 (e.g., 1o(ε)) and profit greater than (1/3+ε);

  • Exact-fit pairs: two items whose total weight is close to 1 and whose total profit is close to 1, where each item has profit larger than (1/3+ε).

Assume there are knapsacks containing such items in the optimal solution. If the weight of any item in the above classes is rounded up, one may have to discard at least one such item, which would incur a profit loss exceeding (1/3+ε) and violate the desired guarantee.

Our algorithm.

We classify items into heavy/light and expensive/cheap categories.

  • Step 1 (Heavy items). We round heavy items into a constant number of types and guess their assignment to knapsacks.

  • Step 2 (Light-expensive items). Once we know that knapsack j contains a heavy item h with rounded weight w~(h), we can round the weights of light items using the scaling factor 1w~(h), and then guess the assignment of light items in each knapsack.

  • Step 3 (Exact-fit pairs). We determine the placement of exact-fit pairs by solving a maximum matching problem.

  • Step 4 (Cheap items). We pack the remaining cheap items by solving a linear program and rounding its fractional solution.

Main techniques.

The main technical component is to show that there exists a solution (of the rounded instance) in which weight rounding is feasible and incurs a profit loss of at most (1/3+ε) per knapsack. Starting from an optimal solution, we divide knapsacks into two types depending on whether they contain a heavy item.

  1. (a)

    Knapsacks with only light items: We show that removing items of total profit at most (1/3+ε) is sufficient to make the weight rounding of the light items feasible.

  2. (b)

    Knapsacks with both heavy and light items:

    1. (b.1)

      Heavy items: We apply a rounding and shifting process as follows.

      • Rounding. We adopt the linear grouping scheme from bin packing [10, 25]. Group the heavy items as follows: the first group contains the heaviest k items, the second group contains the next heaviest k items, and so on. Here k is chosen so that the number of groups is constant. We discard the first group (to be compensated later), and round the weight of heavy items in each group to the heaviest item in that group.

      • Shifting. To maintain feasibility, we shift light items groupwise from their groups to lighter ones (where heavy items are lighter).

      This process guarantees that the weight rounding of heavy items is feasible and the total profit loss is bounded. See Figure 1 for an illustration.

    2. (b.2)

      Light items: We show that removing light items of total profit at most (1/3+ε) from each knapsack is sufficient to make the weight rounding feasible. Moreover, we prove that these removed items can be reassembled and packed into the knapsacks in the discarded group created by the heavy-item shifting step.

Refer to caption
Figure 1: Illustration of the rounding and shifting procedure. Thick (resp., thin) solid segments denote heavy (resp., light) items. Dashed boxes highlight the items being shifted, and arrows show their destinations.

2.2 Arbitrary Capacities

For more details, see the full version of this paper.

3 Notation

In the bottleneck multiple knapsack problem, we are given a set of m knapsacks with capacity B1,,Bm, and a set I of n items, where each item iI has weight w(i) and profit p(i). For any positive integer k, we write [k]={1,2,,k}. A feasible solution consists of m disjoint subsets I1,,ImI with iIjw(i)Bj for each j[m]. Our goal is to find a feasible solution (I1,,Im) that maximizes the minimum profit received by any knapsack. More precisely, we want to maximize minj[m]iIjp(i).

For any subset II of items, we use p(I) and w(I) to denote the total profit and total weight of the items in I, respectively.

We define the density of an item i to be ρ(i)=p(i)w(i). If w(i)=0, we interpret i as a dummy (nonexistent) item, and set p(i)=0 and ρ(i)=0. For any subset II of items, define its density as ρ(I)=p(I)/w(I).

By scaling, we assume that OPT=1. In the identical-capacity setting, we normalize the capacity and write B=1. In the arbitrary-capacity setting, we assume B1=1 and 1=B1B2Bm.

4 An Algorithm for Identical Capacities

In this section, we prove Theorem 1.

4.1 Proof Roadmap

We introduce the key concepts of our proof and explain their roles at a high level.

  1. 1.

    Item categories. We will define heavy/light items and expensive/cheap items. Our main focus is on heavy-expensive items and light-expensive items.

  2. 2.

    Critical items. Given a solution, an item is critical (with respect to this solution) if it is either expensive or heavy, and packed in a knapsack containing at least three items. Critical items are exactly the items that we will round.

  3. 3.

    Slack solution. A solution is said to be slack if, in every knapsack, the unused capacity is large enough to allow the rounding of its critical items. We will define the precise meaning of “large enough”.

  4. 4.

    Profiles. A profile (of a slack solution) is a subset of heavy items that serves as the rounded types of critical heavy items. More precisely, it is defined so that, after replacing each critical heavy item by one of the items in the profile (its rounded type), the resulting solution remains slack.

Organization of the proof.

We guess the critical heavy items, critical light items, non-critical items successively. Our argument follows an “existence-guessing” pattern: before each guessing step, we first prove that there exists a slack solution (containing previously guessed structure); we then guess the assignment of items in this slack solution. The main technical component is the first existence result.

  1. 1.

    Existence of a slack solution and its profile. We show that there exists a slack solution whose minimum knapsack profit is at least 23ε, and whose profile has constant cardinality (Lemma 8). Since the profile has constant size, we can enumerate all possibilities of the profile in polynomial time (Lemma 10).

  2. 2.

    Guessing critical heavy items. There exists a slack solution with objective value at least 232ε whose profile is the guessed one (Lemma 13). Moreover, for each rounded type in the profile, every critical heavy item in this solution is heavier than any non-critical heavy item of the same type (Lemma 13). We show that these critical heavy items can be guessed (Lemma 14).

  3. 3.

    Guessing critical light items. There exists a slack solution with objective value at least 233ε whose critical heavy items are the guessed ones (Lemma 18). Moreover, for each rounded type of light items, every critical light item in this solution is heavier than any non-critical light item of the same type (Lemma 18). We show that these critical light items can be guessed (Lemma 19).

  4. 4.

    Determining non-critical items. Finally, we complete the packing by handling knapsacks with |Ij|=2 (Lemma 21) and assigning the non-critical cheap items in knapsacks with |Ij|3 (Lemma 22).

4.2 Preliminaries

Recall that OPT=1 and B=1. Our goal is to compute, in polynomial time, a feasible solution (I1,,Im) such that p(Ij)236ε for all j[m]. (The constant factor in front of ε is for convenience; by rescaling ε, one can achieve 23ε.) For simplicity, we assume that ε is a sufficiently small constant and 1/ε is an integer.

We assume that every item i satisfies p(i)<236ε. Otherwise, if some item has profit at least 236ε, we can assign it to an empty knapsack and remove both the item and that knapsack from the instance. The remaining instance still admits a solution with objective value at least 1. Consequently, we can assume that every knapsack in the optimal solution contains at least two items.

Definition 4 (Heavy, Light, Expensive, and Cheap Items).

An item i is heavy if w(i)1ε2, and light otherwise. It is expensive if p(i)ε, and cheap otherwise.

We assume that each knapsack contains at most 1/ε expensive items. If a knapsack contains more, we keep an arbitrary subset of 1/ε expensive items, whose total profit is at least 1.

Definition 5 (Critical Items).

Let 𝒮=(I1,,Im) be a feasible solution. The critical items of 𝒮 are defined to be the heavy items and the expensive items in any Ij with |Ij|3. All the items in 𝒮 that are not critical are called non-critical items.

There are four types of items: heavy-expensive, heavy-cheap, light-expensive, and light-cheap. We assume w.l.o.g. that heavy-cheap items do not exist. By Definition 4, each knapsack contains at most one heavy item. If this heavy item is cheap, removing it decreases the profit of that knapsack by less than ε; by rescaling ε, we can still state the guarantee as at least 23ε. Therefore, every heavy item is expensive. Combined with Definition 5, it follows that every critical item is expensive, and thus each knapsack contains at most 1/ε critical items.

Definition 6 (Slack Solutions).

We say that a solution (I1,,Im) is slack if for any j[m] with |Ij|3, exactly one of the following conditions holds.

  1. (i)

    All the items in Ij are light, and w(Ij)1ε3,

  2. (ii)

    Ij contains a heavy item h, and

    w(Ij)w(h)(1ε)(1w(h)),or equivalently,1w(Ij)ε(1w(h)).

The first case in Definition 6 implies that the unused capacity 1w(Ij) is at least ε3. The second case implies that the total weight of light items w(Ij)w(h) occupy at most a (1ε)-fraction of (1w(h)). In other words, the unused capacity 1w(Ij) is at least ε(1w(h)).

Definition 7 (Profile).

Let TI be a subset of heavy items. Let 𝒮=(I1,,Im) be a slack solution. We say that T is a profile of 𝒮 if, for any Ij that contains a critical heavy item h, there exists tT such that p(t)/ε=p(h)/ε and

w(Ij)w(h)(1ε)(1w(t))(1ε)(1w(h)). (1)

Note that the inequality above guarantees that w(t)w(h). It implies that if we replace the heavy item h by t, we have

w((Ij{h}){t})w(t)=w(Ij)w(h)(1ε)(1w(t)).

Therefore, if we round h to t, the resulting solution is still slack.

4.3 Existence of a Structured Slack Solution

We show that there is a slack solution that has a profile of constant size.

Lemma 8.

There is a slack solution 𝒮=(I1,,Im) such that p(Ij)23ε for any j[m] and 𝒮 has a profile TI of heavy items with |T|O((1ε)2).

Proof.

We first show the existence of a slack solution 𝒮 with p(Ij)23ε for any j[m]. Then we show the existence of the profile.

Step 1: Existence of a slack solution.

Given an optimal solution (X1,,Xm) with p(Xj)1 for all j[m], we convert it into a slack soluton with p(Ij)23ε for any j[m]. Without loss of generality, we assume every Xj is minimal in the sense that deleting any item makes its total profit less than 1.

By assumption, each item has profit of at most 236ε and |Xj|2 for any j[m]. If there exists j[m] such that Xj contains two items i1,i2 with p(i1)+p(i2)23ε, then we simply set Ij={i1,i2}. By Definition 5, they are non-critical items and does not affect slackness or the profile.

We thus restrict attention to the case where, for all i1,i2Xj,

p(i1)+p(i2)<23ε. (2)

We distinguish between the two cases below.

(Case 1) All items in 𝑿𝒋 are light.

If w(Xj)1ε3, then let Ij=Xj; by Definition 6, this knapsack is slack, and we are done. Therefore, we assume w(Xj)>1ε3 and partition the items in Xj into three sets:

Xe={iXjp(i)>13+ε and w(i)1ε2},

where w(i)1ε2 holds since all items are light,

Xc={iXjp(i)13+ε and w(i)ε3},

and

Xd={iXjp(i)13+ε and w(i)>ε3}.

By construction, Xj=XeXcXd. If Xd, then we can pick any item iXd and set Ij=Xj{i}; by Definition 6, we are done. Therefore, we assume that Xd=.

Note that there is at most one item in Xe, since otherwise there would be two items whose total profit is at least 23ε, contradicting equation (2). This implies

w(Xc)=w(Xj)w(Xe)(1ε3)(1ε2)=ε2ε3ε3. (3)

Let YXc be obtained by sorting the items in Xc in increasing order of density and adding them until the total weight first reaches at least ε3. The set Y always exists due to equation (3), and it follows that

ε3w(Y)2ε3. (4)

Since Y consists of items with the smallest density, the density of Y is at most the density of Xc. Recall that Xj is minimal. Fix any iXc. Then p(Xc{i})p(Xj{i})<1, and since p(i)13+ε, we get p(Xc)<1+13+ε. Hence, by equation (3) and (4), we have

p(Y)w(Y)p(Xc)w(Xc)2ε31+13+εε2ε313,

where the last inequality holds for 0<ε9+10512. Recall that we assume ε is a sufficiently small constant, so the above inequality holds.

Then we let Ij=XjY. It is clear that p(Ij)=p(Xj)p(Y)23ε and w(Ij)=w(Xj)w(Y)1ε3, which implies that Ij is slack.

(Case 2) 𝑿𝒋 contains a heavy item.

By Definition 4, each knapsack contains at most one heavy item. Denote it by h. If p(h)13+ε, let Ij=Xj{h}. Then Ij contains only light items, and

p(Ij)=p(Xj)p(h)23ε,w(Ij)=w(Xj)w(h)1ε3.

By Definition 6, Ij is slack. It remains to consider the case where p(h)>13+ε.

Claim 9.

If p(h)>13+ε, there is a subset YXj{h} with

εp(Y)13 and ε(w(Xj)w(h))w(Y)ε2. (5)
Proof of Claim 9.

Let Xlight=Xj{h}. Since p(h)>13+ε, every item iXlight satisfies p(i)13ε. Otherwise p(h)+p(i)23, contradicting (2). Recall that p(h)23ε<23 by assumption and w(h)1ε2 by Definition 4. It follows that

p(Xlight)=p(Xj)p(h)13 and w(Xlight)=w(Xj)w(h)1(1ε2)=ε2. (6)

Let YXlight be obtained by sorting the items in Xlight in increasing order of density and adding them until p(Y)>1/3. Let the last item added to Y be l, and set Y=Y{l}. Recall that every item in Xlight has a profit of at most 13ε. We have

13p(Y)13p(l)13(13ε)=ε. (7)

Since Y consists of items of the smallest density, its density is at most the density of Xlight. Moreover, by minimality of Xj, p(Xlight)=p(Xj{h})<1. Therefore,

w(Y)p(Y)w(Xlight)p(Xlight)>εw(Xlight)=ε(w(Xj)w(h)).

The strict inequality follows from (7) and p(Xlight)<1. Finally, equation (6) implies w(Y)w(Xlight)ε2. Combining the above inequalities yields (5), completing the proof.

We set Ij=XjY where Y is defined in Claim 9. It is clear that p(Ij)=p(Xj)p(Y)23ε and

w(Ij)w(h)=w(Xj)w(Y)w(h)(1ε)(w(Xj)w(h))(1ε)(1w(h)),

which implies that Ij is slack.

Step 2: Existence of a profile of small cardinality.

We have constructed a slack solution 𝒮=(I1,,Im) with p(Ij)23ε for all j[m]. Next, we convert 𝒮 into another slack solution 𝒮=(I1,,Im) whose profile has constant cardinality.

Consider the knapsacks that contain a heavy item in the slack solution 𝒮. Let 𝒥H[m] be the set of indices j such that Ij contains a heavy item. Recall that each such Ij contains exactly one heavy item. We denote it by hj.

We partition 𝒥H into groups according to the value of p(hj)/ε: two indices j,j𝒥H are in the same group if p(hj)/ε=p(hj)/ε. Note that there are at most 1/ε such groups since every heavy item has profit at most 236ε and at least ε. We handle each group separately as follows.

Fix an integer t and consider the group 𝒦={j𝒥Hp(hj)/ε=t}. Write 𝒦={1,2,,k} after relabeling the corresponding knapsacks, and further relabel so that

w(h1)w(h2)w(hk). (8)

For each j[k], let YjXj{hj} be the set of light items guaranteed by Claim 9. Recall that Ij=XjYj. We now construct new sets I1,,Ik as follows.

For 1jεk, let =23ε and define

Ij=Y(j1)+1Y(j1)+2Yj.

By Claim 9, each Yj consists only of light items and satisfies p(Yj)ε and w(Yj)ε2. Hence,

p(Ij)ε23andw(Ij)ε2ε1ε3,

where ε2ε1ε3 holds for 0<ε13. Therefore, Ij is slack by Definition 6.

For εk<jk, let s=jεk and set

Ij=(Ij{hj}){hs}.

That is, we replace the heavy item hj by hs. Since s<j, by equation (8), we have w(hs)w(hj), and thus w(Ij)w(Ij).

Note that p(hj)/ε=p(hs)/ε, which implies p(hs)p(hj)ε. By Claim 9 and Ij=XjYj, the profit of Ij is

p(Ij)=p(Ij)+p(hs)p(hj)p(Xj)p(Yj)ε113ε=23ε.

Meanwhile, we have

w(Ij)w(hs) =w(Ij)w(hj)
(1ε)(1w(hj))
(1ε)(1w(hs)). (9)

The first inequality follows from the slackness of Ij in 𝒮. The last inequality holds since w(hs)w(hj). By Definition 6, Ij is slack.

Above all, we obtained a slack solution 𝒮=(I1,,Im). Next, we construct its profile T. Let δ=max{1,εk}. Let {hδ,h2δ,,hrδ} be the representative heavy items of this group, where r=kδ=O(1ε).

For a group with p(hj)/ε=t, we set Tt={hδ,h2δ,,hrδ} to be the set of representative heavy items defined above. Here 1t1/ε because by assumption, εp(hj)236ε for any heavy item hj. We then define the profile set T to be the union of Tt over all groups, i.e., T=t=11/εTt. Since r=O(1ε) for each group, we have |T|=O((1ε)2).

It remains to argue that T is the profile of 𝒮=(I1,,Im). Towards this, it suffices to show that equation (1) holds for each Tt where 1t1/ε. To see this, observe that for each heavy item hsIj where s=jεk, there must exist some hjT with sjj, which implies w(hs)w(hj)w(hj). Therefore, by equation (4.3), we have

w(Ij)w(hs) =w(Ij)w(hj)
(1ε)(1w(hj))
(1ε)(1w(hj))
(1ε)(1w(hs)).

Combined with p(hj)/ε=p(hs)/ε, we conclude that T is the profile of 𝒮 and |T|=O((1ε)2). The constructed solution 𝒮 is exactly the solution 𝒮 claimed in the lemma.

Lemma 10.

After guessing for nO((1ε)2) rounds, at least one of the guesses gives the T that is the profile of the slack solution in Lemma 8.

Proof.

Since |T|=O((1ε)2), and according to the definition of profile, every element of T must be one of the heavy items (i.e., at most n possibilities), we can guess T via nO((1ε)2) enumerations.

4.4 Guessing Critical Heavy Items

We have correctly guessed the profile TI satisfying Lemma 8. Our goal in this subsection is to guess the critical heavy items using T.

In particular, we associate each heavy item hI with a unique item 𝒯(h)T. We define the label weight and label profit of h to be the weight and profit of 𝒯(h), respectively.

Definition 11 (Label weight and label profit).

Fix a profile TI. For a heavy item h, let

𝒯(h)={tT|p(t)ε=p(h)εandw(t)w(h)}.

If 𝒯(h), choose any targminx𝒯(h)w(x) and define w~(h)=w(t) and p~(h)=p(t). Otherwise, define w~(h)=+ and p~(h)=0.

 Remark.

One can view item t as the result of rounding h to a nearby item in the profile T. Note that we neither alter the instance nor replace h by t here. Instead, we simply introduce the notations w~(h) and p~(h) to label h.

Definition 12 (Type and -order).

Two heavy items h1,h2 are of the same type if w~(h1)=w~(h2) and p~(h1)=p~(h2). We define a partial order on heavy items as follows: for heavy items h1,h2, we write h1h2 iff h1 and h2 have the same type and w(h1)<w(h2). Given a set A of heavy items, an item hA is -minimal (resp., -maximal) if there is no hA with hh (resp., hh).

Note that we cannot directly guess which heavy items are critical within each type because it may take exponential time. Instead, we may guess the number of critical heavy items of each type and select them arbitrarily. To guarantee that such a selection is valid, we need to show that even if we select the heaviest items of each type as critical heavy items, the resulting solution is slack and have the desired objective value.

The following lemma shows that there exists a slack solution in which, within each type, every critical heavy item is heavier than every non-critical heavy item (Property iii). Moreover, the total profit of this solution decreases by at most ε compared to the solution in Lemma 8 (Property i). And the property of profile is preserved (Property ii). Here we replace the notation w(t) in equation (1) by w~(h) .

Lemma 13.

There exists a slack solution 𝒮=(I1,,Im) satisfying the following.

  1. (i)

    p(Ij)232ε for any j[m].

  2. (ii)

    For each j[m], if Ij contains a critical heavy item h, then

    w(Ij)w(h)(1ε)(1w~(h)).
  3. (iii)

    For any critical heavy item h, and for any non-critical heavy item h, if h and h are of the same type, then hh.

Proof.

(See the full version of this paper.)

Lemma 14.

After guessing O(n(1ε)2) rounds, at least one of the guesses gives m disjoint set H1,,Hm of heavy items such that there exists a slack solution 𝒮=(I1,,Im) satisfying the following.

  1. (i)

    p(Ij)232ε for any j[m].

  2. (ii)

    For each j[m], if Ij contains a critical heavy item h, then

    w(Ij)w(h)(1ε)(1w~(h)).
  3. (iii)

    The set of critical heavy items of 𝒮 in Ij is exactly Hj.

Proof.

We first guess the number of critical heavy items of each type in the slack solution 𝒮 satisfying Lemma 13. Note that the number of heavy-item types is at most |T|=O((1/ε)2). Index these types by τ1,,τ|T|. For each [|T|], let n denote the number of critical heavy items of type τ in 𝒮, and let (n1,,n|T|) be the count vector. We enumerate all possibilities for (n1,,n|T|). Since 0nn for every , this takes at most n|T|=nO((1/ε)2) rounds.

Fix the round that guesses the correct tuple. In this round, for every [|T|] we select the heaviest n items of type τ. Call the union of all selected items H. By Lemma 13, the set of critical heavy items used by 𝒮 is exactly H.

We distribute the items of H among m sets H1,,Hm, allowing empty sets, so that |Hj|1 for all j[m] and j=1mHj=H. We can relabel the knapsacks in 𝒮 so that property iii is satisfied. Property i and ii follow directly from Lemma 13.

Note that Hj either contains one heavy item or is empty, meaning that there is no critical heavy item in knapsack j.

4.5 Guessing Critical Light Items

Given H1,,Hm satisfying Lemma 14, our next goal is to guess the critical light items. Similarly to heavy items, we define label weight, label profit, type and -order for light items.

Let e be a light-expensive item. We define W(e) to be the scaling factor for rounding the weight of e. To keep the solution feasible after rounding, the factor W(e) should depend on the heavy item (if any) packed together with e, which is not known in advance. We therefore use a conservative choice: define t to be the heaviest item in the profile T that w(e)1w(t), and then let W(e) be ε(1w~(t)), where w~(t) is given in Definition 11. If no such t exists, we use a fixed scaling factor ε3.

Definition 15 (Label weight and label profit for light items).

Fix a profile TI. Let e be a light-expensive item and define 𝒯(e)={tTw(e)1w(t)}. If 𝒯(e), let targmaxx𝒯(e)w(x) and set

W(e)=ε(1w~(t)).

Otherwise, set W(e)=ε3. We define the label weight and label profit of e by

w~(e)=w(e)εW(e)εW(e),p~(e)=p(e)ε2ε2.

For each light cheap item i, we set w~(i)=w(i) and p~(i)=p(i). For a set of items X, we define w~(X)=iXw~(i) and p~(X)=iXp~(i).

Definition 16 (Type and -order).

Two light-expensive items e1,e2 are of the same type if w~(e1)=w~(e2) and p~(e1)=p~(e2). We define a partial order on light-expensive items by declaring e1e2 iff e1 and e2 have the same type and w(e1)<w(e2).

Next, we count the number of different types of light-expensive items. Note that if we choose W(e)=ε(1w~(t)), then we have w(e)1w(t), which implies w(e)εW(e)1ε2. If we choose W(e)=ε3, then w(e)εW(e)1ε4. On the other hand, p(e)ε2 is at most 1ε2. We have the following observation.

Observation 17 (Constant number of types).

There are at most O((|T|ε2+1ε4)1ε2)=O((1ε)6) different types.

The following lemma shows that there exists a solution in which, within each type, every critical light item is heavier than every non-critical heavy item (Property iv). Moreover, the total profit decreases by at most ε compared to the solution in Lemma 13 (Property i). And if we replace the weights of all critical items by their label weights, the feasibility is still preserved (Property ii), where we apply the property of slack.

Lemma 18.

Given H1,,Hm, there exists a feasible solution 𝒮=(I1,,Im) satisfying

  1. (i)

    p(Ij)233ε for any j[m].

  2. (ii)

    For j[m], the set of critical heavy items in Ij is exactly Hj.

  3. (iii)

    For each j[m], if |Ij|3, then

    w(Ij)w(Lj)+w~(Lj)w(Hj)+w~(Hj)1,

    where Lj is the set of critical light items in Ij.

  4. (iv)

    For any critical light-expensive item e1, and for any non-critical light-expensive item e2, if e1 and e2 are of the same type, then e1e2.

Proof.

(See the full version of this paper.)

Lemma 19.

Given H1,,Hm, after guessing for m2O(1ε) rounds, at least one of the guesses gives m sets L1,,Lm of light-expensive items such that there exists a feasible solution 𝒮=(I1,,Im) satisfying

  1. (i)

    p(Ij)234ε for any j[m].

  2. (ii)

    For each j[m], the set of critical heavy items of 𝒮 in Ij is exactly Hj.

  3. (iii)

    For each j[m], the set of critical light items of 𝒮 in Ij is exactly Lj.

Proof.

We first guess, for each type of light items, how many critical items of this type appear in the solution 𝒮 from Lemma 18. By Observation 17, this can be done in O(n(1/ε)6) rounds. By Lemma 18 iv, selecting the heaviest items with the guessed number in each type exactly gives the set of critical light items in 𝒮. Denote the set by L.

We now guess the assignment of critical items in 𝒮 by guessing the assignment of their types. Let be the set of indices of all distinct types of critical items (including both heavy and light items). By Observation 17 and |T|=O((1/ε)2), we have ||=O((1/ε)6). Recall that each knapsack contains at most 1/ε critical items. A configuration is a vector 𝐫=(r1,,r1/ε)1/ε, where rk specifies which rounded type the k-th critical item in the knapsack uses (padding with a dummy type if there are fewer than 1/ε critical items). Thus, the number of possible configurations is N||1/ε((1/ε)6)1/ε=2O(1εlog1ε).

Then we guess the multiplicities of these configurations. Let (c1,,cN)0N be the count vector, where ci denotes the number of knapsacks using configuration i. We enumerate all possibilities for (c1,,cN) satisfying i=1Nci=m, which has (m+N1N1)mO(N)=m2O(1/εlog(1/ε)) possibilities.

For convenience, an item is said to have a rounded type, determined by its label weight and label profit. Note that at least one of the guesses gives the count vector of 𝒮 in Lemma 18. Fixing this guess, we obtain m configurations of 𝒮, say 𝐫1,,𝐫m.

We assign the configurations to knapsacks as follows. We compute a perfect matching between the sets H1,,Hm and 𝐫1,,𝐫m. We add an edge between Hj and 𝐫i if either (1) the rounded type of Hj appears in 𝐫i, or (2) Hj= and 𝐫i contains no heavy-item type. Note that the perfect matching exists given a correct guess of 𝒮.

Now we construct L1,,Lm. We relabel 𝐫1,,𝐫m such that 𝐫j matches Hj. For each rounded type in 𝐫j, we select an arbitrary unused original item within this type from the guessed critical-item set L. This selection is valid, because for each type, the total number of occurrences across 𝐫1,,𝐫m equals the guessed number in L. Then let Lj be the set of light items selected for 𝐫j.

It remains to show the existence of 𝒮 claimed in the Lemma. Given 𝒮=(I1,,Im), we replace all the critical items in Ij with the guessed set Lj for all j[m], while keeping other items unchanged. Let the resulting solution be 𝒮=(I1,,Im). The construction guarantees that Property iii is satisfied. By Lemma 18ii, Property ii holds.

Note that p(Ij)p~(Ij)=p~(Ij), since we construct Lj by selecting light items of the same rounded types as in 𝐫j. It remains to bound p~(Ij). For any light item l, we have p(l)p~(l)ε2 by Definition 15. Lemma 18i guarantees that p(Ij)233ε for all j[m]. Since each Ij contains at most 1/ε critical light items, we have p~(Ij)p(Ij)ε21ε234ε, which completes the proof.

4.6 Determining Non-Critical Items

It remains to determine the non-critical items (of 𝒮 in Lemma 19) in each knapsack. There are two kinds of non-critical items: the items in Ij with |Ij|=2 and the cheap items in Ij with |Ij|3.

4.6.1 Determining the items in 𝑰𝒋 with |𝑰𝒋|=𝟐

In solution 𝒮 of Lemma 19, we have p(Ij)234ε for all j[m]. Recall that the profit of each item does not exceed 236ε. Therefore, if |Ij|=2, each item has a profit at least (234ε)(236ε)>ε. We have the following simple observation.

Observation 20.

Items in Ij of 𝒮 in Lemma 19 with |Ij|=2 are expensive.

The following lemma determines the expensive items in all knapsacks.

Lemma 21.

Given (H1,,Hm) and (L1,,Lm), one can compute sets (Ej)j[m] in time O(m2.5) such that there exists a feasible solution 𝒮=(I1,,Im) satisfying

  1. (i)

    p(Ij)234ε for all j[m].

  2. (ii)

    For each j[m], the expensive items in Ij are exactly Ej.

Proof.

We first compute the sets (Ej)j[m]. Let E denote the set of all expensive items and let NE=Ij[m](HjLj) denote the set of non-critical expensive items. If Hj or Lj is non-empty, then let Ej=HjLj. It remains to determine Ej for knapsacks j with Hj=Lj=.

We construct an undirected graph G as follows. Each item in NE corresponds to a vertex, and we add an edge {u,v} iff

w(u)+w(v)1andp(u)+p(v)234ε. (10)

We then compute a maximum matching M in G, which can be done in O(|E||NE|)=O(m2.5) time [16]. Let n denote the number of knapsacks j with Hj=Lj=. We select arbitrary min{|M|,n} knapsacks j with Hj=Lj=, and set Ej to be the pair of items corresponding to an edge in M; for all other such knapsacks, we set Ej=. It remains to show the existence of the desired solution 𝒮.

Let 𝒮=(I1,,Im) be the solution guaranteed by Lemma 19, and let Z(𝒮)={j[m]:|Ij|=2}. For each jZ(𝒮), writing Ij={uj,vj}, Lemma 19 implies that p(uj)+p(vj)234ε and w(uj)+w(vj)1. By the definition of G, this means {uj,vj} is an edge of G. Moreover, these edges are pairwise vertex-disjoint (since the Ij’s are disjoint), and hence they form a matching of size |Z(𝒮)| in G. Therefore, a maximum matching M satisfies |M||Z(𝒮)|.

We construct the desired solution 𝒮=(I1,,Im) as follows. Given 𝒮=(I1,,Im), if Hj=Lj= and Ej, then let Ij=Ej; otherwise, let Ij=Ij.

We verify that 𝒮 satisfies Property i. If Ij=Ej, then by equation (10), p(Ej)234ε. Otherwise, Ij=Ij and by Lemma 19, p(Ij)234ε.

We verify that 𝒮 satisfies Property ii. If Ij=Ej, then the property holds trivially. Otherwise, either at least one of Hj and Lj is non-empty, or Ej=. For the former case, by Lemma 19, the expensive items in Ij are the critical items HjLj, which is exactly Ej by our construction. For the latter case, it implies that Hj=Lj=. Thus, the critical (i.e., expensive) items in Ij are empty, which is exactly Ej.

4.6.2 Determine the cheap items in 𝑰𝒋 with |𝑰𝒋|𝟑

Let C=Ij[m]Ej denote the set of cheap items. Let the variable xij{0,1} represent whether the cheap item i is packed in knapsack j. Relaxing xij to be fractional, we have the following LP.

maxts.t.p(Ej)+iCp(i)xijt,j=1,,mw(Ej)+iCw(i)xijB,j=1,,mj=1mxij=1,iC0xij1,iC,j=1,,m. (11)

Note that Lemma 21 guarantees a feasible solution to the above LP with objective value at least 234ε. Applying Lemma 22 below, we can obtain an integral feasible solution with objective value at least 234ε2maxiCp(i). Since items in C are cheap, this objective value is at least 236ε, which completes the proof of Theorem 1.

Lemma 22.

Given nonnegative p(i),w(i),tj,Bj and a fractional solution xijf to the following linear system:

i=1np(i)xijftj,j=1,,mi=1nw(i)xijfBj,j=1,,mj=1mxijf=1,i=1,,n0xijf1,i=1,,n,j=1,,m (12)

we can compute in polynomial time an integral solution xij to the following:

i=1np(i)xijtj2pmax,j=1,,mi=1nw(i)xijBj,j=1,,mj=1mxij=1,i=1,,nxij{0,1},i=1,,n,j=1,,m (13)

where pmax=maxip(i).

Proof.

(See the full version of this paper.)

5 An Algorithm for Arbitrary Capacities

See the full version of this paper.

6 Hardness Result

We prove Theorem 3 in this section. We will give a reduction from the restricted numerical 3-dimensional matching problem (RN3DM), which is known to be strongly NP-complete [27].

We first describe the numerical 3-dimensional matching problem (N3DM). Given are three multisets of integers U,V,W where |U|=|V|=|W|=n together with an integer t, the goal is to find a subset MU×V×W such that every element in UVW occurs in M exactly once, and for every (u,v,w)M, u+v+w=t.

The restricted numerical 3-dimensional matching problem further requires that V=W={1,2,,n} and U[O(n)]. The following is an equivalent statement.

Definition 23 (RN3DM).

Given a multiset U={u1,,un} of nonnegative integers and an integer t such that j=1nuj+n(n+1)=nt, does there exist two permutations v and w of {1,,n} such that

uj+v(j)+w(j)=t, for j=1,,n?

Now we are ready to prove Theorem 3.

Proof of Theorem 3.

Given an instance of RN3DM with U={u1,,un} and t, we construct an instance of BMKP as follows. There are 2n items and n knapsacks. Every item has a profit of 1. For i=1,2,,n, there are exactly two items of weight i. The capacity of knapsack j[n] is Bj=tuj.

We first show that if the answer to the given RN3DM instance is “yes”, then the constructed BMKP instance admits a feasible solution with objective value 2. This follows by observing that we can pack two items into each knapsack j, one of weight v(j) and one of weight w(j). The fact that v and w are permutations of [n] guarantees that we have packed exactly two items of weight i for every i=1,2,,n.

Next, we show that if the constructed BMKP instance admits a feasible solution of objective value 2, then the answer to the given RN3DM instance is “yes”. Since there are n knapsacks and 2n items, each of profit 1, it is clear that in this feasible solution all items are packed, and every knapsack contains exactly two items. Moreover, observe that the total weight of all items is exactly 2(1+2++n)=n(n+1)=ntj=1nuj=j=1nBj, thus the total weight of the two items in knapsack j is exactly Bj=tuj.

Now we construct the two permutations v and w for the RN3DM instance based on the assignment of items. Specifically, consider the weights of the two items in knapsack j. We will show that it is possible to set one weight as v(j) and the other weight as w(j) such that v and w are both permutations. As we showed above that the total weight of items in knapsack j is exactly Bj, v(j)+w(j)=tuj follows directly.

It remains to show which of the two item weights in knapsack j should be set to v(j) (and the other is w(j)) so that v and w are permutations. We present an algorithm for achieving this. For ease of description, we take a graphical view. We create a graph G=(Q,E) as follows. Each item is represented as a node, so there are in total 2n nodes. When we set the weight of an item as v(j) (or w(j)), we color the node corresponding to this item red (or blue). We may also abuse the notation by saying we color an item red or blue. The two items in the same knapsack are called partners. We create two types of edges: (i) an edge between the two nodes corresponding to partners, (ii) an edge between two nodes whose corresponding items have the same weight.

Consider graph G. The degree of every node is either 1 or 2. Consider an arbitrary node qQ of degree 1, and let (q,q) be the edge incident to it. Then the two items corresponding to q and q are in the same knapsack, and have the same weight. We color q red and q blue, and then remove the two nodes from graph G.

After removing all the degree 1 nodes, let G¯ be the residual graph, and G¯1,G¯2,,G¯ be its connected components. Since the degree of every node in each G¯j is exactly 2, G¯j is a cycle. Let the cycle be (q1,q2,,qk). We observe the following.

Observation 24.

k=|G¯j| is even for every j.

Proof.

Suppose, on the contrary, that k is odd. Without loss of generality, let q1,q2 be two items of the same weight, then q2,q3 are partners, and q3,q4 are two items of the same weight, etc. We get that qk1,qk are partners, and qk,q1 have the same weight. Then q1,q2,qk all have the same weight. Since there are at most 2 items of the same weight, we get k=2, which is a contradiction.

Since k is even, for each cycle (q1,q2,,qk), we color q1,q3,,qk1 red and q2,q4,,qk blue.

Now we have colored every node either red or blue; it remains to obtain the permutation v and w from this coloring. According to our coloring, every edge is between a red node and a blue node, which means: (i) Partners (items in the same knapsack) always have different colors. (ii) Items of the same weight always have different colors. Thus, the n red nodes correspond to n items on n knapsacks, and their weights are exactly 1,2,,n. Hence, define v(j) (or w(j)) as the weight of red (or blue) node in knapsack j, v(j) and w(j) are permutations.

The above argument shows that the answer to the given RN3DM instance is “yes” if and only if the constructed BMKP instance admits a feasible solution with objective value 2.

Observe that, for our constructed BMKP instance, the objective value is at most 2. Recall that the instance contains 2n items and n knapsacks, and every item has profit 1. If some knapsack contains at least three items, then the remaining n1 knapsacks together contain at most 2n3 items. By the pigeonhole principle, at least one knapsack contains at most one item, and thus the objective value is at most 1. Otherwise, every knapsack contains at most two items, and thus the objective value is at most 2. In either case, the objective value is at most 2.

Now suppose that BMKP admits a polynomial-time (12+ε)-approximation algorithm for some constant ε>0. Given an RN3DM instance, we construct the corresponding BMKP instance and run this algorithm. If the answer to the RN3DM instance is “yes”, then OPT=2 for the BMKP instance and the algorithm returns a solution of value at least (12+ε)2>1, which exactly computes the optimal solution. If the answer is “no”, then OPT=1 and the returned value is at most 1. Thus, the algorithm would allow us to decide RN3DM in polynomial time, completing the proof of Theorem 3.

7 Conclusion and Discussion

We studied the bottleneck multiple knapsack problem (BMKP) under both identical-capacity and arbitrary-capacity settings. For identical capacities, we presented a polynomial-time (23ε)-approximation algorithm, which nearly matches the known (23+ε) inapproximability bound [5]. For arbitrary capacities, we established a nearly tight guarantee at 12 by giving a (12ε)-approximation algorithm together with a (12+ε)-inapproximability result.

Several intriguing questions remain open. First, although the 23 approximation ratio is known to be tight for the bottleneck multiple subset sum problem with identical capacities, it remains unclear whether a 23-approximation is achievable when the knapsack capacities of the subset sum problem are arbitrary.

Our hardness result in Theorem 3 shows that, for arbitrary capacities, no (12+ε)-approximation algorithm exists for any constant ε>0, unless P=NP, even in the restricted case where all item profits are 1. This naturally raises the question of whether a 12-approximation can be achieved in this unit-profit setting.

Another interesting direction is to study intermediate models between identical and arbitrary capacities. In particular, it is open whether a (23ε)-approximation is achievable when the number of distinct knapsack capacities is bounded by a constant.

References

  • [1] Yossi Azar and Leah Epstein. Approximation schemes for covering and scheduling in related machines. In Proceedings of the 1st International Workshop on Approximation Algorithms for Combinatorial Optimization (APPROX), volume 1444, pages 39–47. Springer, 1998. doi:10.1007/BFb0053962.
  • [2] Nikhil Bansal and Maxim Sviridenko. The Santa Claus problem. In Proceedings of the 38th Annual ACM Symposium on Theory of Computing (STOC), pages 31–40. ACM, 2006. doi:10.1145/1132516.1132522.
  • [3] Ivona Bezáková and Varsha Dani. Allocating indivisible goods. ACM SIGecom Exchanges, 5(3):11–18, 2005. doi:10.1145/1120680.1120683.
  • [4] Arpita Biswas and Siddharth Barman. Fair division under cardinality constraints. In Proceedings of the 27th International Joint Conference on Artificial Intelligence (IJCAI), pages 91–97, 2018. doi:10.24963/ijcai.2018/13.
  • [5] Alberto Caprara, Hans Kellerer, and Ulrich Pferschy. The multiple subset sum problem. SIAM Journal on Optimization, 11(2):308–319, 2000. doi:10.1137/S1052623498348481.
  • [6] Alberto Caprara, Hans Kellerer, and Ulrich Pferschy. A PTAS for the multiple subset sum problem with different knapsack capacities. Information Processing Letters, 73(3-4):111–118, 2000. doi:10.1016/S0020-0190(00)00010-7.
  • [7] Alberto Caprara, Hans Kellerer, and Ulrich Pferschy. A 3/4-approximation algorithm for multiple subset sum. Journal of Heuristics, 9:99–111, 2003. doi:10.1023/A:1022584312032.
  • [8] Deeparnab Chakrabarty, Julia Chuzhoy, and Sanjeev Khanna. On allocating goods to maximize fairness. In Proceedings of the 50th Annual IEEE Symposium on Foundations of Computer Science (FOCS), pages 107–116, 2009. doi:10.1109/FOCS.2009.51.
  • [9] Chandra Chekuri and Sanjeev Khanna. A polynomial time approximation scheme for the multiple knapsack problem. SIAM Journal on Computing, 35(3):713–728, 2005. doi:10.1137/S0097539700382820.
  • [10] Wenceslas Fernandez de la Vega and George S. Lueker. Bin packing can be solved within 1+ ε in linear time. Combinatorica, 1(4):349–355, 1981. doi:10.1007/BF02579456.
  • [11] Bin Deng and Weidong Li. The budgeted maximin share allocation problem. Optimization Letters, 19(5):955–968, 2025. doi:10.1007/s11590-024-02145-6.
  • [12] Leah Epstein and Jirí Sgall. Approximation schemes for scheduling on uniformly related and identical parallel machines. Algorithmica, 39:43–57, 2004. doi:10.1007/s00453-003-1077-7.
  • [13] Laurent Gourvès and Jérôme Monnot. Approximate maximin share allocations in matroids. In Proceedings of the International Conference on Algorithms and Complexity (CIAC), volume 10236, pages 310–321. Springer, 2017. doi:10.1007/978-3-319-57586-5_26.
  • [14] Laurent Gourvès and Jérôme Monnot. On maximin share allocations in matroids. Theoretical Computer Science, 754:50–64, 2019. doi:10.1016/j.tcs.2018.05.018.
  • [15] Dorit S. Hochbaum and David B. Shmoys. Using dual approximation algorithms for scheduling problems theoretical and practical results. Journal of the ACM (JACM), 34(1):144–162, 1987. doi:10.1145/7531.7535.
  • [16] John E. Hopcroft and Richard M. Karp. An n5/2 algorithm for maximum matchings in bipartite graphs. SIAM Journal on Computing, 2(4):225–231, 1973. doi:10.1137/0202019.
  • [17] Halvard Hummel. Maximin shares in hereditary set systems. ACM Transactions on Economics and Computation, 13(3):12:1–12:33, 2025. doi:10.1145/3727149.
  • [18] Halvard Hummel and Magnus Lie Hetland. Maximin shares under cardinality constraints. In Proceedings of the European Conference on Multi-Agent Systems (EUMAS), volume 13442, pages 188–206. Springer, Springer, 2022. doi:10.1007/978-3-031-20614-6_11.
  • [19] Klaus Jansen. Parameterized approximation scheme for the multiple knapsack problem. SIAM Journal on Computing, 39(4):1392–1412, 2009. doi:10.1137/080731207.
  • [20] Klaus Jansen. A fast approximation scheme for the multiple knapsack problem. In Proceedings of the 38th International Conference on Current Trends in Theory and Practice of Computer Science (SOFSEM), volume 7147, pages 313–324. Springer, 2012. doi:10.1007/978-3-642-27660-6_26.
  • [21] Hans Kellerer. A polynomial time approximation scheme for the multiple knapsack problem. In Proceedings of the International Workshop on Randomization and Approximation Techniques in Computer Science (APPROX), volume 1671, pages 51–62. Springer, 1999. doi:10.1007/978-3-540-48413-4_6.
  • [22] Sheng-Yen Ko, Ho-Lin Chen, Siu-Wing Cheng, Wing-Kai Hon, and Chung-Shou Liao. Polynomial-time combinatorial algorithm for general max–min fair allocation. Algorithmica, 86(2):485–504, 2024. doi:10.1007/s00453-023-01105-3.
  • [23] Jan Karel Lenstra, David B. Shmoys, and Éva Tardos. Approximation algorithms for scheduling unrelated parallel machines. Mathematical Programming, 46:259–271, 1990. doi:10.1007/BF01585745.
  • [24] Barna Saha and Aravind Srinivasan. A new approximation technique for resource-allocation problems. Random Structures & Algorithms, 52(4):680–715, 2018. doi:10.1002/rsa.20756.
  • [25] David P. Williamson and David B. Shmoys. The design of approximation algorithms. Cambridge University Press, 2011. URL: http://www.cambridge.org/de/knowledge/isbn/item5759340/?site_locale=de_DE.
  • [26] Gerhard J. Woeginger. A polynomial-time approximation scheme for maximizing the minimum machine completion time. Operations Research Letters, 20(4):149–154, 1997. doi:10.1016/S0167-6377(96)00055-7.
  • [27] Wenci Yu, Han Hoogeveen, and Jan Karel Lenstra. Minimizing makespan in a two-machine flow shop with delays and unit-time operations is np-hard. Journal of Scheduling, 7(5):333–348, 2004. doi:10.1023/B:JOSH.0000036858.59787.c2.