# An Approximate Dynamic Programming Approach to The Incremental Knapsack Problem

We study the incremental knapsack problem, where one wishes to sequentially pack items into a knapsack whose capacity expands over a finite planning horizon, with the objective of maximizing time-averaged profits. While various approximation algorithms were developed under mitigating structural assumptions, obtaining non-trivial performance guarantees for this problem in its utmost generality has remained an open question thus far. In this paper, we devise a polynomial-time approximation scheme for general instances of the incremental knapsack problem, which is the strongest guarantee possible given existing hardness results. In contrast to earlier work, our algorithmic approach exploits an approximate dynamic programming formulation. Starting with a simple exponentially sized dynamic program, we prove that an appropriate composition of state pruning ideas yields a polynomially sized state space with negligible loss of optimality. The analysis of this formulation synthesizes various techniques, including new problem decompositions, parsimonious counting arguments, and efficient rounding methods, that may be of broader interest.

## Authors

• 2 publications
• 3 publications
• ### Approximation Algorithms for The Generalized Incremental Knapsack Problem

We introduce and study a discrete multi-period extension of the classica...
09/15/2020 ∙ by Yuri Faenza, et al. ∙ 0

Cookie Clicker is a popular online incremental game where the goal of th...
08/22/2018 ∙ by Erik D. Demaine, et al. ∙ 0

• ### Toward breaking the curse of dimensionality: an FPTAS for stochastic dynamic programs with multidimensional actions and scalar states

We propose a Fully Polynomial-Time Approximation Scheme (FPTAS) for stoc...
11/28/2018 ∙ by Nir Halman, et al. ∙ 0

• ### Dynamic Programming Approach to the Generalized Minimum Manhattan Network Problem

We study the generalized minimum Manhattan network (GMMN) problem: given...
04/23/2020 ∙ by Yuya Masumura, et al. ∙ 0

• ### Approximate Dynamic Programming By Minimizing Distributionally Robust Bounds

Approximate dynamic programming is a popular method for solving large Ma...
05/08/2012 ∙ by Marek Petrik, et al. ∙ 0

• ### Approximating the Incremental Knapsack Problem

We consider the 0-1 Incremental Knapsack Problem (IKP) where the capacit...
01/15/2018 ∙ by Federico Della Croce, et al. ∙ 0

Parameterized complexity theory has lead to a wide range of algorithmic ...
06/26/2018 ∙ by Max Bannach, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Integer packing problems have traditionally been some of the most fundamental and well-studied computational questions in discrete optimization. Contributions along this line of research have ranged from advancing the theory of algorithm design to developing practical tools for tackling a wide range of real-life applications. One of the cornerstone resources in this context is the binary knapsack problem. Here, given a finite collection of items, each associated with profit and weight parameters, one wishes to identify the most profitable subset of items subject to a single packing constraint, in the form of a pre-specified upper bound on the total weight of selected items. Despite its seemingly simple formulation, binary knapsack turned out to incorporate just the right amount of combinatorial complexity to end up as one of Karp’s 21 NP-complete problems (1972), and at the same time, to admit various fully polynomial-time approximation schemes (Ibarra and Kim 1975, Lawler 1979, Magazine and Oguz 1981, Kellerer and Pferschy 1999). Due to the large body of literature on the binary knapsack problem and its descendants, we refer the avid reader to excellent books dedicated to this topic (Toth and Martello 1990, Kellerer et al. 2004) for an exhaustive overview.

#### The incremental knapsack problem.

Knapsack-like problems were studied under various forms and shapes motivated by applications such as financial planning, energy management, and logistics. In particular, the thesis work of Sharp (2007) and Hartline (2008)

introduced a novel multi-period generalization, dubbed the incremental knapsack problem, as part of their incremental optimization modeling framework; this approach extends classic combinatorial optimization problems into multi-period formulations with time-varying constraints. Deferring the finer details of this setting to Section

1.2, rather than having a single knapsack constraint, we are now considering a discrete planning horizon of periods, which are associated with non-decreasing capacities as well as with non-negative coefficients . An additional input ingredient is a collection of items, where each item is characterized by a profit and a weight . These items are to be incrementally introduced along a nested sequence of subsets , subject to time-varying knapsack constraints, stipulating that for every . The goal is to maximize the -averaged profit, . Here, and are extensions of the weight and profit functions from individual items to item sets, meaning that and .

This modeling approach naturally captures resource allocation settings where the available resource (e.g., capital, production capacity, demand) grows in a predictable way over a finite planning horizon. A canonical example of such resource allocation problems is financial planning. For instance, well-informed households generally wish to optimize how their cumulative income is invested over time into low-volatility securities that procure regular payments; from that angle, time-varying discounts reflect specific households’ investment profiles. Similarly, this approach can be utilized for modeling the selection of investments in bond markets and various government decision processes, as illustrated by Faenza and Malinovic (2018). Additionally, the incremental knapsack problem has certain technical connections with sequential assortment optimization problems in revenue management, as discussed in Section 1.3.

#### Previous work.

We proceed by demonstrating that this generalization of the standard binary knapsack problem creates intriguing computational challenges. To this end, we briefly summarize known hardness results and algorithmic findings related to the incremental knapsack problem. Further connections to well-studied optimization settings are discussed in Section 1.3.

• Hardness: Quite surprisingly, Bienstock et al. (2013) and Ye (2016) showed that the incremental knapsack problem is strongly NP-hard. Consequently, the existence of an FPTAS is ruled out in this computational setting unless , thus creating a strong separation from its ancestor, the binary knaspack problem, which is known to admit various such approximation schemes (Ibarra and Kim 1975, Lawler 1979, Magazine and Oguz 1981, Kellerer and Pferschy 1999).

• Special cases. Positive results for special cases of the incremental knapsack problem have been appearing in the literature for quite some time. Hartline and Sharp (2006) devised a polynomial-time -approximation for the incremental subset sum problem, where all input parameters are integral and for every . Hartline (2008, Chap. 3.3) subsequently proposed a pseudo-polynomial -time dynamic program that yields a -approximation for incremental subset sum. By extending the standard pseudo-polynomial dynamic program for the binary knapsack problem, Sharp (2007, Chap. 3.4) attained an approximation scheme in this setting. Her algorithm computes a -approximate solution in time, meaning that this approach is exponential in . Subsequently, Croce et al. (2018) focused on the special case of incremental knapsack with time periods; they developed an LP-based algorithm with a tight approximation ratio of .

• Approximability under parametric assumptions. More recently, research efforts have been put into algorithmic approaches that are provably good or computationally efficient in specific parametric regimes. For example, by combining LP rounding methods and disjunctive programming ideas, Bienstock et al. (2013) devised a polynomial-time constant-factor approximation; the specific constant attained grows as a function of the minimum parameter satisfying for all . Later on, Croce et al. (2019) developed an enumeration-based approximation scheme that identifies an -approximate solution in time; due to its exponential dependency on , this approach corresponds to a PTAS for a fixed number of time periods.

• Time-invariant incremental knapsack. The time-invariant formulation constitutes a special case of incremental knapsack for which stronger performance guarantees are known to exist. The latter heavily relies on a simplifying structural assumption, where all time periods are uniformly weighed within the objective function, meaning that . In this setting, Bienstock et al. (2013) attained a PTAS in the regime where the number of time periods is sublogarithmic in the number of items, i.e., . Recently, Faenza and Malinovic (2018) developed a PTAS for the time-invariant incremental knapsack problem without additional assumptions. Their approach combines techniques such as problem sparsification, compact enumeration, and LP-rounding methods.

#### Research questions.

To summarize, while numerous research papers have shed light on various computational aspects, we are not aware of any way to leverage the above-mentioned advances to obtain non-trivial approximations for the incremental knapsack problem in its utmost generality. Quoting the work of Bienstock et al. (2013, Sec. 5): “Our work leaves the following open questions …Is there a polynomial time algorithm for incremental knapsack with a constant-factor approximation ratio that makes no assumption on the growth rate of ?”. Similarly, this question has been restated by Faenza and Malinovic (2018, Sec. 3): “Following Theorem 1, one could ask for a PTAS for the general incremental knapsack problem”. Our paper seeks to resolve these fundamental open questions.

### 1.1 Our contributions

The main result of this paper resides in developing a PTAS for the incremental knapsack problem in its utmost generality, i.e., without mitigating assumptions on the underlying number of time periods, item weights, or any other parameter. Namely, we show that the optimal profit can be approached within any fixed degree of accuracy via an algorithmic approach whose running time is polynomial in the input size, as formally stated in Theorem 1.1 below; to avoid cumbersome expressions, we make use of to hide polylogarithmic dependencies, i.e., . Recalling that the incremental knapsack problem has previously been shown to be strongly NP-hard (Bienstock et al. 2013, Ye 2016), this result fully settles its complexity status.

[] For any accuracy level , the incremental knapsack problem can be approximated within factor of optimal. The running time of our algorithm is , where stands for the input size in binary representation.

From an algorithmic perspective, while existing approximation schemes for special cases of the incremental knapsack problem mainly relied on LP-rounding methods and disjunctive programming (Bienstock et al. 2013, Faenza and Malinovic 2018), our approach is based on approximate dynamic programming. In a nutshell, the foremost ingredient of this formulation is an efficient state pruning method that takes advantage of how certain near-optimal solutions are structured. This approach combines various techniques, including newly developed problem decompositions, parsimonious counting arguments, and efficient rounding methods. For ease of exposition, our approximate dynamic programming ideas are presented in an incremental way throughout the technical parts of this paper, as we proceed to explain.

#### Approximation scheme assuming λ+-boundedness.

In Section 2, we begin by devising an approximation scheme whose running time includes a polynomial dependency on . Clearly, the latter ratio by itself could be exponential in the input size, meaning that our proposed algorithm constitutes a PTAS only when , a property referred to as

-boundedness. To derive this result, we establish a so-called prefix-like property of near-optimal solutions where, by slightly altering item profits, it is optimal to introduce items within each profit class by increasing weights. Given this property, we formulate an intermediate dynamic program whose states encapsulate, among other parameters, a “count vector” that specifies the number of items introduced thus far out of certain profit classes. Our main structural finding shows that this exponentially sized state space can be efficiently shrunk with a negligible loss of optimality. Specifically, we describe rounding operations that transform the original count vectors into highly structured vectors, of which there are polynomially many distinct occurrences.

#### General approximation scheme.

Given these results, Section 3 is dedicated to devising a PTAS that applies to any instance of the incremental knapsack problem, with no assumptions whatsoever. This general purpose algorithm is developed via an efficient reduction to the -bounded setting. To this end, we prove that near-optimal solutions can be decomposed through the connected components of an appropriately defined bipartite graph, representing how items of different profit classes are assigned to “clusters” of time periods, each meeting the -boundedness property. Moreover, we argue that the best-possible such decomposition can be computed via further dynamic programming ideas.

### 1.2 Problem formulation

In an instance of the incremental knapsack problem, we are given a collection of items, where each item has a profit of and a weight of . By reading the remainder of this formulation, it is easy to verify that both parameters can be assumed to be strictly positive. These items may be introduced across a discrete planning horizon that consists of time periods, indexed , whose respective knapsack capacities are designated by . Moreover, each period is associated with a non-negative coefficient .

To formally capture how items are inserted over time, we define a solution to be a nested sequence of items sets falling within the above-mentioned capacities, i.e., for every . We refer to the difference as the collection of items introduced in time period , with the convention that , meaning that each set is precisely the collection of items that were introduced up until and including period , with a total profit of . The objective function averages the profits of these item sets over all time periods through their -coefficients, namely, . Our goal is to compute a solution that maximizes this function.

#### Equivalent representation of Ψ.

Moving forward, it will be convenient to rewrite the objective function as a summation over “item contributions” rather than over time period profits. For this purpose, let , noting that . We assume without loss of generality that , since all time periods with can be eliminated in advance. Additionally, with respect to a solution and an item , we use to denote the unique time period in which this item was introduced. Consequently, by defining for any such item, it follows that the objective function can be decomposed into the sum of individual item contributions as follows:

 Ψ(S)  =  ∑t∈[T]λt⋅p(St)  =  ∑i∈ST(pi⋅T∑t=ν(i,S)λt)  =  ∑i∈STpi⋅λν(i,S)+  =  ∑i∈STΨi(S) . (1)

### 1.3 Connections to additional optimization settings

Beyond our preliminary overview of directly related work, it is worth pointing out that the incremental knapsack problem is related to additional streams of literature in discrete optimization. In what follows, we discuss two such connections and highlight the distinctive features of incremental knapsack.

#### Maximum generalized assignment.

Incremental knapsack has certain similarities with the maximum generalized assignment problem. Here, items can be assigned to disjoint knapsacks with capacities . Placing item in knapsack consumes units of capacity and generates a profit of ; we note that both quantities depend on the knapsack to which an item is assigned to. Shmoys and Tardos (1993) were the first to implicitly study this problem, by presenting an LP-based -approximation for its minimization variant, which provides with small modifications a -approximation for the maximization problem, as noted by Chekuri and Khanna (2005). The latter paper further identified special cases of generalized assignment that turn out to be APX-hard; the authors also devised a PTAS when each item’s profits and weights are uniform across all knapsacks, a setting known as the multiple knapsack problem. Subsequently, Fleischer et al. (2011) considered the separable assignment problem, which extends generalized assignment, for which they devised an LP-based -approximation. Feige and Vondrák (2010) broke this barrier by proposing an LP-based algorithm that attains an approximation factor of , for some absolute constant . Additional papers have studied closely related variants, including those of Cohen et al. (2006) and Nutov et al. (2006).

As observed by Bienstock et al. (2013), the incremental knapsack problem is reducible to maximum generalized assignment in the special case where the capacity constraints can be equivalently represented as cardinality constraints on the number of items introduced at each time period. Nevertheless, to our knowledge, connections to this line of research do not lend themselves for the purpose of designing a general-purpose PTAS for the incremental knapsack problem.

#### Assortment optimization over time.

Interestingly, technical connections can also be established in relation to a class of problems known as assortment optimization over time under the Multinomial Logit (MNL) choice model. In this setting, we are given a collection of products

characterized by a profit and a preference weight . The firm decides on a sequence of nested subsets of products that are examined by customers according to an exogenous distribution . The goal is to maximize the cumulative expected revenue, , where the inner ratio

reflects the purchase probability of product

within the assortment , as prescribed by the MNL model. This problem has recently been introduced by Davis et al. (2015), who proposed a greedy-like -approximation when . Subsequently, Gallego et al. (2020) developed a dynamic programming-based algorithm that attains an improved approximation ratio of and actually applies to a more general class of choice models. Focusing on the MNL setting, Aouad and Segev (2020) devised a PTAS via an approximate dynamic programming formulation. Closely related variants have been considered in additional papers, including those of Derakhshan et al. (2018) and Flores et al. (2019).

To understand the connection between this setting and the incremental knapsack problem, note that the linear-fractional terms in the objective function indirectly capture soft capacity constraints. Specifically, rather than imposing a hard constraint of the form , the profit contribution of each product in decreases as a function of . To formalize this connection, it is not difficult to verify that assortment optimization over time is reducible to incremental knapsack, had we been able to efficiently guess the sequence , where is the optimal sequence of assortments. Unfortunately, we are unaware of any way to reciprocally exploit this connection for the purpose of designing a PTAS for the incremental knapsack problem.

## 2 PTAS for λ+-Bounded Instances

In what follows, we devise an approximation scheme for the incremental knapsack problem whose running time incorporates a polynomial dependency on the ratio between the largest and smallest values. The specifics of this result are formally stated in the next theorem.

For any accuracy level , the incremental knapsack problem can be approximated within factor of optimal in time.

### 2.1 The inverse problem

#### Auxiliary formulation.

To provide an accessible account of this result, we introduce a closely related variant, dubbed inverse incremental knapsack. Here, given a profit requirement , suppose that our goal is to identify a solution that minimizes the total weight of inserted items, , subject to obtaining a profit of at least , namely, . Moving forward, we use to designate a fixed optimal solution for the inverse problem, parameterized by ; when the latter problem is infeasible, we indicate this situation by setting . In the remainder of this section, we develop an approximation scheme for computing a super-optimal solution to the inverse incremental knapsack problem, at the expense of slightly violating the profit constraint. As formally stated in the next claim, our algorithm will incur a polynomial dependency on as part of its running time.

For any accuracy level , given a profit requirement for which , we can compute in time a solution satisfying:

1. [label=()]

2. Super-optimality: .

3. -profit violation: .

#### Immediate consequence.

To derive Theorem 2, the important observation is that our algorithm for the inverse formulation can be leveraged to devise an approximation scheme for incremental knapsack in a straightforward way. To this end, letting

be an optimal solution for the latter problem, suppose we were given in advance an estimate

for the optimal profit. It is easy to verify that, since , such an estimate can be obtained by enumerating over either or quantities of the form within this interval, for integer values of . Consequently, whenever , the -parameterized inverse formulation is clearly feasible, meaning that by applying Theorem 2.1, we identify a solution satisfying , which is a -approximate solution to the original incremental knapsack problem. As a side note, it is worth pointing out that the latter argument does exploit the super-optimality of ; this property will play a crucial role in Section 3, once we consider arbitrarily structured instances.

### 2.2 Preliminaries: Prefix-like near-optimal solutions

Focusing on an inverse incremental knapsack instance parameterized by , it would be convenient to fix the profit requirement from this point on. For simplicity of notation, we further drop the symbol when referring to , which results in having as an optimal solution to the inverse problem instance being considered.

#### Profit classes.

We begin by scaling all profits such that . In addition, we round down the profit of each item to the nearest integer power of . It is easy to verify that, as a result of this alteration, we are losing at most an -fraction of the profit ; clearly, once the original item profits are restored, the profit of any solution can only increase. For simplicity, we keep denoting the modified profits by . Following these preprocessing steps, for every , we use to designate the collection of items associated with a profit of ; this set will be referred to as the profit class .

#### Prefix-like solutions.

For any profit class and for any integer , we use to denote the set of smallest weight items in , breaking ties arbitrarily. Also, will be the set of -th smallest, -th smallest, up to -th smallest weight items in , that is, . We say that a solution has a prefix-like structure when, for every time period and class , the items picked by from are those with smallest weight, i.e., .

Crucial to our algorithmic approach is the next lemma, which argues that the sequence of profit classes contains an -length interval such that the union of its classes has a near-optimal prefix-like solution.

There exist an -length interval and a prefix-like solution such that:

1. [label=()]

2. The solution only introduces items from profit classes .

3. Super-optimality: .

4. -profit violation: .

###### Proof.

Proof. To determine the interval , let be the maximal index of a profit class of which introduces at least one item, namely, . Our interval is defined as , where , meaning that it is indeed of the required length. Having specified the interval , we construct a corresponding prefix-like solution by setting for every . In other words, for every , the set picks out of the profit class exactly the same number of items as does; however, these items are picked by order of increasing weight.

One straightforward observation is that, since no items are introduced out of profit classes , property 1 is clearly satisfied. In addition, this definition guarantees that is indeed a feasible solution by noting that, for every time period ,

where the first inequality is derived by observing that is a subset of items in profit class , while is the lightest subset of consisting of that many items. Beyond feasibility, the inequality we have just proven also shows that property 2 is satisfied.

To prove property 3, we first argue that for every ,

 ∑i∈~ST∩PℓΨi(~S) = ∑t∈[T]∑i∈(~St∖~St−1)∩PℓΨi(~S) = (1+ϵ)ℓ⋅∑t∈[T]λt+⋅∣∣(~St∖~St−1)∩Pℓ∣∣ = (1+ϵ)ℓ⋅∑t∈[T]λt+⋅∣∣(S∗t∖S∗t−1)∩Pℓ∣∣ = ∑t∈[T]∑i∈(S∗t∖S∗t−1)∩PℓΨi(S∗) = ∑i∈S∗T∩PℓΨi(S∗) .

Here, the second equality holds since for all items , whereas the fourth equality follows from an analogous argument with respect to . As a result, based on representation (1) of the objective function, to show that , it suffices to argue that . For this purpose, note that

 ∑i∈S∗T∖~STΨi(S∗) = ∑i∈S∗T∖~STpi⋅λν(i,S∗)+ ≤ ∣∣S∗T∖~ST∣∣⋅λ1+⋅(1+ϵ)ℓmax−L ≤ n⋅λ1+⋅(1+ϵ)ℓmax⋅ϵnρ = ϵ⋅λT+⋅(1+ϵ)ℓmax ≤ ϵ⋅Ψ(S∗) .

Here, the first inequality holds since and since is necessarily a subset of , by definition of , meaning that every item has a profit of at most . The second inequality is obtained by observing that in view of our choice for . The last inequality holds since, by definition of , at least one item is introduced by , implying that its individual profit contribution is at least . ∎

### 2.3 Dynamic programming formulation

Taking advantage of Lemma 2.2, we restrict our attention to prefix-like solutions with respect to the profit classes . For convenience, rather that representing such solutions as a sequence of items sets , we use instead an equivalent sequence of utilization vectors . Here, each is an integer-valued vector of dimension , in which each coordinate specifies the number of items picked thus far from the profit class , i.e., .

#### States.

Each state of our dynamic program is described by two parameters:

• The index of the current period, . This parameter takes one of the values .

• The collection of items utilized thus far, specified by the utilization vector . This parameter belongs to the family of vectors .

It is important to emphasize that the family of vectors we are currently working with is of cardinality , meaning that the state space described so far is exponentially sized. Our goal in subsequent sections will be to develop a more compact, and yet still near-optimal state space representation.

#### Value function.

The value function stands for the maximum-possible accumulated profit contribution of a -period solution that satisfies the following conditions:

1. Utilization vector at period : The set of items introduced across time periods is described by the utilization vector .

2. Feasibility: All capacities are satisfied, i.e., for every , with the convention that .

When there is no solution satisfying conditions 1 and 2, we define . Consequently, we are interested in finding a utilization vector that minimizes out of those that meet the criterion . At this stage, it is worth pointing out that, by considering the prefix-like solution constructed in Lemma 1, it follows that the utilization vector associated with satisfies and . Therefore, the previously mentioned criterion is met by some utilization vector, and concurrently, since we return the one whose total weight is minimized, the items introduced have a total weight of at most . Hence, by following the actions taken by our dynamic program, we obtain an inverse incremental knapsack solution that satisfies the properties required in Theorem 2.1.

#### Recursive equations.

Next, we argue that the value function satisfies a collection of recursive equations, leading to a dynamic programming formulation of the inverse incremental knapsack problem. The important observation is that the feasibility of any -period solution is equivalent to jointly ensuring that:

• The induced -period solution is feasible by itself.

• Our extension to period preserves feasibility, meaning that and .

Consequently, for every and , the value function can be recursively expressed as

 F(t,Nt)= maxNt−1∈Uall {F(t−1,Nt−1)+λt+⋅∑ℓ∈L(1+ϵ)ℓ⋅(Nt,ℓ−Nt−1,ℓ)} s.t. Nt−1≤Nt , w(Nt)≤Wt .

To better understand the recursion above, note that the expression is precisely the marginal profit contribution of the items introduced in period , bearing in mind that we have already accumulated profit contributions amounting to up to and including period . Specifically, on top of the latter quantity, in period we are introducing items from each profit class , whose profits are all uniformly equal to . When there is no extendible -period solution, i.e., one satisfying and , we have . Finally, the terminal states of this dynamic program are reached at , in which case and for all other states.

### 2.4 Approximate dynamic program: High-level overview

#### Restriction to Usmall.

In what follows, we explain how our original dynamic programming formulation can be altered, when considering an appropriately restricted subset of the utilization vectors . To this end, let be any family of utilization vectors with . Given such a set, one can define an approximate dynamic program that would mimic the exact program , when restricted to the family . That is, while each state is still of the form , we now require that instead of . In addition, rather than searching over , we substitute this constraint with . As a result, the recursive equations we obtain for are given by:

 ~FUsmall(t,Nt)= maxNt−1∈Usmall {~FUsmall(t−1,Nt−1)+λt+⋅∑ℓ∈L(1+ϵ)ℓ⋅(Nt,ℓ−Nt−1,ℓ)} s.t. Nt−1≤Nt , w(Nt)≤Wt .

It is easy to verify that this dynamic program is well-defined for any possible choice of with . However, there is clearly a loss in optimality resulting from the elimination of , corresponding to further restrictions on the utilization vectors being considered. That said, every utilization vector with can still be converted in a straightforward way into a solution with a profit of and a total weight of .

#### The fundamental question.

Let be the maximum value of over all utilization vectors with ; we remind the reader that is a fixed optimal solution to the inverse incremental knapsack instance being considered. As noted in Section 2.3, the utilization vector , corresponding to the prefix-like solution given by Lemma 2.2, satisfies and , immediately showing that . Similarly, let us define as the maximum value of over all utilization vectors with . The intrinsic question is: Can we efficiently construct a small-sized family of utilization vectors for which ?

In the remainder of this section, we will present an explicit construction of a family formed by utilization vectors, for which . Consequently, our algorithm returns the solution associated with the utilization vector that minimizes over those meeting the criterion . By the preceding discussion, this solution is guaranteed to simultaneously satisfy and , thereby completing the proof of Theorem 2.1.

#### Construction of Usmall.

In the upcoming discussion, we will constructively define the family of utilization vectors in an incremental way. Given an arbitrary utilization vector , we describe two alterations for transforming the latter into a highly structured vector, . Informally speaking, this vector preserves the main features of , in the sense of generating a nearly-matching total profit while still being feasible with respect to the time period capacities. However, the additional structural properties entailed by our alterations would ensure that the family of vectors is polynomially sized. Specifically, in Section 2.5, we begin by defining the up-rounding operation, where is mapped to a vector by appropriately rounding up some of its coordinates. It is important to emphasize that up-rounding by itself may very well lead to capacity violations at various time periods. Next, in Section 2.6, we define the truncation operation, where is mapped in turn to the final utilization vector . While its finer details are somewhat involved, at least intuitively, this operation discards certain items within each profit class in order to offset the excess capacity within the up-rounding , and thus, to restore feasibility.

It is important to point out that the upcoming description of our up-rounding and truncation operations is primarily meant for purposes of analysis. Algorithmically speaking, the composition of these operations is not an efficient method for generating the reduced family of utilization vectors , and its naive application would require an explicit enumeration over . That said, the mappings will be instrumental in bounding the optimality loss entailed by the approximate formulation relative to the exact program . The computational aspects of our approximate dynamic program, including an efficient construction of , are separately discussed in Section 2.7.

### 2.5 The up-rounding operation: Definitions and properties

In what follows, we define an explicit mapping from each utilization vector to its up-rounding , which is a new utilization vector with very specific structure.

#### Light and heavy classes.

To avoid cumbersome notation, we assume without loss of generality that is an integer and that . We begin by defining a vector-specific dichotomy of the profit classes , depending on the number of items picked by the utilization vector out of each one. For this purpose, the profit class is said to be light for when . The collection of all light classes is denoted by . Every other class, with strictly more than items, is called heavy for , with the analogous notation .

#### Constructing N(1) via up-rounding.

Each coordinate of the vector will be defined depending on whether its corresponding profit class is light or heavy. Specifically, out of each light class, picks exactly the same number of items as does, meaning that for every . In contrast, for each heavy class , the way we define is more elaborate:

• We begin by introducing a shorthand notation for the total weight of all items picked by out of heavy classes, beyond the lightest ones in each class, i.e.,

 Wheavy(N)=∑ℓ∈heavy(N)w(Pℓ[1ϵ+1,Nℓ]) .
• For every , let be an over-estimate for ’s contribution toward the sum , up to an additive factor of . Here, the operator rounds its non-negative argument up to the nearest integer power of , with the convention that . Specifically, our estimate is of the form , where is the unique integer for which

 (μℓ−1)⋅Power2[ϵ|L|⋅Wheavy(N)]  <  w(Pℓ[1ϵ+1,Nℓ])  ≤  μℓ⋅Power2[ϵ|L|⋅Wheavy(N)] . (3)
• Finally, out of the profit class in order of increasing weights, the vector picks the maximum number of items beyond the first ones such that their total weight is still within the estimate . That is,

 N(1)ℓ=max{k∈[1ϵ+1,|Pℓ|]:w(Pℓ[1ϵ+1,k])≤Eℓ} . (4)

#### Is “up-rounding” really rounding up?

Based on the above definitions, it is not entirely clear whether we are indeed rounding up each coordinate of to obtain , or whether some coordinates can actually decrease. To show that , we first observe that for , one clearly has by definition. For , due to our method for choosing in (4), we necessarily have , since by definition of . These observations also imply that and , meaning that the up-rounding operation preserves the light and heavy classes.

#### Key properties.

The next lemma summarizes the main properties of the up-rounding operation that will be utilized in our subsequent analysis.

The up-rounding operation satisfies the following properties:

1. [label=()]

2. Monotonicity: for every .

3. Weight beyond first items: .

For ease of presentation, since the proof is rather technical, its specifics are deferred to Appendix 5.1. At a high level, the above-mentioned properties stem from appropriately choosing the multiplier . By selecting a sufficiently small multiplier, that explicitly depends on the total weight quantity and the number of classes , we ensure that the excessive items due to our up-rounding operation only account for an fraction of the total weight, as stated in property 2. In contrast, arguing for the monotonicity of this operation, corresponding to property 1, is more challenging. Here, choosing the multiplier as an integer power of will play an important role, as further explained in Appendix 5.1.

### 2.6 The truncation operation: Definitions and properties

In what follows, given a utilization vector and its up-rounding , we explain how to define the truncation of the latter vector. Prior to presenting this construction, we remind the reader that the up-rounding operation was shown in Section 2.5 to be class-preserving, meaning that and .

#### Constructing N(2) via truncation.

Similarly to the up-rounding operation, each coordinate of the vector will be defined depending on whether its corresponding profit class is light or heavy. Specifically, out of each light class, picks exactly the same number of items as and do, that is, for every . However, for each heavy class , we will define by eliminating a certain number of items from . To formalize this notion, let be the number of items picked by from the profit class beyond the first items. Then, is obtained from by eliminating its last items, that is, .

#### Is truncation class-preserving?

Before turning our attention to specific structural properties of the newly obtained vector , it is worth pointing out that, similarly to up-rounding, the truncation operation is class-preserving. To verify this claim, we first observe that for , one clearly has by definition, implying that . In addition, to argue that each class remains heavy for , we should prove that none of the first items in will be eliminated. Put differently, the number of eliminated items, , does not exceed . For this purpose, we know that