Abstract 1 Introduction 2 Preliminaries 3 A reduction from 2-CSP to VK with Varying Dimensions 4 Proofs of the Main Lower Bound References

On the PTAS Complexity of Multidimensional Knapsack

Ilan Doron-Arad ORCID MIT, Cambridge, MA, USA Ariel Kulik ORCID Ben-Gurion University of the Negev, Be’er-Sheva, Israel Pasin Manurangsi ORCID Google Research, Bangkok, Thailand
Abstract

We study the d-dimensional knapsack problem. We are given a set of items, each with a d-dimensional cost vector and a profit, along with a d-dimensional budget vector. The goal is to select a set of items that do not exceed the budget in all dimensions and maximize the total profit. A polynomial-time approximation scheme (PTAS) with running time nΘ(d/ε) has long been known for this problem, where ε is the error parameter and n is the encoding size. Despite decades of active research, the best running time of a PTAS has remained O(nd/εd). Unfortunately, existing lower bounds only cover the special case with two dimensions d=2, and do not answer whether there is a no(dε)-time PTAS for larger values of d.

In this work, we show that the running times of the best-known PTAS cannot be improved up to a polylogarithmic factor assuming the Exponential Time Hypothesis (ETH). Our techniques are based on a robust reduction from 2-CSP, which embeds 2-CSP constraints into a desired number of dimensions. Then, using a recent result of [Bafna Karthik and Minzer, STOC’25], we succeed in exhibiting tight trade-off between d and ε for all regimes of the parameters assuming d is sufficiently large. Informally, our result also shows that under ETH, for any function f there is no f(dε)no~(dε)-time (1ε)-approximation for d-dimensional knapsack, where n is the number of items and o~ hides polylogarithmic factors in dε.

Keywords and phrases:
d-dimensional Knapsack, Multidimensional Knapsack, PTAS, CSP
Copyright and License:
[Uncaptioned image] © Ilan Doron-Arad, Ariel Kulik, and Pasin Manurangsi; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Approximation algorithms analysis
; Theory of computation Problems, reductions and completeness ; Theory of computation Parameterized complexity and exact algorithms
Related Version:
Previous Version: https://arxiv.org/abs/2407.10146 [17]
Acknowledgements:
Pasin is grateful to Karthik C. S. for insightful discussions on [7].
Editor:
Shubhangi Saraf

1 Introduction

In the 0/1-Knapsack problem, we are given a set of items, each with a cost and a profit, together with a budget. The goal is to select a subset of items whose total cost does not exceed the budget while maximizing the total profit. Knapsack is one of the most studied problems in combinatorial optimization. Indeed, a polynomial-time approximation scheme (PTAS) for the problem [28, 48] was among the first PTASes to have ever been discovered in the field, and is often the first PTAS taught in computer science courses (see e.g. [50, Section 3.1] and [13, Chapter 35.5]). While such a PTAS has been known to exist since the 70s [28, 48], the problem remains an active topic of research to this day [23, 37, 32, 33, 46, 9, 27, 16, 42, 12], with the best known (fully) PTAS that gives a (1ε)-approximation in time O~(n+1/ε2) [42, 12]. This running time is essentially tight assuming (min,+)-convolution cannot be solved in truly sub-quadratic time [15, 36].

Numerous generalizations of Knapsack have been considered over the years. One of the most natural and well-studied versions is the so-called d-dimensional knapsack problem. Here each cost is a d-dimensional vector. The problem remains the same, except that the total cost must not exceed the budget in every coordinate. The problem is defined more formally below.

Definition 1 (d-Dimensional Knapsack).
Input:

An instance =(I,p,c,B) consisting of:

  • a set of items I,

  • a profit function p:I,

  • a d-dimensional cost function c:Id,

  • a d-dimensional budget Bd.

Solution:

A subset SI such that for all j[d] it holds that cj(S):=iScj(i)Bj.

Objective:

Find a solution of maximum profit, where the profit of S is p(S):=iSp(i).

Multidimensional (vector) knapsack is the family of d-dimensional knapsack problems for all d1. The study of d-dimensional knapsack dates back to the 50s [40, 43, 49] and it has been used to model problems arising in many contexts, including resource allocation, delivery system, budgeting, investment, and voting (see the survey [18] for a more comprehensive review). Given its importance, there have been several algorithms and hardness results devised for the problem over the years. We summarize the main theoretical results below. We note that many heuristics for the problems have been proposed (e.g., [2, 5, 6, 31, 38, 47, 3, 51, 45]), although these do not provide theoretical guarantees and thus will be omitted from the subsequent discussions.

On the hardness front, the decision version of the Knapsack problem (d=1) generalizes the Subset Sum problem, which is one of Karp’s 21 NP-complete problems [29]. The d=1 case admits a fully polynomial time approximation scheme (FPTAS), i.e., a PTAS that runs in time (n/ε)O(1). In contrast, for d=2, it has also long been known that no FPTAS exists unless P = NP [34, 41]. This has more recently been strengthened in [35], who show that, even when d=2, the problem does not admit an efficient PTAS (EPTAS), i.e., one that runs in time f(ϵ)nO(1) time, assuming W[1]FPT. This in turn was improved by [26] to rule out any PTAS that runs in time no(1/ε) even for d=2, assuming ETH. Recently, [20] established a lower bound for exact algorithms for the d-Dimensional Knapsack problem, based on a hypothesis concerning multi-dimensional (max,+) convolutions.

Meanwhile, on the algorithmic front, a PTAS for d-dimensional knapsack with running time nO(d/ε) was first described by Chandra et al. [10]111Strictly speaking, Chandra et al.’s algorithm is for the unbounded version where each item can be picked multiple times. However, it can be extended to the bounded case too [44]., not long after a PTAS for Knapsack was discovered in [28, 48]. The d-dimensional knapsack has been a challenging research topic ever since: over the past nearly 50 years, all improvements on Chandra et al.’s PTAS come just in the constant in the exponent [19, 8], with the best running time known being O(nd/εd) [8]. Unfortunately, this barrier cannot be explained by aforementioned existing lower bounds. For example, they do not rule out an nO(d+1/ε)-time PTAS. This brings us to the main question of this paper:

Is there a PTAS for d-dimensional knapsack with running time no(d/ε)?

1.1 Our Results

Our main result is the resolution of the above question in the negative, up to a polylogarithmic factor in the exponent. Unlike previous lower bounds [35, 26] which focused on two dimensions d=2, or a non-parametrized number of dimensions [11], our lower bound gives a nearly tight trade-off between d and 1ε, for all regimes of dε. In the following results, n denotes the encoding size of the instance.

Theorem 2.

Assuming ETH, there are constants A,d0, such that for any dd0 and any ε(0,1) the following holds. There is no (1ε)-approximation algorithm for d-dimensional knapsack that runs in time O(nr/logAr), where n is the size of the input and r=dε.

For example, Theorem 2 implies that there is no algorithm which for every sufficiently large d and any ε<1 returns a (1ε)-approximate solution for a d-dimensional knapsack instance in time nO(d+1ε), or nO(d1δε), or even nO((d+1ε)2δ) for any δ(0,1) (by setting d=1ε). Additionally, as the lower bound in Theorem 2 considers specific values of d and ε, the result also rules out algorithms with running time of the form f(d,ε)nr/logAr for an arbitrary function f.

1.2 Technical Overview

Existing lower bounds for d-dimensional knapsack can be crudely partitioned into three categories.

  • First, lower bounds for d=2 dimensions [34, 41, 35, 26]. The basic technique in this setting is to reduce Subset Sum, known to be computationally hard in various settings (e.g., [14, 1]), to 2-dimensional knapsack. In broad terms, each number in the Subset Sum instance corresponds to an item. One dimension imposes an upper bound by the target value on the original sum, while the second dimension guarantees that the original sum is higher than the target value using a clever cost construction. However, these constructions are only useful for d=2 using an extremely small ε, and cannot be used to reveal the asymptotic hardness of d-dimensional knapsack for larger values of d.

  • The second category of lower bounds considers the setting where d is arbitrarily large, as can be seen in [11]. The lower bound in [11] relies upon a reduction from independent set which uses a fairly high number of dimensions. In particular, the result in [11] rules out the existence of a constant approximation for multidimensional knapsack, where the number of dimensions is part of the input. However, it is unclear whether the approach in [11] can be adapted to yield lower bounds for fixed d and ε.

  • The third type of lower bounds deals with the parameterized complexity of the problem. In [25] the authors show that multidimensional subset sum does not have a parameterized algorithm when the parameter is the number of dimensions d, even if the items’ costs are encoded in unary. The result is based on a reduction from the 2-constraint satisfaction problem (2-CSP, see definition in Section 2), which embeds each edges of the 2-CSP instance into two dimensions.

    The core ideas of the reduction in [25] can be easily extended to multidimensional knapsack. Combined with recent hardness-of-approximation results for constraint satisfaction problems [4, 21, 39, 22], this extension can be used to establish lower bounds on the running time of any (1ε)-approximation algorithm for multidimensional knapsack with fixed ε>0. However, such results are limited for a fixed ε>0, and will not lead to the result in Theorem 2.

We build upon the existing reduction form 2-CSP [25], and extend it to attain a lower bound which works for every sufficiently large d and every ε. The core novelty of our reduction lies in a technique which embeds multiple constraints of the 2-CSP instance into a constant number of dimensions. To do so, on certain dimensions, the weights of the items are viewed as multidigit numbers on the basis of a large number 𝒬, and each constraint is mapped into a specific digit.

Crucially to attain hardness of approximation results, our reduction is approximation preserving. However, the quality of the approximation preservation depends linearly on the used ratio between constraints and variables in the CSP instance. Combined with the recent hardness of approximation results for 2-CSP by Bafna Karthik and Minzer [4], this leads to a lower bound which works for every sufficiently large fixed value of d and any ε.

Organization

We start with some preliminary definitions in Section 2. Then, in Section 3 we give our reduction from 2-CSP to VK and in Section 4 we prove our main lower bound for VK. An older version of this paper, with additional results, is given in [17].

2 Preliminaries

Basic definitions

For an instance of a maximization problem Π, let OPT() be the optimum value of and let || denote the encoding size of . For a set S, a function f:S, and a subset XS we use the abbreviation f(X)=xXf(x). For some α(0,1), an α-approximate solution for is a solution for of value at least αOPT(). For all t let [t]={1,2,,t}. Throughout this paper, let log be the logarithm with the natural logarithm base.

𝒅-dimensional knapsack

For short, for any d1 we use d-VK to denote d-dimensional (vector) knapsack (see the formal definition of d-VK in Definition 1). We also use VK to denote the collection of d-VK instances over all d1. For some d and a d-VK instance =(I,p,c,B), let W()=maxj[d]Bj be the maximum budget of the instance. For any d and d~[d], we may assume w.l.o.g. that every d~-dimensional knapsack instance is also a d-dimensional knapsack instance by adding extra dd~ dimensions with zero budgets and zero costs for all items.

Graph theory definitions

For every graph G let V(G) and E(G) denote the set of vertices and edges of G, respectively. We assume that all graphs G considered in this paper are simple directed graphs with no anti-symmetric edges. For a vertex vV(G) we use AdjG(v) to denote the set of adjacent edges to v in G. For some Δ, a graph G is Δ-bounded degree if the degree of each vertex in G is at most Δ.

3-SAT and ETH

Our lower bounds are conditioned on ETH. Before we state these, recall the standard 3-SAT problem.

Definition 3 (3-SAT).
  • Input: ϕ=(V,C), where V is a set of variables and C is a set of disjunction clauses of three variables or negation of variables in V.

  • Assignment: A function s:V{0,1}.

  • Objective: Find an assignment satisfying a maximum number of clauses. Let SAT(ϕ) be the maximum number of clauses in C satisfied by a single assignment to ϕ.

Next, we state ETH [24].

Conjecture 4 (Exponential-Time Hypothesis (ETH)).

There is a constant ξ>0 such that there is no algorithm that given a 3-SAT formula ϕ on n variables and m clauses can decide if SAT(ϕ)=True in time O(2ξn).

2-CSP

We prove the hardness of VK via a reduction from 2-CSP, defined formally below.

Definition 5 (2-CSP).
  • Input: Π=(G,Σ,{πe}eE(G)) consisting of

    • A directed constraint graph G.

    • A finite alphabet set Σ. Without the loss of generality, we always assume that Σ={1,,n} for some n.

    • For each edge e=(u,v)E(G), a constraint πe:Σ×Σ{0,1}.

  • Satisfied edges: For e=(u,v)E(G), we say that that e is satisfied by (σu,σv)Σ×Σ if and only if πe(σu,σv)=1.

  • A solution: A function φ:V(G)Σ.

  • Value: The value of a solution φ:V(G)Σ is defined as the relative number of satisfied edges:

    val(φ):=|{e=(u,v)E(G)πe(φ(u),φ(v))=1}||E|
  • Objective: Find a solution with maximum value.

For a 2-CSP instance Π, we define by val(Π) the value of an optimal solution for Π. In the proof of our main result, we use a recent hardness of approximation result for 2-CSPs [4]. In the following, we state a slightly stronger version of the result from [4]. We have verified with the authors that this stronger formulation does indeed follow from their work [30].

Theorem 6 ([4]).

Assuming ETH, there is a constant k0 such that the following holds. For every constant ξ>0 there exist C>0 and Δ such that for every fixed kk0 there is no algorithm running in time O(nk/logCk) that takes as input a 2-CSP instance Π on a constant degree Δ bipartite regular graph with k vertices over an alphabet of size n and can distinguish between the following two cases:

  • (Completeness) val(Π)=1.

  • (Soundness) val(Π)<ξ.

We remark that a recent work of [22] yields a slightly worse running time, but allowing for sub-constant soundness compared to Theorem 6.

3 A reduction from 2-CSP to VK with Varying Dimensions

In this section, we give our main reduction from 2-CSP to VK. As we will see in the next section, this implies our main result (Theorem 2). Besides the 2-CSP instance, the reduction also considers an additional integer parameter F in addition to the 2-CSP instance Π. The reduction embeds multiple edges of the 2-CSP instance into a constant number of dimensions. The parameter F determines how many edges are embedded within a constant number of dimensions. Increasing F reduces the number of dimensions of the resulting instance but also weakens the soundness guarantees of the reduction. Thus, F introduces a trade-off between the number of dimensions and the approximation ratio.

Lemma 7 (Dimension Embedding Reduction).

There is a reduction 2-CSP VK that, given a 2-CSP instance Π whose constraint graph G=(V,E) is a Δ-bounded degree graph and F[1,|E|], returns in time O(|Π|5) an instance (Π,F)=(I,p,c,B) of d-VK such that the following holds.

  1. 1.

    The number of dimensions is d=4|E|F.

  2. 2.

    |(Π)|=O(|Π|5).

  3. 3.

    (Completeness) If val(Π)=1, then there is a solution for (Π,F) with profit 8|E|.

  4. 4.

    (Soundness) For every q, if there is a solution for (Π,F) of profit at least
    8|E|q, then val(Π)12ΔFq|E|.

Before the formal construction, we provide a high level intuitive description. For this entire section, let Π=(G,Σ,{πe}eE) be a 2-CSP instance, where G is of bounded degree Δ for some fixed constant Δ, and let F[1,|E|]. In addition, let n such that Σ={1,,n}. In the following, we describe a reduction that creates the reduced VK instance (Π,F)=(I,p,c,B).

The construction of the reduced instance can be intuitively summarized as follows. The instance has two types of items. The first type contains all pairs of a vertex in G and an assignment for the vertex, and the second type contains all triplets of an edge and a feasible assignment for both of its endpoints. The profits, costs, and budgets are defined so that a feasible solution SI for this VK instance with a sufficiently high profit satisfy the following: for most vertices vV and for all of their adjacent edges e=(u,v)E it holds that (i) exactly one item (v,σv) is selected to S corresponding to an assignment of σv to the vertex v, and (ii) exactly one item of the form (e,σu,σv) is selected to S, preserving the assignment of σv to v. From here, it is easy to construct an assignment for the original 2-CSP instance with relatively high value.

The non-trivial part is to enforce the above using the definition of profits, costs, and budgets. Recall that the reduction receives the parameter F which controls the number of dimensions. We define four sub-constraints for each edge eE and call D the set of sub-constraints over all edges. We define a partition D1,,Dr of D into r constraints, with up to 4F sub-constraints in each constraint (with possibly fewer sub-constraints in the last constraint). For each [r], we make an embedding of D into only two dimensions, thus having overall d=2r dimensions of the VK instance.

The construction of the items’ costs consists of two levels. The first level associates a weight with each item, where the weight has a dimension for every sub-constraint. The weight function ensures that if a set of items has a weight of exactly m=3n in every dimension, then the set of items represents a solution for the 2-CSP instance of value 1. On its own, this level is similar to the reduction in [25]. The second level generates the actual costs. Here, each constraint D (a subset of sub-constraints) is associated with two dimensions. The first dimension encodes the weights of the sub-constraints as a |D| digit number on the basis of a large number 𝒬, where each sub-constraint in D is assigned to a digit. The second dimension is used to enforce the property that if a solution contains multiple items associated with the sub-constraints in D, then the weight associated with each sub-constraint must be exactly m=3n.

The Reduction from 2-CSP to VK

We proceed with the formal description of (Π,F). As the reduction is relatively long, we describe each parameter (the set of items, profits, costs, and budgets) in separate paragraphs.

The Items

The set of items contains all pairs of a vertex in G and a possible assignment to the vertex, as well as all edges in G and a satisfying assignment to the endpoints of the edges. Formally, let I=IVIE be the set of items, where

IV=V×Σ

and

IE={(e,σ1,σ2)E×Σ×Σπe(σ1,σ2)=1}.

For any i=(v,σ)IV and i=(e,σ1,σ2)IE, with a slight abuse of notation, we use the unified notation for the first entry of the item, corresponding for a vertex or an edge, respectively, by

μ(i)=v,μ(i)=e.

Before describing the remaining components of the reduction, we use the following definition of constraints.

Constraints

Our reduction associates four sub-constraints with every edge eE of the 2-CSP instance, and bundles 4F sub-constraints into a single constraint. More formally, a sub-constraint is a tuple χ=(e,j,s)E×{1,2}×{1,2}, where e=(u1,u2) is the edge of the sub-constraint, j selects uj as the endpoint of e associated with the sub-constraint χ, and s can be viewed as a sign selector. In our reduction, a constraint is a subset of sub-constraints.

Let E1,,Er be an arbitrary partition of E such that |E|=F for all [r1] and |Er|F; thus, r=|E|F and |E|F for all [r]. Define D=E×{1,2}×{1,2} as the -th constraint. We also define D=E×{1,2}×{1,2} as the set of all sub-constraints. In particular, D1,,Dr is a partition of D.

We define the following auxiliary parameter – the number of sub-constraints in which a vertex or an edge participates within a constraint. This parameter relates to both the profits and costs of the items. For all [r] and vV define

#sub(,v)=2|AdjG(v)E|

and for every eE define

#sub(,e)={4, if eE,0, else .

Intuitively, the values #sub(,v) and #sub(,e) can be viewed as the number of sub-constraints in D in which v and e participate. An illustration of the above is given in Figure 1.

Figure 1: An illustration of two sub-constraints (e,1,s),(e,2,s) (on the left), and three items i1,i2,i3 on the right. The edges in the figure between a sub-constraint and an item i{i1,i2,i3} indicate that μ(i) participates in the sub-constraint.

Profits

Define the profits p:I by p((v,σ))=2deg(v) for every (v,σ)IV and p((e,j,s))=4 for every (e,j,s)IE.

Lemma 8.

For every SI and [r], we have p(S)=[r]iS#sub(,μ(i)).

Proof.

It holds that

p(S)=iSp(i)=(v,σ)SIV2deg(v)+(e,j,s)SIE4=[r](v,σ)SIV2|AdjG(v)E|+[r](e,j,s)SIE s.t. eE4=[r](v,σ)SIV#sub(,v)+[r](e,j,s)SIE s.t. eE#sub(,e)=[r]iS#sub(,μ(i))

The second equality holds since for every eE there is exactly one [r] such that eE. Next, we define the costs and budgets of the reduced VK instance. As a building block, we use the following definition of a |D|-dimensional weight function. Informally, each dimension of the weight function corresponds to a sub-constraint in D, and can be interpreted as the cost of an item on the specific sub-constraint.

Weights

Let m=3n. Define the weight function w:ID such that for every χ=(e,j,s)E×{1,2}×{1,2}=D, where e=(u1,u2), define the χ-dimension wχ as follows.

  • For every (v,σ)IV define

    wχ((v,σ))={0, if vuj,σ, if v=uj and s=1mσ if v=uj and s=2. (1)
  • For every i=(e,σ1,σ2)IE define

    wχ(i)={0, if ee,σj, if e=e and s=2mσj if e=e and s=1. (2)

Notice that the weight of an item (v,σ)IV in wχ equals to σ if v is the endpoint of e associated with χ and s=1; on the other hand, for s=2 the weight the item receives is the complement: mσ, considering m as a large number, strictly larger than any σΣ (recall that Σ={1,,n} and m=3n). The weight of an item (e,σ1,σ2)IE is defined reciprocally to the above, using σj if s=2, and the complement mσj if s=1. From here, we get the following result.

Lemma 9.

Let φ:VΣ such that val(φ)=1, and let

S={(v,φ(v))|vV}{(e,φ(u),φ(v))e=(u,v)E}.

Then, for every χD it holds that wχ(S)=m.

Proof.

Note that SI since for every e=(u,v)E it holds that πe(φ(u),φ(v))=1 as val(φ)=1. For any χ=((u1,u2),j,s)D, we have

wχ(S)=wχ(uj,φ(uj))+wχ((u1,u2),φ(u1),φ(u2))={φ(uj)+mφ(uj)s=1mφ(uj)+φ(uj)s=2=m.

Thus, it holds that wχ(S)=m for every χD.

Additional Parameters for the Costs and Budgets

Define a sufficiently large parameter as

𝒬=3F2m(|V|+|E|)|Σ|2.

Recall that |Π| is the encoding size of the 2-CSP instance Π. In addition, define M=𝒬4F, where the reason for the selection of these parameters becomes clear in the proofs later on. The following observation holds since m,F,|V|,|E|,|Σ| are bounded by |Π|.

Observation 10.

𝒬6|Π|6 and M(6|Π|)24F.

We proceed to define the costs and budgets of the reduced VK instance.

Costs

The reduced instance will have d=2r dimensions and without the loss of generality, the dimensions correspond to the set [r]×{1,2}, i.e., a pair of dimensions for each constraint D. We define the cost function c:I[r]×{1,2} as follows. For every [r], let ord:D[|D|] be an arbitrary bijection, that will be used to order the sub-constraints in each constraint arbitrarily into disjoint bits in the costs (and budgets). Let iI and for (,t)[r]×{1,2} define

c(,t)(i)={χDwχ(i)𝒬ord(χ), if t=1,M#sub(,μ(i))χDwχ(i)𝒬ord(χ), if t=2.

Observe that #sub(,μ(i))={χD|wχ(i)>0}, which implies that the costs in dimensions (,2) are non-negative. For each [r], and t=1 the cost c(,t)(i) encodes the weights wχ(i) of all the sub-constraints χD. The encoding simply views the cost as an |D|-digit number on the basis of 𝒬, where the sub-constraint χD is assigned to the ord(χ)-digit. The costs c(,t)(i) for t=2 are used as a complement to the costs in the t=1 dimension. The two dimensions (,1) and (,2) are later used together to ensure properties of high profit solutions. We give an illustration of the costs in Figure 2.

The next observation will be helpful throughout this section.

Observation 11.

For any SI and [r], we have

  1. (i)

    c,1(S)=χDwχ(S)𝒬ord(χ).

  2. (ii)

    c,2(S)=MiS#sub(,μ(i))χDwχ(S)𝒬ord(χ).

Budget

We define the d-dimensional budget B[r]×{1,2} for every dimension (,t)[r]×{1,2} by

B,t={χDm𝒬ord(χ), if t=1,8M|E|χDm𝒬ord(χ) if t=2.
Figure 2: A partial illustration of the cost function in the reduction. The figure shows the cost of item i=(v,σ)IV in dimension (,1) for some [r]. The sub-constraints in the constraint D are D={χ1,χ2,χ3,χ4} where χ1=(e,j=2,s=2), j3=(e,j=2,s=1), e=(u,v), and χ2,χ4 are sub-constraints corresponding to edges not adjacent to v. Thus, #sub(,v)=2. The sub-constraints are ordered by χ1,χ2,χ3,χ4 so that ord(χ1)=1, ord(χ2)=2, etc. The cost of i in dimension (,1) is wχ1(i)+wχ3(i)𝒬3. Considering this cost as a base-𝒬 number, the first digit is mσ and the third digit is σ. This is illustrated as the gray area in the figure, depicting the 4-digit number in base-𝒬.

This completes the definition of the reduced instance (Π,F). To simplify the presentation, when Π,F are clear from the context, we may discard Π,F from the notations.

Clearly, given a 2-CSP instance Π with a constraint graph G and F[1,|E|], the instance (Π,F) can be constructed in time |Π|O(1). Next, we prove some basic properties of the reduction.

Lemma 12.

For any 2-CSP instance Π=(G,Σ,{πe}eE) and F[1,|E|] the following holds.

  1. 1.

    d=4|E|F.

  2. 2.

    |(Π,F)|O(|Π|5).

Proof.

The first property clearly holds as a simple observation from the construction of the reduced instance. For the second property of the lemma, note that the largest number in the costs/profits/budgets of the instance (Π,F), i.e., W((Π,F)), is bounded by 8M|E|. In addition, from Observation 10 it holds that M(6|Π|)24F. Thus,

W((Π,F))8M|E|8M|Π|8(6|Π|)24F|Π|(48|Π|)25F

Therefore, the reduced instance (Π,F) can be encoded in space

O(|I|dlogW((Π,F)))=O((|V||Σ|+|E||Σ|2)|E|FFlog|Π|) O(|Π|5),

This shows the second property of the lemma.

We also use the following auxiliary result.

Lemma 13.

The following properties hold:

  • For every [r]: aVE#sub(,a)=8|E|

  • [r]aVE#sub(,a)=8|E|

Proof.

For a boolean valued expression A, define 𝟙A=1 if A is true and 𝟙A=0 if A is false. For the first property of the lemma, for all [r] it holds that

aVE#sub(,a)= vV#sub(,v)+eE#sub(,e)
= vV2|AdjG(v)E|+eE4𝟙eE
= eE8𝟙eE
= 8|E|.

Since E1,,Er is a partition of E, the second property follows from the first property.

We give below the completeness and soundness of the reduction. We start with the former, which is (relatively) straightforward.

Lemma 14 (Completeness).

For any 2-CSP instance Π=(G,Σ,{πe}eE) and F[1,|E|], if there is a solution φ:VΣ for Π such that val(φ)=1, then there is a solution for (Π,F) of profit 8|E|.

Proof.

Let φ:VΣ be a solution for Π satisfying that for every e=(u,v)E it holds that πe(φ(u),φ(v))=1. We use φ to define a solution for the VK instance (Π,F) as follows. Define

S={(v,φ(v))|vV}{(e,φ(u),φ(v))e=(u,v)E}.

Note that for every vV it holds that (v,φ(v))IV. In addition, for every e=(u,v)E it holds that πe(φ(u),φ(v))=1 by the definition of φ; thus, (e,φ(u),φ(v))IE. We conclude that SI and is therefore well-defined. From Lemma 8 and the second item of Lemma 13, the profit is equal to

p(S)=[r]aVE#sub(,a)=8|E|.

To conclude, it remains to prove that S is a solution for (Π,F); i.e., that all budget constraints are satisfied. To see this, first notice that for any χ=(u1,u2,j,s)D, by Lemma 9 we have

wχ(S)=m χD. (3)

Let (,t)[r]×{1,2} be a budget constraint. Consider the two cases depending on t:

  • t=1. In this case, (3) and the first item of Observation 11 yield

    c(,t)(S)=χDwχ(S)𝒬ord(χ)=χDm𝒬ord(χ)=B,t.
  • t=2. In this case, the first item of Observation 11, we have

    c(,t)(S)= MiS#sub(,μ(i))χDwχ(S)𝒬ord(χ)
    = MiS#sub(,μ(i))χDm𝒬ord(χ)
    = MaVE#sub(,a)χDm𝒬ord(χ)
    = 8M|E|χDm𝒬ord(χ)
    = B,t.

    The second equality uses (3). The fourth equality uses the fact that for every vV and for every eE there is exactly one item in S in which v and e form the first coordinate.

Thus, S is a feasible solution for (Π,F) and this completes the proof.

For the soundness, we prove that given a solution to the reduced instance (Π,F), we can construct a solution for Π with roughly the same value/profit. Before that, we give a couple of useful properties over the weights w of any solution of (Π,F):

Lemma 15.

Let S be any solution for (Π,F). Then, for any [r], the following holds:

  1. (i)

    iS#sub(,μ(i))8|E|.

  2. (ii)

    If iS#sub(,μ(i))=8|E|, then wχ(S)=m for all χD.

To prove this, we use the following fact that an integer can be uniquely represented in base-N.

Observation 16.

Let N and x1,,xn,A{0,,N1} be such that i[n]xiNi=i[n]ANi. Then, for all i[n] it holds that xi=A.

Proof of Lemma 15.

Since S is a solution for (Π,F),

M8|E|=B,1+B,2c,1(S)+c,2(S)=MiS#sub(,μ(i)), (4)

where the last equality follows from the two items of Observation 11. Thus, Item i of the lemma holds by diving the two sides of the inequality by M>0.

To prove Item ii of the lemma, note that for (4) to be an equality rather than just an inequality, we must have B,1=c,1(S), since B,1c,1(S) and B,2c,2(S) (recall that S is a solution). Therefore,

χDm𝒬ord(χ)=B,1=c,1(S)=χDwχ(S)𝒬ord(χ). (5)

Observe that wj(S)|I|m<𝒬 due to our choice of the parameters m and 𝒬. From this, (5), and Observation 16, we can conclude that wχ(S)=m for all χD as required.

Using Lemma 15, we can give the second direction of the reduction.

Lemma 17 (Soundness).

For any 2-CSP instance Π, F[1,|E|], and q, if there is a solution for (Π,F) of profit at least 8|E|q, then there is a solution φ for Π such that val(φ)12ΔqF|E|.

The soundness proof goes, in high level, as follows. Given a solution S for (Π,F) with relatively high profit, we define the set of tight constraints of S as all [r] satisfying iS#sub(,μ(i))=8|E|. We denote by V the set of vertices vV whose all of their adjacent edges belong to a set E such that is tight. We show that every vV induce the following property: There is exactly one (v,σv)S, and for every eAdj(v) there is exactly one (e,σ1,σ2)S, such that σj=σv where e=(u1,u2), j{1,2}, and v=uj. Therefore, we can define an assignment φ by setting φ(v)=σv for vertices vV, and define the assignment of other vertices vVV arbitrarily. Finally, we can easily show that every constraint (u,v)V×V of the CSP instance Π is satisfied by φ immediately by the definition of IE. Since S has a relatively high profit, it follows that |V| is large implying that most of the constraints are tight and therefore we have constructed an assignment for Π with a relatively high profit.

Proof.

Let q such that there is a solution S for (Π,F) of profit at least 8|E|q. For every eE, let (e)[r] be the unique index satisfying that e belongs to E(e). In addition, let

T={[r]|iS#sub(,μ(i))=8|E|}

be the set of tight constraints of S. Define

V={vV|eAdjG(v):(e)T} (6)

as the set of vertices satisfying that all of their adjacent edges belong to tight constraints. The set V satisfies the following crucial property.

Claim 18.

For every vV there is exactly one σvΣ such that (v,σv)S. Moreover, for every e=(u1,u2)AdjG(v) there is exactly one (σ1,σ2)Σ2 such that (e,σ1,σ2)S and σj=σv, where j{1,2} satisfies v=uj.

Proof.

By (6), it holds that (e) must be tight for every eAdjG(v), that is,

iS#sub((e),μ(i))=8|E(e)|.

Let e=(u1,u2)AdjG(v) and let χ1=(e,j,1), χ2=(e,j,2) where j{1,2} is the unique index such that uj=v. Thus, as χ1,χ2D(e), by Item ii of Lemma 15 it holds that wχ1(S)=m and wχ2(S)=m. Observe that there can be at most one σvΣ such that (v,σv)S: assume towards a contradiction that there are (v,σv),(v,σv)S such that σvσv, then it follow that

wχ2(S)wχ2(v,σv)+wχ2(v,σv)=3nσv+3nσv=4n>3n=m,

where first equality follows from the definition of wχ2 (1) and the second inequality holds as σv,σvn. The above inequality is a contradiction that wχ2(S)=m.

Analogously, if there are (e,σ1,σ2),(e,σ1,σ2)S where (σ1,σ2)(σ1,σ2) then it would follow that

wχ1(S)3nσj+3nσj4n>3n=m,

where the first inequality uses the definition of wχ1 (2), and the second inequality follows from σj,σjn. The above inequality is a in contradiction to wχ1(S)=m. Therefore, there is at most one items of the form (e,σ1,σ2) in S.

On the other hand, if for all σvΣ it holds that (v,σv)S, then since there is at most one (σ1,σ2)Σ2 such that (e,σ1,σ2)S we also have

wχ2(S)maxσΣσ=n<3n=m.

The inequality holds since we assume that there is no σvΣ it holds that (v,σv)S, and we have shown above that there is at most one (σ1,σ2)Σ2 such that (e,σ1,σ2)S. The above contradicts the fact that wχ2(S)=m. Similarly, if for all (σ1,σ2)Σ2 it holds that (e,σ1,σ2)S, then it follows that

wχ1(S)maxσΣσ=n<3n=m

The above equation is a contradiction that wχ1(S)=m.

Overall, we have established that there is exactly one σvΣ such that (v,σv)S and there is exactly one (σ1,σ2)Σ2 such that (e,σ1,σ2)S. Therefore, it remains to prove that σj=σv. Observe that

wχ1(S)=wχ1((v,σv))+wχ1((e,σ1,σ2))=σv+3nσj.

Since wχ1(S)=m=3n, we conclude that σj=σv. The statement of the claim follows.

For all vV denote by σvΣ the unique symbol satisfying that (v,σv)S; by Claim 18 it holds that σv is well defined for every vV. Define φ:VΣ by φ(v)=σv for every vV, and for every vVV define φ(v) arbitrarily as some symbol in Σ. We start with the following claim.

Claim 19.

For every e=(u,v)E such that u,vV it holds that πe(φ(u),φ(v))=1.

Proof.

Let e=(u,v)E such that u,vV. Thus, it follows that φ(u)=σu and φ(v)=σv, where σu,σv are the unique symbols such that (u,σu)S and (v,σv)S, respectively, by Claim 18. Moreover, as eAdjG(v) and eAdjG(u), by Claim 18 it follows that (e,σu,σv)SIE. Since IE={(e,σ1,σ2)E×Σ×Σπe(σ1,σ2)=1} it immediately follows that πe(φ(u),φ(v))=πe(σu,σv)=1 as required.

It remains to give a lower bound on the value of φ. To do so, we need the following upper bound on the number of non-tight indices [r].

Claim 20.

|[r]T|q.

Proof.

First, from Lemma 8, we have

p(S)=[r]iS#sub(,μ(i))=TiS#sub(,μ(i))+[r]TiS#sub(,μ(i))=T8|E|+[r]TiS#sub(,μ(i))

Now, for every [r]T, it holds that iS#sub(,μ(i))8|E|; by Item i of Lemma 15 and the fact that #sub assigns only integral value for each item, we have that iS#sub(,μ(i))8|E|1. Plugging this into the above, we get

p(S)T8|E|+[r]T(8|E|1)=[r]8|E||[r]T|=8|E||[r]T|,

Finally, the claim follows since we assume that p(S)8|E|q.

To conclude the soundness proof, observe that

|VV|= |{vV|eAdjG(v) s.t. (e)[r]T}| (7)
[r]T2|E|
[r]T2F
= |[r]T|2F
2qF.

The first inequality holds as every eE such that (e)[r]T can add up to 2 vertices (its endpoints) to VV. The second inequality holds as |E|F due to the construction of the partition E1,,Er of E . The last inequality uses Claim 20. Hence,

val(φ)=|{e=(u,v)Eπe(φ(u),φ(v))=1}||E||{e=(u,v)E(V×V)}||E|=1|{e=(u,v)E(V×V)}||E|1Δ|VV||E|12ΔqF|E|.

The first inequality follows from Claim 19. The second inequality holds since G has a maximum degree Δ; hence, for each vVV there are at most Δ adjacent edges that do not belong to V×V and we conclude that |E(V×V)|Δ|VV|. The last inequality follows from (7). By the above inequality, the soundness proof follows.

The above lemmas give the statement of the reduction.

Proof of Lemma 7.

The proof follows from Lemma 12, Lemma 14, and Lemma 17.

4 Proofs of the Main Lower Bound

In this section, we prove Theorem 2 relying on the reduction presented in Section 3 and the strong lower bound for 2-CSP of [4], formalized in Theorem 6.

Theorem (2).

Assuming ETH, there is a constant d0, such that for any dd0 and any ε(0,1) the following holds. There exists a constant A>0 such that there is no (1ε)-approximation algorithm for d-dimensional knapsack that runs in time O(nr/logAr), where n is the size of the input and r=dε.

Proof of Theorem 2.

The proof can be summarized in high level as follows. First, we define a set of parameters. Then, relying on these parameters, we assume towards a contradiction the existence of an approximation algorithm VK-ALG for d-VK, for a sufficiently large d (see the concrete definitions below). Then, based on the existence of VK-ALG we give a reduction called CSP-ALG from 2-CSP to d-VK. Finally, we use the reduction to reach a contradiction to the existing lower bound for 2-CSP, given in Theorem 6. For readability, the proofs of the technical claims within the proof are deferred to Section 4.1.

Assume that ETH holds. Define ξ=14 and let C>0 and Δ be the constants promised by Theorem 6 for the error parameter ξ. Let A=C+1. We define several constants as follows. Let k0 be the constant promised by Theorem 6. Let B=102048Δ2 and let k2 be the integer promised by the following claim.

Claim 21.

There is an integer k2k0 such that for every kk2 the following holds.

  • klogCk10.

  • BklogAkklogCk.

Let d0=4096Δ2k2. Assume, towards a contradiction that there are dd0 and ε(0,1) such that there is a (1ε)-approximation algorithm VK-ALG for d-dimensional knapsack that runs in time O(Nr/logAr), where N is the size of the input and r=dε. To reach a contradiction to Theorem 6, we define the following reduction from 2-CSP on specific parameters. Define d=d2, and define k=dε1024Δ2. It holds that k is sufficiently large by the following claim.

Claim 22.

kk2k0.

According to Theorem 6, in the following we will consider only 2-CSP instances with k variables and m=Δk constraints. Define F=4md. The following claim shows that F satisfies the conditions of Lemma 7.

Claim 23.

F[m] and d4mF.

Recall that by Theorem 6 there is no algorithm running in time O(nk/logCk) that takes as input a 2-CSP instance Π on a constant degree Δ bipartite regular graph with k vertices over an alphabet of size n and can distinguish between the following two cases:

  • (Completeness) val(Π)=1.

  • (Soundness) val(Π)<ξ.

By our assumption, there is a (1ε)-approximation algorithm VK-ALG for d-dimensional knapsack that runs in time O(Nr/logAr), where N is the size of the input. Using VK-ALG, we define the following algorithm CSP-ALG that decides between the above two cases on 2-CSP instances with k variables on bipartite regular graphs of degree Δ. Let Π=(G,Σ,{πe}eE), where G=(V,E), be such a 2-CSP instance and define CSP-ALG on Π as follows.

  1. 1.

    Compute the reduced d-VK instance (Π,F) using Lemma 7

  2. 2.

    Execute VK-ALG on instance (Π,F) and let p be the profit of the resulting solution

  3. 3.

    If p8|E|(1ε): Decide val(Π)=1 and else decide val(Π)<ξ.

By Claim 23 and Lemma 7, the number of dimensions of the instance (Π,F) is at most d, and recall we can treat this instance as a d-VK instance by padding the extra dimensions in the cost vectors with zeros for all items. We conclude with the following two claims that the existence of the above algorithm is a contradiction to Theorem 6.

Claim 24.

For every given 2-CSP instance Π=(G,Σ,{πe}eE) on a constant degree Δ bipartite regular graph with k vertices, Algorithm CSP-ALG correctly decides if val(Π)=1 or val(Π)<ξ.

Proof.

Observe that (Π,F) is a well defined d-VK instance by Lemma 7 and Claim 23. Consider the following cases to show that CSP-ALG correctly decides Π.

  • If val(Π)=1. Then, by Lemma 7 there is a solution for (Π,F) with profit 8|E|; thus, as VK-ALG is a (1ε)-approximation algorithm, it follows that p8|E|(1ε) and consequently CSP-ALG decides val(Π)=1.

  • If val(Π)<ξ. We use the following claim.

    Claim 25.

    12ΔF8|E|ε|E|>ξ.

    Then, by Claim 25 it follows that

    val(Π)<ξ<12ΔF8|E|ε|E|.

    Therefore, by Lemma 7, for q=ε8|E|, there is no solution for (Π,F) with profit at least 8|E|q=8|E|(1ε). Hence, p<8|E|(1ε) and consequently CSP-ALG decides val(Π)<ξ.

The above two cases suffice to conclude the proof of the claim.

In the following, we analyze the running time of CSP-ALG.

Claim 26.

For every given 2-CSP instance Π=(G,Σ,{πe}eE) on a constant degree Δ bipartite regular graph with k vertices, Algorithm CSP-ALG decides Π in time O(nk/logCk), where n is the size of the alphabet.

Proof.

We first bound the running time of Step 1 of the algorithm, that constructs (Π,F) (note that F does not depend on Π). Let n=|Σ|. The running time of this step is O(|Π|5) by Lemma 7. Note that the encoding size of Π can be bounded by |Π|=O(n2) since for each eE we can encode πe using O(n2) bits, and there are m=Δk=O(1) such functions (recall that k is fixed for CSP-ALG and is not part of the input to the algorithm). Thus, the running time of Step 1 is

O(|Π|5)=O((n2)5)=O(n10).

In addition, Step 2 can be computed in time

O(|(Π,F)|r/logAr)=O(|Π|5r/logAr)=O(n10r/logAr)=O(n10(2048Δ2k)/logAr)=O(nBk/logAk)=O(nk/logCk).

The first equality follows from |(Π,F)|=O(|Π|5) by Lemma 7. The second equality holds since the encoding size of Π is bounded by |Π|=O(n2) as explained above. The third equality uses that k=rΔ22048=dεΔ21024; thus, r2048Δ2k. The fourth inequality follows because rk1 and by the monotonicity of the function logAx in the domain [1,) (recall that A1 since C>0). The last equality uses Claim 21 as kk2.

Thus, overall the running time of CSP-ALG on instance Π can be bounded by

O(n10)+O(nk/logCk)=O(nk/logCk).

The equality follows from the fact that klogCk10 from Claim 21, using that kk2.

By Claim 24 and Claim 26 we reach contradiction to Theorem 6 and the proof of the theorem follows.

4.1 Deferred Technical Proofs

We give below the deferred proofs of the technical claims used throughout the proof of Theorem 2.

Claim 21. [Restated, see original statement.]

There is an integer k2k0 such that for every kk2 the following holds.

  • klogCk10.

  • BklogAkklogCk.

Proof.

Let k1 be the minimum integer satisfying that for every kk1 it holds that klogCk10. Clearly, there is such an integer since C is fixed. Recall that B=102048Δ2 and define k2=max{k0,k1,eB}. Since k2eB, it follows that logk2B; thus, logAk2BlogCk2 and for every kk2 it holds that BklogAkklogCk a required.

Claim 22. [Restated, see original statement.]

kk2k0.

Proof.

Since we have

dεd=d2d02=2048Δ2k2,

it follows that dε2048Δ2k2; thus,

k=dε1024Δ2dε2048Δ2k2k0.

The claim follows.

Claim 23. [Restated, see original statement.]

F[m] and d4mF.

Proof.

Since dd024, it follows that Fm. For the second direction, F=4md1 as we round up and m=Δk1 (using that dd021024Δ2). Thus, F[m]. In addition,

4mF=4m4md4m4md=4d442d4=2d=d.

The above gives the statement of the claim.

Claim 25. [Restated, see original statement.]

12ΔF8|E|ε|E|>ξ.

Proof.

Recall that dεdd022048Δ2. Thus, k=dε1024Δ21 and it follows that

dε1024Δ2dε512Δ2.

Thus, using the definition of F=4Δkd:

2ΔF8|E|ε|E|=16ΔFε=16Δ4Δdε1024Δ2dε16Δ42Δdε1024Δ2dε128Δ2dε1024Δ2dε12

Therefore,

12ΔF8|E|ε|E|112>ξ.

The proof follows.

References

  • [1] Amir Abboud, Karl Bringmann, Danny Hermelin, and Dvir Shabtay. Seth-based lower bounds for subset sum and bicriteria path. ACM Transactions on Algorithms (TALG), 18(1):1–22, 2022. doi:10.1145/3450524.
  • [2] Inès Alaya, Christine Solnon, and Khaled GHéDIRA. Ant algorithm for the multidimensional knapsack problem. In BIOMA, pages 63–72, 2004.
  • [3] Md. Abul Kalam Azad, Ana Maria A. C. Rocha, and Edite M. G. P. Fernandes. Improved binary artificial fish swarm algorithm for the 0-1 multidimensional knapsack problems. Swarm Evol. Comput., 14:66–75, 2014. doi:10.1016/J.SWEVO.2013.09.002.
  • [4] Mitali Bafna, CS Karthik, and Dor Minzer. Near optimal constant inapproximability under eth for fundamental problems in parameterized complexity. In Proceedings of the 57th Annual ACM Symposium on Theory of Computing, pages 2118–2129, 2025.
  • [5] Stefan Balev, Nicola Yanev, Arnaud Fréville, and Rumen Andonov. A dynamic programming based reduction procedure for the multidimensional 0–1 knapsack problem. European journal of operational research, 186(1):63–76, 2008. doi:10.1016/J.EJOR.2006.02.058.
  • [6] Vincent Boyer, Moussa Elkihel, and Didier El Baz. Heuristics for the 0–1 multidimensional knapsack problem. European Journal of Operational Research, 199(3):658–664, 2009. doi:10.1016/J.EJOR.2007.06.068.
  • [7] Karthik C. S., Dániel Marx, Marcin Pilipczuk, and Uéverton Souza. Conditional lower bounds for sparse parameterized 2-csp: A streamlined proof. arXiv e-prints, pages arXiv–2311, 2023.
  • [8] Alberto Caprara, Hans Kellerer, Ulrich Pferschy, and David Pisinger. Approximation algorithms for knapsack problems with cardinality constraints. Eur. J. Oper. Res., 123(2):333–345, 2000. doi:10.1016/S0377-2217(99)00261-1.
  • [9] Timothy M. Chan. Approximation schemes for 0-1 knapsack. In SOSA, pages 5:1–5:12, 2018. doi:10.4230/OASIcs.SOSA.2018.5.
  • [10] Ashok K. Chandra, Daniel S. Hirschberg, and C. K. Wong. Approximate algorithms for some generalized knapsack problems. Theor. Comput. Sci., 3(3):293–304, 1976. doi:10.1016/0304-3975(76)90048-7.
  • [11] Chandra Chekuri and Sanjeev Khanna. On multidimensional packing problems. SIAM journal on computing, 33(4):837–851, 2004. doi:10.1137/S0097539799356265.
  • [12] Lin Chen, Jiayi Lian, Yuchen Mao, and Guochuan Zhang. A nearly quadratic-time FPTAS for knapsack. CoRR, abs/2308.07821, 2023. doi:10.48550/arXiv.2308.07821.
  • [13] Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. Introduction to Algorithms, 3rd Edition. MIT Press, 2009. URL: http://mitpress.mit.edu/books/introduction-algorithms.
  • [14] Marek Cygan, Holger Dell, Daniel Lokshtanov, Dániel Marx, Jesper Nederlof, Yoshio Okamoto, Ramamohan Paturi, Saket Saurabh, and Magnus Wahlström. On problems as hard as cnf-sat. ACM Transactions on Algorithms (TALG), 12(3):1–24, 2016. doi:10.1145/2925416.
  • [15] Marek Cygan, Marcin Mucha, Karol Wegrzycki, and Michal Wlodarczyk. On problems equivalent to (min, +)-convolution. ACM Trans. Algorithms, 15(1):14:1–14:25, 2019. doi:10.1145/3293465.
  • [16] Mingyang Deng, Ce Jin, and Xiao Mao. Approximating knapsack and partition via dense subset sums. In SODA, pages 2961–2979, 2023. doi:10.1137/1.9781611977554.CH113.
  • [17] Ilan Doron-Arad, Ariel Kulik, and Pasin Manurangsi. Fine grained lower bounds for multidimensional knapsack. arXiv preprint arXiv:2407.10146, 2024. doi:10.48550/arXiv.2407.10146.
  • [18] Arnaud Fréville. The multidimensional 0-1 knapsack problem: An overview. Eur. J. Oper. Res., 155(1):1–21, 2004. doi:10.1016/S0377-2217(03)00274-1.
  • [19] A.M. Frieze and M.R.B. Clarke. Approximation algorithms for the m-dimensional 0–1 knapsack problem: Worst-case and probabilistic analyses. European Journal of Operational Research, 15(1):100–109, 1984. doi:10.1016/0377-2217(84)90053-5.
  • [20] Kilian Grage and Klaus Jansen. Convolution and knapsack in higher dimensions. arXiv preprint arXiv:2403.16117, 2024. doi:10.48550/arXiv.2403.16117.
  • [21] Venkatesan Guruswami, Bingkai Lin, Xuandi Ren, Yican Sun, and Kewen Wu. Parameterized inapproximability hypothesis under exponential time hypothesis. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing, pages 24–35, 2024. doi:10.1145/3618260.3649771.
  • [22] Venkatesan Guruswami, Bingkai Lin, Xuandi Ren, Yican Sun, and Kewen Wu. Almost optimal time lower bound for approximating parameterized clique, csp, and more, under eth. In Proceedings of the 57th Annual ACM Symposium on Theory of Computing, pages 2136–2144, 2025. doi:10.1145/3717823.3718130.
  • [23] Oscar H. Ibarra and Chul E. Kim. Fast approximation algorithms for the knapsack and sum of subset problems. J. ACM, 22(4):463–468, 1975. doi:10.1145/321906.321909.
  • [24] Russell Impagliazzo and Ramamohan Paturi. On the complexity of k-sat. Journal of Computer and System Sciences, 62(2):367–375, 2001. doi:10.1006/JCSS.2000.1727.
  • [25] Tanmay Inamdar, Daniel Lokshtanov, Saket Saurabh, and Vaishali Surianarayanan. Parameterized Complexity of Fair Bisection: (FPT-Approximation meets Unbreakability). In Inge Li Gørtz, Martin Farach-Colton, Simon J. Puglisi, and Grzegorz Herman, editors, 31st Annual European Symposium on Algorithms (ESA 2023), volume 274 of Leibniz International Proceedings in Informatics (LIPIcs), pages 63:1–63:17, Dagstuhl, Germany, 2023. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.ESA.2023.63.
  • [26] Klaus Jansen, Felix Land, and Kati Land. Bounding the running time of algorithms for scheduling and packing problems. SIAM J. Discret. Math., 30(1):343–366, 2016. doi:10.1137/140952636.
  • [27] Ce Jin. An improved FPTAS for 0-1 knapsack. In ICALP, pages 76:1–76:14, 2019. doi:10.4230/LIPIcs.ICALP.2019.76.
  • [28] David S. Johnson. Approximation algorithms for combinatorial problems. In STOC, pages 38–49, 1973. doi:10.1145/800125.804034.
  • [29] Richard M. Karp. Reducibility among combinatorial problems. In Proceedings of a symposium on the Complexity of Computer Computations, pages 85–103, 1972. doi:10.1007/978-1-4684-2001-2_9.
  • [30] C. S. Karthik. Personal communication, 2025.
  • [31] Liangjun Ke, Zuren Feng, Zhigang Ren, and Xiaoliang Wei. An ant colony optimization approach for the multidimensional knapsack problem. Journal of Heuristics, 16:65–83, 2010. doi:10.1007/S10732-008-9087-X.
  • [32] Hans Kellerer and Ulrich Pferschy. A new fully polynomial time approximation scheme for the knapsack problem. J. Comb. Optim., 3(1):59–71, 1999. doi:10.1023/A:1009813105532.
  • [33] Hans Kellerer and Ulrich Pferschy. Improved dynamic programming in connection with an FPTAS for the knapsack problem. J. Comb. Optim., 8(1):5–11, 2004. doi:10.1023/B:JOCO.0000021934.29833.6B.
  • [34] Bernhard Korte and Rainer Schrader. On the existence of fast approximation schemes. In Nonlinear Programming 4, pages 415–437. Academic Press, 1981. doi:10.1016/B978-0-12-468662-5.50020-3.
  • [35] Ariel Kulik and Hadas Shachnai. There is no EPTAS for two-dimensional knapsack. Inf. Process. Lett., 110(16):707–710, 2010. doi:10.1016/J.IPL.2010.05.031.
  • [36] Marvin Künnemann, Ramamohan Paturi, and Stefan Schneider. On the fine-grained complexity of one-dimensional dynamic programming. In ICALP, pages 21:1–21:15, 2017. doi:10.4230/LIPIcs.ICALP.2017.21.
  • [37] Eugene L. Lawler. Fast approximation algorithms for knapsack problems. Math. Oper. Res., 4(4):339–356, 1979. doi:10.1287/MOOR.4.4.339.
  • [38] Soh-Yee Lee and Yoon-Teck Bau. An ant colony optimization approach for solving the multidimensional knapsack problem. In ICCIS, pages 441–446, 2012. doi:10.1109/ICCISci.2012.6297286.
  • [39] Daniel Lokshtanov, MS Ramanujan, Saket Saurab, and Meirav Zehavi. Parameterized complexity and approximability of directed odd cycle transversal. In SODA, pages 2181–2200, 2020.
  • [40] James H Lorie and Leonard J Savage. Three problems in rationing capital. The journal of business, 28(4):229–239, 1955.
  • [41] Michael J. Magazine and Maw-Sheng Chern. A note on approximation schemes for multidimensional knapsack problems. Math. Oper. Res., 9(2):244–247, 1984. doi:10.1287/MOOR.9.2.244.
  • [42] Xiao Mao. (1-ϵ)-approximation of knapsack in nearly quadratic time. CoRR, abs/2308.07004, 2023. doi:10.48550/arXiv.2308.07004.
  • [43] Harry M Markowitz and Alan S Manne. On the solution of discrete programming problems. Econometrica: journal of the Econometric Society, pages 84–110, 1957.
  • [44] Osman Oguz and MJ Magazine. A polynomial time approximation algorithm for the multidimensional 0/1 knapsack problem. Univ. Waterloo Working Paper, 1980.
  • [45] Abdellah Rezoug, Mohamed Bader-El-Den, and Dalila Boughaci. Hybrid Genetic Algorithms to Solve the Multidimensional Knapsack Problem, pages 235–250. Springer International Publishing, Cham, 2019. doi:10.1007/978-3-319-95104-1_15.
  • [46] Donguk Rhee. Faster fully polynomial approximation schemes for knapsack problems. PhD thesis, Massachusetts Institute of Technology, 2015.
  • [47] Sara Sabba and Salim Chikhi. A discrete binary version of bat algorithm for multidimensional knapsack problem. Int. J. Bio Inspired Comput., 6(2):140–152, 2014. doi:10.1504/IJBIC.2014.060598.
  • [48] Sartaj Sahni. Approximate algorithms for the 0/1 knapsack problem. J. ACM, 22(1):115–124, 1975. doi:10.1145/321864.321873.
  • [49] H Martin Weingartner and David N Ness. Methods for the solution of the multidimensional 0/1 knapsack problem. Operations Research, 15(1):83–103, 1967. doi:10.1287/OPRE.15.1.83.
  • [50] 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.
  • [51] Hong-Fang Yan, Ci-Yun Cai, De-Huai Liu, and Min-Xia Zhang. Water wave optimization for the multidimensional knapsack problem. In ICIC, volume 11644, pages 688–699, 2019. doi:10.1007/978-3-030-26969-2_65.