Polynomial Time Instances for the IKHO Problem

Abstract

The Interactive Knapsacks Heuristic Optimization (IKHO) problem is a particular knapsacks model in which, given an array of knapsacks, every insertion in a knapsack affects also the other knapsacks, in terms of weight and profit. The IKHO model was introduced by Isto Aho to model instances of the load clipping problem. The IKHO problem is known to be APX-hard and, motivated by this negative fact, Aho exhibited a few classes of polynomial instances for the IKHO problem. These instances were obtained by limiting the ranges of two structural parameters, c and u, which describe the extent to which an insertion in a knapsack in uences the nearby knapsacks. We identify a new and broad class of instances allowing for a polynomial time algorithm. More precisely, we show that the restriction of IKHO to instances where (𝑐+2𝑢)/𝑐 is bounded by a constant can be solved in polynomial time, using dynamic programming.

1. Introduction

Interactive Knapsacks Heuristic Optimization problem (IKHO) is a particular knapsacks model in which, given an array of knapsacks, an insertion in a knapsack influences the nearest knapsacks, in terms both of weight and of profit. It was introduced by Aho in [1], for solving the load clipping problem arising in electricity management application. It belongs to the general framework of the Interactive Knapsacks problems (IK) (also defined in [1]) which has several other applications, for example, in electricity management, single and multiprocessor scheduling, and packing of 𝑛-dimensional items to different knapsacks. Since IKHO is NP-complete [1] and APX-hard [2], the research of polynomial time instances is very important. In [3], Aho introduces a few classes of such instances restricting the values of certain parameters of the problem: 𝑐 and 𝑢, which determine the dimension of the influence on other knapsacks caused by an insertion, and 𝐾, that limits the number of insertions. We keep on this line of investigation by adding a wide and significant class of polynomial time instances for the IKHO problem in the case when (𝑐+2𝑢)/𝑐 is bounded.

Intuitively, in IKHO, when we insert an item in a knapsack, this item is replicated (cloned) to the 𝑐 next knapsacks (hence forming a cloning block over 𝑐+1 consecutive knapsacks), and it causes an arbitrary but predetermined modification (radiation) of the weight and profit of the knapsacks at distance at most 𝑢 from the cloning block (on both sides of the cloning block). After a knapsack is involved in a cloning operation, we are not allowed to insert any other item in that knapsack. Therefore, the cloning blocks are disjoint. In this paper, we are mainly interested in the case where the ratio between the whole width 𝑐+2𝑢 of the influenced zone (cloning plus radiation zones) and the width 𝑐 of the cloning part is bounded by a constant 𝑟. We propose a dynamic programming algorithm based on a matrix of size 𝑂(𝑐^𝑟×𝐾), and having time complexity of 𝑂(𝑐^𝑟×𝑚×𝐾), where 𝑚 is the number of knapsacks and 𝐾 represents the maximum number of cloning block that we can insert in the knapsacks array.

In Section 2, we give the original formulation of the problem from [1] and we then simplify it to ease our exposition in later sections. In Section 3, we give the algorithm. In Section 4, we sharpen the complexity result. Finally, in Section 5, we design a memory saving version of that algorithm.

We conclude this section by defining some useful notation. Henceforth, we write 𝟎^𝑚 to denote a zero constant vector of length 𝑚, that is, 𝟎^𝑚_𝑖=0 for 𝑖=1,…,𝑚. Moreover, if 𝑥,𝑦∈{0,1}^𝑚, we write 𝑥⋅𝑦 to indicate the concatenation of the two binary strings. Furthermore, [𝑎,𝑏] always denotes a range of integers and, if 𝑎>𝑏, we assume that [𝑎,𝑏] is empty. In the same way, if 𝑎>𝑏, the notation for 𝑖=𝑎,…,𝑏 means for no 𝑖.

2. Formulation of the IKHO Problem

We are given an array of 𝑚 knapsacks, each one of capacity 𝑏_ℓ, for ℓ=1,…,𝑚. There is a single item that we are asked to insert at most 𝐾 times in the knapsacks array, where 𝐾 is a natural given as part of the input. The profit and weight of an insertion depend on the knapsack in which we insert for 𝑖=1,…,𝑚 the naturals 𝑤_𝑖 and 𝑝_𝑖 represent the weight and the profit of an insertion in the knapsack 𝑖. The main feature of  IK problems is that every insertion has also an influence on the weight and profit of the nearby knapsacks. In this way, the weight charged on and the profit relative to a knapsack are established by the insertions in all the knapsacks. To describe this mechanism, Aho introduces a function (called interactive function) 𝐼_𝑖 for each knapsack 𝑖=1,…,𝑚, that determines the interaction from a knapsack 𝑖 to every other knapsack. In particular, given naturals 𝑐 and 𝑢, for each knapsack 𝑖, we know that 𝐼_𝑖(ℓ)=1forknapsacksℓ∈[𝑖,𝑖+𝑐],𝐼_𝑖(ℓ)∈ℚarbitraryforknapsacksℓ∈[𝑖−𝑢,𝑖−1]∪[𝑖+𝑐+1,𝑖+𝑐+𝑢],𝐼_𝑖(ℓ)=0forallotherknapsacks.(1) The range [𝑖,𝑖+𝑐] is called cloning block and the range [𝑖−𝑢,𝑖−1]∪[𝑖+𝑐+1,𝑖+𝑐+𝑢]  radiation part. The role of the functions 𝐼_𝑖 gets clear in formulas (2)–(5).

The decision variables used to denote in which knapsacks we do the insertions are 𝑥_𝑖∈{0,1} for 𝑖=1,…,𝑚. Given in input 𝑚,𝑝_𝑖,𝑤_𝑖,𝑏_𝑖,𝑐,𝑢∈ℕ and 𝐾∈ℕ⧵{0}, an IKHO problem is to maximize^𝑚_𝑖=1𝑥^𝑖𝑚_ℓ=1𝐼_𝑖(ℓ)𝑝_ℓ(2)subjectto^𝑚_𝑖=1𝑥_𝑖𝐼_𝑖(ℓ)𝑤_𝑖≤𝑏_ℓ,forℓ=1,…,𝑚,(3)_𝑚_𝑖=1𝑥_𝑖≤𝐾,(4)𝑥_𝑗=0,for𝑖<𝑗≤𝑖+𝑐,when𝑥_𝑖=1,(5) where 𝑖=1,…,𝑚 in (5). Clearly, since a feasible 𝑥 must belong to {0,1}^𝑚, then at most one item may be put in each single knapsack. Moreover, notice that in Constraint (3), imposing that the knapsacks are not overfilled, 𝐼_𝑖(ℓ) is multiplied by the weight 𝑤_𝑖. Thus, when we insert in the knapsack 𝑖(𝑥_𝑖=1), the weight 𝑤_𝑖 is equivalently charged on the knapsacks ℓ∈[𝑖,𝑖+𝑐], for which 𝐼_𝑖(ℓ)=1. This is the reason of calling the range [𝑖,𝑖+𝑐] cloning block. Regarding the knapsacks in the radiation part [𝑖−𝑢,𝑖−1]∪[𝑖+𝑐+1,𝑖+𝑐+𝑢], we get that an arbitrary portion of the weight 𝑤_𝑖 is added or subtracted (since 𝐼_𝑖(ℓ) can be negative) to them. Similar operations are performed in the maximization function (2) with the profits 𝑝_ℓ. Furthermore, Constraint (4) specifies the maximum number of cloning blocks to be put into the knapsacks array, while Constraint (5) tells that the cloning blocks must be disjoint. The IKHO model is more widely explained and motivated in [1, 4].

2.1. Simplifying the Formulation

Our first step here is to simplify the formulation of the problem by making the notion of weight independent from the interaction functions, and the profit dependent only on the knapsack where we insert. This is accomplished by exploiting the transformation proposed by Aho in [2], in order to reduce IKHO to MDKP, an IPL formulation surveyed in [5]. We define 𝑝^_𝑖=^𝑚_ℓ=1𝐼_𝑖(ℓ)𝑝_ℓ,𝑤^_𝑖ℓ=𝐼_𝑖(ℓ)𝑤_𝑖,(6) so that 𝑝^_𝑖 represents the total profit of an insertion in the knapsack 𝑖, and 𝑤^_𝑖ℓ is the weight that an insertion in the knapsack 𝑖 charges over the knapsack ℓ. From the features of 𝐼_𝑖(ℓ) exposed in (1), it follows that 𝑤^_𝑖ℓ and 𝑝^_𝑖 are both rational numbers. Thus, notice that they can be also negative.

Now, we can reformulate the problem as follows: maximize^𝑚_𝑖=1𝑥_𝑖𝑝^_𝑖(7)subjectto^𝑚_𝑖=1𝑥_𝑖𝑤^_𝑖ℓ≤𝑏_ℓ,forℓ=1,…,𝑚,(4)and(5).(8) Henceforth we refer always to the latter formulation of the problem, since it simplifies the description of the algorithm.

Let us restate the behavior of parameter 𝑤^ as inherited by functions 𝐼_𝑖. For 𝑖=1,…,𝑚, we have that 𝑤^_𝑖ℓ=𝑤_𝑖(andthenitisconstant)forℓ∈[𝑖,𝑖+𝑐],𝑤^_𝑖ℓisarbitraryforℓ∈[𝑖−𝑢,𝑖−1]∪[𝑖+𝑐+1,𝑖+𝑐+𝑢],𝑤^_𝑖ℓ=0forallotherℓ∈[1,…,𝑚].(9)

2.2. Polynomial Time Instances

The classes of instances isolated by Aho are the following: (a) the instances with 𝑐=𝑢=0; (b)those with 𝐾=𝑂(1); (c)those with 𝑢=0; (d)those with 𝑐+2𝑢+1=𝑂(log(𝑚^𝛼)), for a constant 𝛼.

The restriction of IKHO obtained by considering only the instances in (a) corresponds to the situation in which there are no interactions, whence the decision on whether to insert an item can be taken independently on each knapsack. As for (b), notice that any instance of IKHO admits at most 𝑚^𝐾 feasible solutions, which is only a polynomial number of possibilities whenever 𝐾=𝑂(1). We refer to [3] for details on Aho's algorithm for instances of type (c) and (d).

In Section 3, we describe an algorithm for IKHO that has time complexity of 𝑂(𝑚×𝐾×𝑐^{(𝑐+2𝑢)/𝑐}). When (𝑐+2𝑢)/𝑐 is bounded by a constant, it clearly becomes a polynomial time algorithm. Indeed, note that the term 𝑐^{(𝑐+2𝑢)/𝑐} is polynomial also when 𝑐+2𝑢=𝑂(ln(𝑚^𝛼)), for a constant 𝛼. In fact, 𝑐^{(𝑐+2𝑢)/𝑐}=(𝑐^1/𝑐)^𝑐+2𝑢, and 𝑐^1/𝑐 is a decreasing function on 𝑐. Therefore, our results imply those reported in (a), (c), and (d).

3. The Algorithm

In the following, 𝐴=(𝑚,𝑏,𝑐,𝑢,𝑤^,𝑝^,𝐾) always denotes the input IKHO instance. Let 𝐿∶=𝑐+2𝑢. A binary string 𝑠∈{0,1}^𝐿 is called a signature if it obeys Constraint (5), that is, if 𝑠_𝑖+𝑠_𝑗≤1 for all 𝑖,𝑗∈[1,𝐿] such that 1≤|𝑖−𝑗|≤𝑐. We denote by 𝒮 the set of all signatures.

Given a solution 𝑥∈{0,1}^𝑚, |𝑥|∶=∑^𝑚_𝑖=1𝑥_𝑖 denotes the number of insertions prescribed by 𝑥. Moreover, for each ℓ∈[1,𝑚], 𝑤(𝑥,ℓ)∶=∑^𝑚_𝑖=1𝑥_𝑖𝑤^_𝑖ℓ is the weight charged on the knapsack ℓ by the solution 𝑥. Then, we say that a solution 𝑥 obeys the capacity constraint (Constraint (8)) on the knapsacks [𝛼,𝛽] if and only if 𝑤(𝑥,ℓ)≤𝑏_ℓ for each ℓ∈[𝛼,𝛽]. Furthermore, we write 𝑥⊢(𝑠,ℎ) when 𝑥_ℎ+𝑗=𝑠_𝑗 for each 𝑗∈[1,𝐿] and 𝑥_𝑖=0 for each 𝑖∈[1,ℎ], that is, when 𝑥  starts with the signature 𝑠 in the knapsacks [ℎ+1,ℎ+𝐿], whence having the form 𝑥=0⋯0_ℎ𝑠𝑥′.

3.1. The Subproblems of Our DP Approach

Given a natural 𝑘≤𝐾, a natural ℎ≤𝑚−𝐿, and a signature 𝑠, we consider a modified problem Sub[𝑘,ℎ,𝑠], whose solutions are those 𝑥∈{0,1}^𝑚 which obey 𝑥⊢(𝑠,ℎ),(10)𝑤(𝑥,ℓ)≤𝑏_ℓ∀ℓ∈[ℎ+𝑐+𝑢+1,𝑚],(11)|𝑥|≤𝑘,and(5).(12) The objective function is the same as in the IKHO formulation. The differences between the IKHO problem and the above-defined subproblems are in the additional parameters 𝑠, ℎ, 𝑘 and their use in the constraints. (i)Constraint (10) fixes the first insertions in compliance to the signature 𝑠. (ii)The range on which we check the capacity constraint in (11) is [ℎ+𝑐+𝑢+1,𝑚], a subset of the range [1,𝑚] checked in IKHO. (iii)By Constraint (12), we can do at most 𝑘 insertions. Notice that in general (12) is more restrictive than (4).

In the following, we denote by 𝒳[𝐴] the space of solutions to the IKHO instance 𝐴, and by 𝒳[𝑘,ℎ,𝑠] the space of solutions to the modified problem Sub[𝑘,ℎ,𝑠]. Moreover, let opt[𝐴] be the maximum value of a solution in 𝒳[𝐴] and opt[𝑘,ℎ,𝑠] the maximum value of a solution in 𝒳[𝑘,ℎ,𝑠]. It is assumed that opt[𝑘,ℎ,𝑠]=−∞ when 𝒳[𝑘,ℎ,𝑠] is empty.

3.2. The Dynamic Programming Algorithm

Our dynamic programming approach is based on Lemmas 1 and 2, whose proofs are given later in this subsection. In particular, Lemma 1 shows how to read out an optimal solution to the IKHO instance, from the optimal solutions to the subproblems.

Lemma 1. Let 𝒮₀⊆𝒮 be the set of the signatures 𝑠 such that 𝑦=𝑠⋅𝟎^𝑚−𝐿 obeys the capacity constraint on all knapsacks ℓ∈[1,𝑐+𝑢]. Then, opt[𝐴]=max_𝑠∈𝒮0opt[𝐾,0,𝑠].(13) Indeed, 𝒳[𝐴]=⋃_𝑠∈𝒮0𝒳[𝐾,0,𝑠].

Lemma 2 explains how to recursively solve the subproblems. We need some additional notation. Given 𝑥∈{0,1}^𝑚, 𝑏∈{0,1}, for 𝑖=1,…,𝑚, we write 𝑥+(𝑏,𝑖) to denote the binary string obtained from 𝑥 by setting its 𝑖-th element to 𝑏. Moreover, if 𝑋⊆{0,1}^𝑚, we let 𝑋+(𝑏,𝑖)∶={𝑥+(𝑏,𝑖)∶𝑥∈𝑋}. Furthermore, for each 𝑏∈{0,1}, and ℎ∈[0,𝑚−𝐿], a signature 𝑠∈𝒮 is called (ℎ,𝑏)-good if 𝑧∶=𝟎^ℎ⋅𝑠⋅𝑏⋅𝟎^{𝑚−ℎ−𝐿−1} obeys the capacity constraint for the knapsack ℎ+𝑐+𝑢+1 and if 𝑠^∶=(𝑠₂,𝑠₃,…,𝑠_𝐿,𝑏)∈𝒮.

Lemma 2. For 𝑘=1,…,𝐾, ℎ=0,…,𝑚−𝐿−1, 𝑠∈𝒮, opt[𝑘,ℎ,𝑠]=max_{𝑏∈{0,1}∶𝑠is(ℎ,𝑏)-good}opt×𝑘−𝑠₁,ℎ+1,𝑠^∶=𝑠₂,𝑠₃,…,𝑠_𝐿,𝑏+𝑠₁𝑝^_ℎ+1.(14) Indeed, 𝒳[𝑘,ℎ,𝑠]=_{𝑏∈{0,1}∶𝑠}_{is(ℎ,𝑏)-good}𝒳𝑘−𝑠₁,ℎ+1,𝑠^∶=𝑠₂,𝑠₃,…,𝑠_𝐿,𝑏+𝑠₁,ℎ+1.(15)

The base for the recursion, that is, the cases where ℎ=𝑚−𝐿 and 𝑘=0, is handled in Section 3.3.

In order to prove Lemmas 1 and 2, let us begin by pointing out some basic facts that directly derive from the IKHO formulation. Observations 1 and 2 play an important role in the formal proofs of these lemmas. For this reason, these observations and their proofs are visualized in Figures 1 and 2, respectively.

Figure 1 

Representing Observation 1. The gray area indicates where 𝑥 is equal to 𝑦, that is, the knapsacks [1,𝑎]. The arrow represents the left most possible radiation as starting from the left most possible different bit. Since this radiation cannot reach the knapsacks [1,𝑎−𝑢], then, for ℓ∈[1,𝑎−𝑢], 𝑤(𝑥,ℓ) and 𝑤(𝑦,ℓ) cannot differ as they depend only on the common bits [1,𝑎].

Figure 2 

Representing Observation 2.

Observation 1. Assume 𝑎>𝑢. Let 𝑥,𝑦∈{0,1}^𝑚 such that 𝑥_𝑖=𝑦_𝑖 for 𝑖=1,…,𝑎. Then, for each ℓ≤𝑎−𝑢, 𝑥 satisfies the capacity constraint if and only if 𝑦 satisfies it. Indeed, for each ℓ≤𝑎−𝑢, 𝑤(𝑥,ℓ)=𝑤(𝑦,ℓ).

Proof. Let ℓ≤𝑎−𝑢. Remember that 𝑤(𝑥,ℓ)∶=∑^𝑚_𝑖=1𝑥_𝑖𝑤^_𝑖ℓ. However, by (9), 𝑤^_𝑖ℓ=0 for ℓ<𝑖−𝑢, that is, when 𝑖>𝑙+𝑢. Moreover, 𝑥_𝑖=𝑦_𝑖 for 𝑖=1,…,ℓ+𝑢, since ℓ+𝑢≤𝑎. Therefore, 𝑤(𝑥,ℓ)∶=^𝑚_𝑖=1𝑥_𝑖𝑤^_𝑖ℓ=^ℓ+𝑢_𝑖=1𝑥_𝑖𝑤^_𝑖ℓ=^ℓ+𝑢_𝑖=1𝑦_𝑖𝑤^_𝑖ℓ=^𝑚_𝑖=1𝑦_𝑖𝑤^_𝑖ℓ=∶𝑤(𝑦,ℓ).(16)

Observation 2 covers the left/right-reverse situation.

Observation 2. Assume 𝑎≤𝑚−𝑐−𝑢. Let 𝑥,𝑦∈{0,1}^𝑚 such that 𝑥_𝑖=𝑦_𝑖 for each 𝑖=𝑎,…,𝑚. Then, for each ℓ≥𝑎+𝑐+𝑢, 𝑥 satisfies the capacity constraint if and only if 𝑦 satisfies it. Indeed, for each ℓ≥𝑎+𝑐+𝑢, 𝑤(𝑥,ℓ)=𝑤(𝑦,ℓ).

Proof. Let ℓ≥𝑎+𝑐+𝑢. By (9), 𝑤^_𝑖ℓ=0 for ℓ>𝑖+𝑐+𝑢, that is, when 𝑖<𝑙−𝑐−𝑢. Moreover, 𝑥_𝑖=𝑦_𝑖 for 𝑖=ℓ−𝑐−𝑢,…,𝑚, since ℓ−𝑐−𝑢≥𝑎. Therefore, 𝑤(𝑥,ℓ)∶=^𝑚_𝑖=1𝑥_𝑖𝑤^_𝑖ℓ=^𝑚_{𝑖=ℓ−𝑐−𝑢}𝑥_𝑖𝑤^_𝑖ℓ=^𝑚_{𝑖=ℓ−𝑐−𝑢}𝑦_𝑖𝑤^_𝑖ℓ=^𝑚_𝑖=1𝑦_𝑖𝑤^_𝑖ℓ=∶𝑤(𝑦,ℓ).(17)

Now, we are ready to prove Lemmas 1 and 2.

Proof of Lemma 1. First, let us show that every feasible solution to IKHO is a feasible solution to one of the subproblems Sub[𝐾,0,𝑠] for an 𝑠∈𝒮₀. Clearly, for each 𝑥∈𝒳[𝐴], taking 𝑠∶=(𝑥₁,𝑥₂,…,𝑥_𝐿), we get that 𝑥∈𝒳[𝐾,0,𝑠]. By exploiting Observation 1 with 𝑎=𝐿, we get that 𝑦∶=𝑠⋅𝟎^𝑚−𝐿 obeys the capacity constraint on knapsacks [1,𝑐+𝑢], and then 𝑠∈𝒮₀. To prove the opposite inclusion, take 𝑠∈𝒮₀ and 𝑥∈𝒳[𝐾,0,𝑠]. We show that 𝑥∈𝒳[𝐴]. Constraint (4), Constraint (5), and the capacity constraint on knapsacks [𝑐+𝑢+1,𝑚] are clearly satisfied. Since 𝑠∈𝒮₀, Observation 1 let us verify the capacity constraint on knapsacks [1,𝑐+𝑢].

Lemma 2 directly follows from the two opposite inclusions, that we show separately. While reading these proofs, Figure 3 can be useful to visualize the structure of the vectors 𝑥,𝑦 involved in the proofs.

Figure 3 

Building a feasible solution to Sub[𝑘,ℎ,𝑠]. In order to construct a feasible solution 𝑥 to the current subproblem Sub[𝑘,ℎ,𝑠], we exploit a feasible solution 𝑦 to one of the subsequent subproblems Sub[𝑘−𝑠1,ℎ+1,𝑠∶=(𝑠2,𝑠3,…,𝑠𝐿,𝑏)], for a 𝑏∈{0,1}. Clearly, 𝑥 must satisfy the capacity constraint on the knapsacks [ℎ+𝑐+𝑢+1,𝑚]. Moreover, notice that the radiation from the bit 𝑠1 does not reach the knapsacks after ℎ+𝑐+𝑢+1, and then, for those knapsacks, 𝑥 satisfies the capacity constraint only if 𝑦 does. Therefore, we need to check the capacity constraint only for the knapsack ℎ+𝑐+𝑢+1. Furthermore, the bits after 𝑏 are not involved when we check the capacity constraint on that knapsack. Thus, in order to check the capacity constraint on the knapsack ℎ+𝑐+𝑢+1, it is enough to know the bits of the string 𝑠⋅𝑏. Notice that, for a signature 𝑠, 𝐿 is the smallest width that holds the properties we showed above.

Proof of Lemma 2. First, we show that 𝒳[𝑘,ℎ,𝑠]⊆_{𝑏∈{0,1}∶𝑠}_{is(ℎ,𝑏)-good}𝒳𝑘−𝑠₁,ℎ+1,𝑠^∶=𝑠₂,𝑠₃,…,𝑠_𝐿,𝑏+𝑠₁,ℎ+1.(18)
Proof. Suppose 𝑥∈𝒳[𝑘,ℎ,𝑠]. Let 𝑏∶=𝑥_ℎ+𝐿+1. The inclusion follows by two facts: (a)𝑠 is (ℎ,𝑏)-good; (b)𝑥∈𝒳[𝑘−𝑠₁,ℎ+1,𝑠^]+(𝑠₁,ℎ+1). Take 𝑧∶=𝟎^ℎ⋅𝑠⋅𝑏⋅𝟎^{𝑚−ℎ−𝐿−1}. Since 𝑥 obeys the capacity constraint on knapsacks [ℎ+𝑐+𝑢+1,𝑚] and 𝑥_𝑖=𝑧_𝑖 for 𝑖=1,…,ℎ+𝐿+1, by exploiting Observation 1 with 𝑎=ℎ+𝐿+1, we get that 𝑧 satisfies the capacity constraint on the knapsack ℎ+𝑐+𝑢+1. Clearly, 𝑠^∶=(𝑠₂,𝑠₃,…,𝑠_𝐿,𝑏) satisfies Constraint (5), being a substring of 𝑥. Hence, 𝑠 is (ℎ,𝑏)-good.
In order to show that 𝑥∈𝒳[𝑘−𝑠₁,ℎ+1,𝑠^]+(𝑠₁,ℎ+1), we take 𝑦∶=𝑥+(0,ℎ+1) and we show that 𝑦∈𝒳[𝑘−𝑠₁,ℎ+1,𝑠^]. By following the subproblems definition, it is simple to verify that 𝑦 obeys Constraint (10), (12), and (5) of Sub[𝑘−𝑠₁,ℎ+1,𝑠^]. Moreover, since 𝑥 satisfies the capacity constraint for each ℓ∈[ℎ+𝑐+𝑢+1,𝑚], by applying Observation 2 with 𝑎=ℎ+2, we get that 𝑦 satisfies the capacity constraint over the knapsacks [ℎ+𝑐+𝑢+2,𝑚], and then 𝑦 obeys Constraint (11) too.

Second, we prove that _{𝑏∈{0,1}∶𝑠}_{is(ℎ,𝑏)-good}𝒳𝑘−𝑠₁,ℎ+1,𝑠^∶=𝑠₂,𝑠₃,…,𝑠_𝐿,𝑏+𝑠₁,ℎ+1⊆𝒳[𝑘,ℎ,𝑠].(19)

Proof. Take a 𝑏∈{0,1} such that 𝑠 is (ℎ,𝑏)-good and a 𝑦∈𝒳[𝑘−𝑠₁,ℎ+1,𝑠′∶=𝑠₂,𝑠₃,…,𝑠_𝐿,𝑏]. We will show that 𝑥∶=𝑦+(𝑠₁,ℎ+1)∈𝒳[𝑘,ℎ,𝑠]. Constraint (10) and (12) of Sub[𝑘,ℎ,𝑠] easily follow from subproblems definition. Moreover, since 𝑦 satisfies Constraint (5) and 𝑠∈𝒮, then 𝑥 satisfies Constraint (5).
It remains to verify Constraint (11). Since 𝑠 is (ℎ,𝑏)-good, then 𝑧∶=𝟎^ℎ⋅𝑠⋅𝑏⋅𝟎^{𝑚−ℎ−𝐿−1} obeys the capacity constraint on the knapsack ℎ+𝑐+𝑢+1. By applying Observation 1 with 𝑎=ℎ+𝐿+1, we derive that also 𝑥 obeys the capacity constraint on that knapsack. Moreover, since 𝑦∈𝒳[𝑘−𝑠₁,ℎ+1,𝑠^], then 𝑦 obeys the capacity constraint on the knapsacks [ℎ+𝑐+𝑢+2,𝑚]. Since 𝑦_𝑖=𝑥_𝑖 for 𝑖=(ℎ+2,…,𝑚), by Observation 2,  𝑥 obeys the capacity constraint also for the knapsacks [ℎ+𝑐+𝑢+2,𝑚].

3.3. The Base of the Recursion

We have two base cases. Observation 3 handles the case when ℎ=𝑚−𝐿, while Observation 4 treats the case when 𝑘=0.

Observation 3. Consider ℎ=𝑚−𝐿, for all 𝑘=1,…,𝐾, and 𝑠∈𝒮. Moreover, let 𝑧∶=𝟎^ℎ⋅𝑠. If |𝑧|≤𝑘and 𝑤(𝑧,ℓ)≤𝑏_ℓ for each ℓ∈[𝑚−𝑢+1,𝑚],then opt[𝑘,ℎ,𝑠]=∑^𝑚_𝑖=1𝑧_𝑖𝑝^_𝑖. Otherwise, opt[𝑘,ℎ,𝑠]=−∞.

Proof. Clearly, since ℎ+𝐿=𝑚 and by Constraint (10), there cannot exist a solution to Sub[𝑘,ℎ,𝑠] different from 𝑧. Moreover, notice that ℎ+𝑐+𝑢+1=𝑚−𝑢+1.

Observation 4. Consider 𝑘=0, for all ℎ=0,…,𝑚−𝐿, and 𝑠∈𝒮. If 𝑠=𝟎^𝐿, then opt[𝑘,ℎ,𝑠]=0,Otherwise opt[𝑘,ℎ,𝑠]=−∞.

Proof. Clearly, by Constraint (12), 𝟎^𝑚 can be the only solution to Sub[0,ℎ,𝑠].

4. Complexity

In this section, we prove Lemma 3.

Lemma 3. Let 𝑟 be a constant such that 𝐿/𝑐 is bounded by 𝑟 when 𝑐>0, and 𝐿 is bounded by 𝑟 when 𝑐=0. The above algorithm takes time and space of 𝑂(𝑐^𝑟×𝑚×𝐾).

Clearly, our algorithm exploits a three-dimensional matrix for storing the values opt[𝑘,ℎ,𝑠], for 𝑘=1,…,𝐾, ℎ=0,…,𝑚−𝐿, and 𝑠∈𝒮. We also need a matrix of the same size which traces, for each subproblem Sub[𝑘,ℎ,𝑠], the subsequent subproblem used to compute opt[𝑘,ℎ,𝑠]. This makes us rebuild the optimum solution at the end. The space complexity of the algorithm then is 𝑂(𝐾×𝑚×|𝒮|). We need to rate the value of |𝒮|, but first let us to compute the time complexity.

In order to evaluate the base case of our dynamic programming algorithm, we first refer to Observation 3. Clearly, for 𝑘<|𝑠|, opt[𝑘,ℎ,𝑠]=−∞, because there must be at least |𝑠| insertion in a solution that starts with the signature 𝑠. Moreover, since 𝑧∶=𝟎^ℎ⋅𝑠 is the only feasible solution to Sub[𝑘,ℎ,𝑠], it is clear that, for each 𝑘>|𝑠|, opt[𝑘,ℎ,𝑠]=opt[|𝑠|,ℎ,𝑠], by Constraint (12). Therefore, we have to compute only for 𝑘=|𝑠|, and then, the number of base case subproblems to be computed is only |𝒮|. Since 𝑠∈{0,1}^𝐿, 𝐿 is the time needed for computing both the profit of 𝑧 and 𝑤(𝑧,ℓ), for an ℓ∈[𝑚−𝑢+1,𝑚]. Then, to check the capacity constraint on all the knapsacks [𝑚−𝑢+1,𝑚], we need 𝑢×𝐿 computations. Thus, the base case ℎ=𝑚−𝐿 can be computed in time of 𝑂(|𝒮|×𝐿×𝑢). About the base case 𝑘=0, as handled by Observation 4, note that if we codify the signatures 𝑠∈𝒮 (a such codify is given in Section 4.2), we can check the condition 𝑠=𝟎^𝐿 in 𝑂(1). Regarding the general case, by (14), for solving a subproblem, we have to check if 𝑠 is (ℎ,𝑏)-good, for 𝑏=0,1. To check if 𝑧∶=𝟎^ℎ⋅𝑠⋅𝑏⋅𝟎^{𝑚−ℎ−𝐿−1} satisfies the capacity constraint on the knapsack ℎ+𝑐+𝑢+1, and if 𝑠^∈𝒮, we spend 𝑂(𝐿) computations. Since the number of subproblems is 𝐾×(𝑚−𝐿)×|𝒮|, we need 𝑂(|𝒮|×𝑚×𝐿×𝐾) time to fill the matrix opt. Moreover, by (13), we have to scan over the 𝑠∈𝒮₀ in order to find the maximum value of opt[𝐾,0,𝑠]. Clearly, |𝒮₀|≤|𝒮|, but we need 𝐿×(𝑐+𝑢) computations to check the capacity constraints on all knapsacks ℓ∈[1,𝑐+𝑢], because each signature 𝑠 has width 𝐿. Thus, we spend 𝑂(|𝒮|×𝐿²) computations, to find opt[𝐴]. Furthermore, rebuilding the best solution takes 𝑂(𝑚) time. Therefore, the part in which we recursively compute the subproblems leads the complexity of the entire algorithm. It depends on the value of |𝒮|, as well as the space complexity. In Section 4.1, we give an estimate of this value. Moreover, in Section 4.2, we show an ordering of the set 𝒮, that permits us to check the capacity constraint on a knapsack in constant time.

4.1. Estimating |𝒮|

In the case where 𝑐 is a constant, we can directly estimate |𝒮|.

Observation 5. If 𝑐 is a constant, then |𝒮|=𝑂(1).

Proof. Clearly, |𝒮|≤2^𝐿, because the number of binary strings 𝑠∈{0,1}^𝐿 is 2^𝐿. Moreover, when 𝑐=0, we supposed 𝐿 constant. When 𝑐>0, since 𝐿/𝑐≤𝑟, we get that 𝐿≤𝑟𝑐, with constant 𝑟 and 𝑐.

For nonconstant values of 𝑐, let us find a general form for |𝒮|. Let 𝑆_𝑐(𝑛) denote the number of binary strings 𝑠∈{0,1}^𝑛 such that 𝑠 obeys Constraint (5). Note that Constraint (5) contains the parameter 𝑐. When 𝑛∈[0,𝑐], we have 𝑛 places where to insert, and at most one insertion is possible by Constraint (5). Moreover, we have to count the string with no insertions. Thus, we get that 𝑆_𝑐(𝑛)=𝑛+1 for all 𝑛∈[0,𝑐]. For greater values of 𝑛, we refer to the recursion shown in Figure 4. If the first bit of 𝑠 is 0, the choice of the following bits is not influenced. Therefore, it is enough to find the number of strings 𝑠∈{0,1}^𝑛−1 such that 𝑠 obeys Constraint (5), that is exactly 𝑆_𝑐(𝑛−1). If the first bit is 1, by Constraint (5), the following 𝑐 bits are necessarily 0’s. In this case, we continue to choose after the 𝑐+1-th bit. Thus, we have 𝑆_𝑐(𝑛−𝑐−1) ways to choose the remaining bits. Therefore, we can express 𝑆_𝑐(𝑛) by the recurrence equation: 𝑆_𝑐(𝑛)=𝑆_𝑐(𝑛−1)+𝑆_𝑐(𝑛−𝑐−1),𝑆_𝑐(𝑛)=𝑛+1∀𝑛∈[0,𝑐].(20)

Figure 4 

The influence of the first bit choice.

Lemma 4 gives a general estimate of the recurrence 𝑆_𝑐(𝑛), in order to bound |𝒮| for nonconstant values of 𝑐.

Lemma 4. Let 𝑐≥𝑒. For each 𝑛≥𝑐, 𝑆_𝑐(𝑛)≤((𝑐+1)/𝑐)𝑐^𝑛/𝑐.

Proof. We prove the claim by induction on 𝑛, and we postpone to the appendix the proof of the base of the induction, that is, the case 𝑐≤𝑛≤2𝑐. For 𝑛>2𝑐, we have the step of induction. Clearly, 𝑆_𝑐(𝑛)=𝑆_𝑐(𝑛−1)+𝑆_𝑐(𝑛−𝑐−1)≤𝑐+1𝑐𝑐^{(𝑛−1)/𝑐}+𝑐+1𝑐𝑐^{(𝑛−𝑐−1)/𝑐}=𝑐+1𝑐𝑐^{(𝑛−1)/𝑐}+𝑐^{(𝑛−𝑐−1)/𝑐}=𝑐+1𝑐𝑐^{(𝑛−𝑐−1)/𝑐}1+𝑐^𝑐/𝑐=𝑐+1𝑐𝑐^{(𝑛−𝑐−1)/𝑐}(1+𝑐)=𝑐+1𝑐𝑐^𝑛/𝑐(1+𝑐)𝑐^{(𝑐+1)/𝑐}.(21) Hence, it is sufficient to show that (1+𝑐)/𝑐^{(𝑐+1)/𝑐}≤1 or equivalently 1+𝑐≤𝑐^{(𝑐+1)/𝑐}. Since 𝑐^{(𝑐+1)/𝑐}=𝑐⋅𝑐^1/𝑐, it remains to show that (1+1/𝑐)≤𝑐^1/𝑐.
We know that 𝑒^𝑥≥𝑥+1 for each real 𝑥. By substituting 𝑥 with 1/𝑐 and noticing that 𝑐≥𝑒, we get that (1+1/𝑐)≤𝑐^1/𝑐.

Since 𝐿=𝑐+2𝑢≥𝑐, we can apply Lemma 4 to deduce that |𝒮|=𝑆_𝑐(𝐿)=𝑂(𝑐^𝐿/𝑐), as (𝑐+1)/𝑐≤2 for 𝑐>0. Therefore, when 𝐿/𝑐 is bounded by a constant 𝑟, we get |𝒮|=𝑂(𝑐^𝑟).

4.2. Ranking the Set 𝒮

We use Recurrence (20) to define a function pos∶𝒮→[0,|𝒮|−1], which provides a unique index for each signature, and hence, it gives a ranking for the set 𝒮.

Definition 5. For each 𝑠∈𝒮, pos(𝑠)∶=^𝐿_𝑖=1𝑠_𝑖⋅𝑆_𝑐(𝐿−𝑖).(22)

Note that 𝑆_𝑐(𝐿−𝑖) is the number of signatures having length 𝐿−𝑖, and it is equivalent to the number of signatures of length 𝐿−𝑖+1 that start with a 0. Hence, as illustrated in Figure 5, in the step of the sum where 𝑖=1, we intend to place the signatures with 𝑠₁=1 after all the signatures with 𝑠₁=0, that are exactly 𝑆_𝑐(𝐿−1). For 𝑖=2,…,𝐿, we do recursively the same, locating substrings of length 𝐿−𝑖.

Figure 5 

Ordering the signatures.

Conversely, given an integer 𝑝∈[0,|𝑆|−1], the unranking procedure is the following. Take 𝑠∶=𝟎^𝐿. For 𝑖=1,…,𝐿, if 𝑝≥𝑆_𝑐(𝐿−𝑖), set 𝑠_𝑖=1 and 𝑝∶=𝑝−𝑆_𝑐(𝐿−𝑖).

Evidently, in order to efficiently perform such ordering on the set 𝒮, we need to compute and store the recurrence 𝑆_𝑐(𝑛), for 𝑛=1,…,𝐿−1, at the beginning of the algorithm. This takes 𝑂(𝐿) time and space, whereas the ranking and unranking operations take 𝑂(𝐿) time.

Indeed, we can avoid to encode and decode the signatures for the computation of each subproblem. This can be done by initializing a table at the beginning of the algorithm, that stores, for each position pos(𝑠^) relative to a signature 𝑠^, a list of the bits that are changed from the previous signature 𝑠, that is, the signature having pos(𝑠)=pos(𝑠^)−1. It is easy to verify the following procedure finds the next signature from the previous one (it works similarly to the function that increments a binary counter, but considering Constraint (5)). (i)Scan the previous string 𝑠 starting from the least significant bit (right most) and find the first range of 𝑐+1 consecutive 0’s, or a range of consecutive 0’s that includes the most significant bit (left most). (ii)If such a range exists, the next string is obtained by setting to 1 the right most bit of the range, and by setting to 0 all the bits at the right of the range. (iii)If such a range does not exist, 𝑠 is the last signature.

Above all, observe that, by Constraint (5), there are at most 𝐿/(𝑐+1) insertions in a signature 𝑠∈|𝒮|, and we know that 𝐿/(𝑐+1)≤𝐿/𝑐≤𝑟. Therefore, for every kind of ranking for the set 𝒮, the number of the bits changing between two adjacent signatures is 𝑂(𝑟). Thus, if we know the changing bits from a signature 𝑠 to the next 𝑠^, we can use an incremental approach for computing the value 𝑤(𝑠^,ℓ), from 𝑤(𝑠,ℓ), in constant time. This allows us to check in constant time the capacity constraints of the (ℎ,𝑏)-goodness (14), those regarding the definition of the set 𝒮₀ (13), and when computing the base case (Observation 3). Note that also Constraint (5) of the (ℎ,𝑏)-goodness can be computed in 𝑂(𝑟) with the same technique.

Moreover, note that when computing the matrix opt, if we place the cycle on the variable 𝑠, externally to the cycle on the variable 𝑘, we can clearly find the next signature and check the capacity constraints only once every 𝐾 subproblems. In this way, the cost of finding the next signature is made inessential.

Thus, we can conclude that our algorithm has time and space complexity of 𝑂(𝑐^𝑟×𝑚×𝐾).

5. Memory Saving Version

Consider (14). Given an ℎ∈[1,𝑚−𝐿−1], in order to compute opt[𝑘,ℎ,𝑠] for each 𝑠∈𝒮 and 𝑘≤𝐾, we need only the elements having ℎ=ℎ+1 of the matrix opt. Moreover, by (13), only the elements with ℎ=0 are required for computing opt[𝐴]. Thus, in order to work out the profit of a best solution, we only need 𝑂(|𝒮|×𝐾) space. Unfortunately, this simplification does not apply to the matrix used to compute the best solution.

In [6], Hirschberg showed an elegant and practical space reduction method for the longest common subsequence problem, which works for many dynamic programming algorithms (well exposed also in [7]). In general, this method allows to compute an optimal solution, taking as much space and time as if we had only to compute the optimal solution value. This is accomplished by exploiting the equation which handles the recursion in the original algorithm (in our case (14)). Its space policy exploits the space improvement mentioned at the beginning of this section.

Conceptually, the basic idea of the method is to halve a dimension of the dynamic programming matrix and find how the best solution is divided in the other dimensions. This permits the two halves obtained to be solved separately and recursively in the same way. In order to apply this method to our algorithm, we follow the next steps. (i)We halve the knapsack array. (ii)We find how many insertions of the best solution are placed in each half of the knapsack array. (iii)We locate a number of insertions placed around the middle of the knapsack array. This allows us to break up the IKHO problem in two independent subproblems, which are then solved recursively.

Notice that, in the last sentence, the word subproblems does not refer to the subproblems Sub[𝑘,ℎ,𝑠] defined in Section 3.

In Section 5.1, we implement this idea. In Section 5.2, we show that the new defined algorithm decreases the space complexity to 𝑂(|𝒮|×𝐾), without increasing the time complexity.

5.1. The Algorithm

In the following, we write 𝑥⊢^𝑅(𝑠,ℎ) when 𝑥_{ℎ−𝐿−1+𝑗}=𝑠_𝑗 for each 𝑗∈[1,𝐿] and 𝑥_𝑖=0 for each 𝑖∈[ℎ,𝑚], that is, when 𝑥  ends with the signature 𝑠 in the knapsacks [ℎ−𝐿,ℎ−1].

Given a natural 𝑘≤𝐾, a natural ℎ∈[𝐿+1,𝑚+1], and a signature 𝑠, we consider a modified problem Sub^𝑅[𝑘,ℎ,𝑠] whose solutions are those 𝑥∈{0,1}^𝑚 which obey 𝑥0𝑥00090⊢^𝑅(𝑠,ℎ),𝑤(𝑥,ℓ)≤𝑏_ℓ∀ℓ∈[1,ℎ−𝑢−1],|𝑥|≤𝑘,and(5).(23) The subproblems Sub^𝑅[𝑘,ℎ,𝑠] are simply the symmetrical transposition of the subproblems Sub[𝑘,ℎ,𝑠]. The only significant difference is that we check the capacity constraints in the range [1,ℎ−𝑢−1], that is, not symmetrical to the range [ℎ+𝑐+𝑢+1,𝑚]. This dissimilarity is caused by the fact that also the radiations produced by an insertion are not symmetrical too (see (9)).

We denote by 𝒳^𝑅[𝑘,ℎ,𝑠] the space of the feasible solutions to the modified problem Sub^𝑅[𝑘,ℎ,𝑠]. Moreover, opt^𝑅[𝑘,ℎ,𝑠] is the maximum profit of a solution in 𝒳^𝑅[𝑘,ℎ,𝑠] when 𝒳^𝑅[𝑘,ℎ,𝑠] is not empty, and opt^𝑅[𝑘,ℎ,𝑠]=−∞ when 𝒳^𝑅[𝑘,ℎ,𝑠] is empty. Notice that, since the subproblems Sub and Sub^𝑅 are symmetrical, the properties proved for opt hold symmetrically for opt^𝑅, bringing some adjustments due to the fact that the radiations are not exactly symmetrical. Thus, for computing the matrix opt^𝑅, we take the same space and time needed for computing the matrix opt, that is, 𝑂(|𝒮|×𝐾) space and 𝑂(𝑚×|𝒮|×𝐾) time.

In the following, let |𝑠| to be the number of insertions in a signature 𝑠. For each 𝑠∈𝒮, and for ℎ=0,…,𝑚−𝐿, let 𝑝(𝑠,ℎ)∶=∑^𝐿_𝑖=1𝑠_𝑖𝑝^_ℎ+𝑖. Clearly, this function holds for each knapsack ℎ the profit caused by placing the signature 𝑠 in the knapsacks [ℎ+1,…,ℎ+𝐿]. Moreover, for 𝛼,𝛽=1,…,𝑚, and 𝑦∈{0,1}^𝑚, let 𝑦(𝛼,𝛽) be the substring of 𝑦 composed by the elements in the range [𝛼,𝛽] (we assume 𝑦(𝛼,𝛽) is empty when 𝛼<𝛽). Furthermore, for 𝑘,𝑘^≤𝐾, for each signature 𝑠, for ℎ=0,…,𝑚−𝐿 and ℎ^=𝐿+1,…,𝑚−𝐿 such that ℎ^−ℎ=𝐿+1, let 𝒳^𝑅[𝑘^,ℎ^,𝑠]⊗𝒳[𝑘,ℎ,𝑠]∶={𝑦^(1,ℎ)⋅𝑠⋅𝑦(ℎ^,𝑚)∶𝑦′∈𝒳^𝑅[𝑘^,ℎ^,𝑠],𝑦∈𝒳[𝑘,ℎ,𝑠]}. This new operator defines a new space of solutions given by the concatenation of the feasible solutions of two symmetrical subproblems. Notice that the signature 𝑠 represents the joining point when concatenating the two strings. This situation is represented in Figure 6, which is also useful to visualize the proof of Lemma 6, which represents the main innovation on our algorithm.

Figure 6 

Joining 𝒳𝑅[𝑘,ℎ,𝑠] with 𝒳[𝑘,ℎ,𝑠]. The solution 𝑦 belongs to the space 𝒳[𝑘,ℎ,𝑠], while 𝑦∈𝒳𝑅[𝑘,ℎ,𝑠]. Note that the knapsacks [ℎ+𝑐+𝑢+1,𝑚], where 𝑦 satisfies the capacity constraint, are complementary to the knapsacks [1,ℎ−𝑢−1], where 𝑦 satisfies that constraint.

Lemma 6. Let ℎ=𝑚/2−𝐿/2−1, and ℎ^=ℎ+𝐿+1.
Then, opt[𝐴]=max_{𝑠∈𝒮,|𝑠|≤𝑘≤𝐾}opt^𝑅𝐾−𝑘+|𝑠|,ℎ^,𝑠+opt[𝑘,ℎ,𝑠]−𝑝(𝑠,ℎ).(24) Indeed, 𝒳[𝐴]=_𝑠∈𝒮_{,|𝑠|≤𝑘≤𝐾}𝒳^𝑅𝐾−𝑘+|𝑠|,ℎ^,𝑠⊗𝒳[𝑘,ℎ,𝑠].(25)

Proof. In order to show that 𝒳[𝐴]⊆⋃_{𝑠∈𝒮,|𝑠|≤𝑘≤𝐾}(𝒳^𝑅[𝐾−𝑘+|𝑠|,ℎ^,𝑠]⊗𝒳[𝑘,ℎ,𝑠]), take 𝑥∈𝒳[𝐴]. Moreover, take 𝑠∶=𝑥(ℎ+1,ℎ^−1), 𝑦∶=𝟎^ℎ⋅𝑠⋅𝑥(ℎ^,𝑚), 𝑦^∶=𝑥(1,ℎ)⋅𝑠⋅𝟎^{𝑚−ℎ+1}, and 𝑘∶=|𝑦|. In the following, we prove that 𝑦^∈𝒳^𝑅[𝐾−𝑘+|𝑠|,ℎ^,𝑠] and 𝑦∈𝒳[𝑘,ℎ,𝑠]. Obviously, 𝑦⊢(𝑠,ℎ) and 𝑦^⊢^𝑅(𝑠,ℎ^). For which concerning the number of insertions, it is clear that 𝑦 satisfies Constraint (12) of Sub[𝑘,ℎ,𝑠], as 𝑘=|𝑦|. Moreover, note that |𝑥|≤𝐾, because 𝑥∈𝒳[𝐴], and |𝑦^|=|𝑥|−|𝑦|+|𝑠|. Thus, |𝑦^|≤𝐾−𝑘+|𝑠|, and then 𝑦^ satisfies Constraint (12) of Sub[𝐾+|𝑠|−𝑘,ℎ^,𝑠]. About the capacity constraints, in order to show that 𝑦 satisfies them on the knapsacks [ℎ+𝑐+𝑢+1,𝑚], we can apply Observation 2 with 𝑎=ℎ+1. Conversely, applying Observation 1 with 𝑎=ℎ^−1, we obtain that 𝑦^ satisfies the capacity constraint on the knapsacks [1,ℎ^−𝑢−1].
To prove the converse inclusion, take 𝑠∈𝒮, 𝑘 such that |𝑠|≤𝑘≤𝐾, 𝑦^∈𝒳^𝑅[𝐾−𝑘+|𝑠|,ℎ^,𝑠], and 𝑦∈𝒳[𝑘,ℎ,𝑠]. We prove that 𝑥∶=𝑦^(1,ℎ)⋅𝑠⋅𝑦(ℎ^,𝑠)∈𝒳[𝐴]. Clearly, since |𝑦^|≤𝐾−𝑘+|𝑠| and |𝑦|≤𝑘, we get that |𝑥|=|𝑦^|+|𝑦|−|𝑠|≤𝐾, thus 𝑥 satisfies Constraint (12). Moreover, since 𝐿≥𝑐, it is simple to verify that 𝑥 satisfies also Constraint (5). Furthermore, exploiting Observation 2 with 𝑎=ℎ+1, and Observation 1 with 𝑎=ℎ^−1, we get that 𝑥 satisfies the capacity constraint on all the knapsacks [1,𝑚].

Let 𝑠_opt and 𝑘_opt be the values of 𝑠 and 𝑘 that maximize (24). Moreover, let 𝑥_opt∈{0,1}^𝑚 be a best solution for an IKHO instance 𝐴. Clearly, the signature 𝑠_opt represents a piece of 𝑥_opt, that is, 𝑠_opt=𝑥_opt(ℎ+1,ℎ^−1). In addition, note that 𝑘_opt determines a distribution of the best solution insertions, that is, |𝑥_opt(ℎ+1,𝑚)|≤𝑘_opt and |𝑥_opt(1,ℎ^−1)|≤𝐾−𝑘_opt+|𝑠_opt|. If we do not consider the insertions given by the signature 𝑠_opt, we obtain |𝑥_opt(ℎ^,𝑚)|≤𝑘_opt−|𝑠_opt| and |𝑥_opt(1,ℎ)|≤𝐾−𝑘_opt, as described in Figure 7.

Figure 7 

The subdivision on the 𝑘 dimension. A possible best solution 𝑥opt is drawn. The black spots represent the insertions. It is simple to see that the value 𝑘opt−|𝑠opt| is a bound for the number of insertions placed at the right of 𝑠opt, while 𝐾−𝑘opt bounds the number of insertions at the left of the signature.

Having fixed the 𝐿 middle elements of 𝑥_opt has an important consequence. The radiations of weight starting from the insertions at the left of 𝑠_opt cannot interfere with the radiations coming from the insertions placed at the right of 𝑠_opt, as shown in Figure 8. In particular, by (9), the right insertions affect only the range [ℎ^−𝑢,𝑚], while the left insertions interest only the knapsacks [1,ℎ+𝑐+𝑢].

Figure 8 

The subdivision on the 𝑠 dimension. The radiations of weight coming from the right knapsacks do not reach those starting from the left knapsacks.

Therefore, in order to compute the entire part of 𝑥_opt which stands at the right of 𝑠_opt, it is enough to know 𝑠_opt, because the checks on the capacity constraints are independent from the insertions at the left of 𝑠_opt. The same clearly holds also for finding the left piece of 𝑥_opt. Thus, we subdivided the main problem in two independent subproblems, as follows:(i)to find the best solution in the knapsacks [ℎ^,𝑚], obeying the capacity constraints over the knapsacks [ℎ^−𝑢,𝑚], having at most 𝑘_opt−|𝑠_opt| insertions and knowing that 𝑥_opt(ℎ+1,ℎ^−1)=𝑠_opt; (ii)to find the best solution in the knapsacks [1,ℎ], obeying the capacity constraints over the knapsacks [1,ℎ+𝑐+𝑢], having at most 𝐾−𝑘_opt insertions and knowing that 𝑥_opt(ℎ+1,ℎ^−1)=𝑠_opt.

The above-obtained subproblems are solvable as an IKHO instance, by recursively applying (24) with some adjustments. The only significant difference between the main call and the recursive calls is that, in the second ones, when checking the capacity constraints, we have to consider the insertions given by the previously fixed 𝑠_opt. Indeed, we can simplify this task by progressively updating the vector of capacities 𝑏, by subtracting 𝑤(𝑠_opt,ℓ) for each ℓ∈[1,𝑚]. For each step of recursion, the new vector 𝑏 will be passed to the input of the lower level subproblems. The solution of each subproblem fixes over 𝑥_opt a signature 𝑠_opt, so as to recursively cover 𝑥_opt with substrings of length 𝐿. This is visualized in Figure 9. Finally, note that the base cases for this recursion are the subproblems which involve a number of knapsacks lower than 𝐿. In order to compute the best solution for them, we simply list all the feasible solutions and compare the profits.

Figure 9 

Covering 𝑥opt recursively. An optimal solution 𝑥opt is drawn. The black elements are determined by the first call of (24). The more gray knapsacks are determined by the two next levels of calls.

5.2. Complexity

As mentioned at the beginning of this section, in the first call (root node of the recursion tree), the computing of (24) takes 𝑂(|𝒮|×𝐾) space. The recursive calls occupy geometrically less memory than the first call, as they deal with an halvened number of knapsacks (and with a lower value of 𝐾), whence the total memory consumption is of the same order as the memory consumption for the sole first call. Note that, for each step of recursion, once we found 𝑘_opt and 𝑠_opt, we can deallocate the matrices opt and opt^𝑅. Besides these matrices, we need 𝑂(𝑚) space for dynamically compose the best solution 𝑥_opt. Therefore, the new algorithm takes only 𝑂(𝑚+[|𝒮|×𝐾]) space.

Let us now analyze its time complexity. In the first call, for the computation of (24), the algorithm spends 𝑂(𝑚×|𝒮|×𝐾) time to compute the matrices opt and opt^𝑅, and 𝑂(|𝒮|×𝐾) time to pick out the values 𝑠_opt and 𝑘_opt. It also spends 𝑂(𝐿²) time in order to update the vector 𝑏 by subtracting the radiations of weight given by 𝑠_opt. In fact, a signature has width 𝐿, and the range of influence of an insertion is 𝑐+2𝑢+1=𝐿+1. To give an estimate for the subproblems computation, we need to study how the two terms found, 𝑂(𝐿²) and 𝑂(𝑚×|𝒮|×𝐾), propagate on the next levels of calls. Moreover, let us write them as 𝛼⋅𝐿² and 𝛽⋅(𝑚×|𝒮|×𝐾), for some constants 𝛼,𝛽.

First, note that the recursive calling scheme for (24) can be approximated with a binary tree of height ⌈log₂(𝑚)⌉. Indeed, since the calls on an input of 𝐿 knapsacks are treated as leaf cases, the height of the binary tree corresponds to the first integer 𝑛 such that 𝐿⋅2^𝑛≥𝑚, that is, ⌈log₂(𝑚/𝐿)⌉. Moreover, it is simple to find that such a binary tree has 𝑂(𝑚/𝐿) nodes. In fact, since for each level 𝑖, we have at most 2^𝑖 nodes, the total number of nodes is ^log^2(𝑚/𝐿)_𝑖=02^𝑖=1−2^{log2(𝑚/𝐿)+1}1−2=1−2⋅(𝑚/𝐿)−1=2⋅𝑚𝐿−1.(26) Therefore, considering all the calls of (24), for the first term, we obtain 𝛼𝐿²⋅𝛾(𝑚/𝐿)=𝑂(𝑚×𝐿).

Note that, when we call the two children of a node, both the knapsack array dimension and the 𝐾 dimension are subdivided. In particular, we call the children resolution on two half of the knapsacks array (𝑚/2 and 𝑚/2), and taking parameters 𝐾^ and 𝐾^ such that 𝐾^+𝐾^≤𝐾. Thus, for each level 𝑖, and each node 𝑗, the second term of complexity is 𝛽×(𝑚/2^𝑖)×𝐾_𝑗×|𝒮|, such that ∑_𝑗𝐾_𝑗≤𝐾. Therefore, for the second term, the complexity for each entire level 𝑖, is clearly 𝛽×(𝑚/2^𝑖)×𝐾×|𝒮|. Moreover, by adding up each level, we get that the total complexity for the second term is ^log^2(𝑚/𝐿)_𝑖=0𝛽×𝑚2^𝑖×𝐾×||𝒮||=𝛽𝑚𝐾||𝒮||×^{log2(𝑚/𝐿)}_𝑖=012^𝑖≤𝛽𝑚𝐾||𝒮||×2=𝑂𝑚𝐾||𝒮||.(27) Since |𝒮|=𝑆_𝑐(𝐿)≥𝐿, the second term 𝑂(𝑚×|𝒮|×𝐾) always bounds the first 𝑂(𝑚×𝐿). Therefore, the complexity of the nodes computation is 𝑂(𝑚×|𝒮|×𝐾).

Regarding the computation of the leaf cases, note that we have to find the best feasible piece of solution, for an input of at most 𝐿 knapsacks. Since these pieces have length lower than 𝐿, and they must obey Constraint (5), they are at most |𝒮|. Moreover, we have to consider the cost of checking the capacity constraints on 𝑂(𝐿) knapsacks. Thus, a leaf case can be solved in 𝑂(|𝒮|×𝐿) time. Since we have 𝑂(𝑚/𝐿) leaf cases, the total cost of the leaf cases is 𝑂(𝑚×|𝒮|), that is not higher than the complexity needed for computing the nodes. Therefore, the memory-saving version of the algorithm has time complexity of 𝑂(𝑚×|𝒮|×𝐾), which is the same as for the base version.

6. Conclusions

In [3], Aho exhibited a few classes of polynomial instances for the IKHO problem, motivated by the fact that IKHO is NP-complete [1] and APX-hard [2]. The most important class of instances identified by Aho is represented by the instances where 𝑐+2𝑢+1=𝑂(log(𝑚^𝛼)), for a constant 𝛼. Throughout Sections 3 and 4, we identified a new and wide class of instances allowing for a polynomial time algorithm. We achieved this by showing how to build a dynamic programming algorithm which executes in time of 𝑂(𝑐^𝑟×𝑚×𝐾) and takes space of 𝑂(𝑐^𝑟×𝑚×𝐾) for the instances where (𝑐+2𝑢)/𝑐 is bounded by a constant 𝑟. These results represent a significant improvement to the understanding of the IKHO problem and more in general for the Interactive Knapsacks problems to which IKHO belongs and that are extensively presented by Aho in [4]. Note that our results imply Aho's results for IKHO, as shown in Section 2.2. In Section 5, we also exploited Hirschberg's approach in order to create a memory saving version of our algorithm which decreases the space complexity to 𝑂(𝑐^𝑟×𝐾+𝑚) without increasing the time complexity.

Extensive experimental evaluations have been performed on the c++ implementations of both algorithms, confirming the complexity estimates given in Sections 4 and 5. In addition, these experiments pointed out that, despite the heavy constants introduced in the time complexity bound of the memory saving version, the last version of the algorithm is often faster than the base version in the practice. This is mainly due to the fact that the higher memory usage of the base version brings the operative system to allocate data in the slowest memory devices like the RAM and the hard disk, instead of using the CPU cache.

Appendix

Proving the Base of Lemma 4

In this appendix, we prove the base of the induction of Lemma 4. We have to show that, assuming 𝑐≥𝑒, 𝑆_𝑐(𝑛)≤((𝑐+1)/𝑐)𝑐^𝑛/𝑐 for 𝑛∈[𝑐,2𝑐].

In the following, let 𝐹_𝑐(𝑖)=1+𝑐+𝑖+𝑖(𝑖−1)2.(A.1) First, notice that 𝐹_𝑐(𝑖)=𝑆_𝑐(𝑐+𝑖) for 𝑖∈[0,𝑐]. Indeed, for 𝑖∈[0,𝑐], we can compute 𝑆_𝑐(𝑐+𝑖) by simply counting the number of signatures of length 𝑐+𝑖, and then verify that this number is exactly 𝐹_𝑐(𝑖). By Constraint (5), in a signature of length 2𝑐, or smaller than 2𝑐, there can be at most two insertions. Thus, since 𝑐+𝑖≤2𝑐, we can count the signatures of length 𝑐+𝑖, by grouping them according to the number of insertions (no one, one, or two). Obviously, only the signature 𝟎^𝑐+𝑖 has no insertions. Moreover, there are exactly 𝑐+𝑖 ways to place one insertion. For the case where we have two insertions, note that the first one can be only in the first 𝑖−1 positions, because if we place it on the 𝑖-th position, by Constraint (5), there cannot be later insertions in a signature of length 𝑖+𝑐. Moreover, notice that if we fix the first insertion in position 𝑗, then we have 𝑖−𝑗 possible places where to put the second one, again by Constraint (5). Therefore, the number of signatures with two insertions is clearly ^𝑖−1_𝑗=1𝑖−𝑗=^𝑖−1_𝑗=1𝑗=𝑖(𝑖−1)2.(A.2)

So 𝐹_𝑐(𝑖)=𝑆_𝑐(𝑐+𝑖) for 𝑖∈[0,𝑐], as anticipated. Therefore, in order to prove the base of the induction of Lemma 4, it is enough to show that 𝐹_𝑐(𝑖)≤𝑓_𝑐(𝑖), with 𝑓_𝑐(𝑖)=((𝑐+1)/𝑐)𝑐^{(𝑐+𝑖)/𝑐}=((𝑐+1)/𝑐)𝑐^1+𝑖/𝑐=(𝑐+1)𝑐^𝑖/𝑐.

Clearly, for 𝑖=0, we get 𝐹_𝑐(0)=𝑐+1≤(𝑐+1)𝑐^0/𝑐=𝑓_𝑐(0). Our plan is then to observe that 𝜕𝐹_𝑐(𝑖)/𝜕𝑖≤𝜕𝑓_𝑐(𝑖)/𝜕𝑖 holds for every 𝑖≥0, when 𝑐≥𝑒. Indeed, 𝜕𝐹_𝑐(𝑖)/𝜕𝑖=𝑖+1/2, whereas 𝜕𝑓_𝑐(𝑖)/𝜕𝑖=(𝑐+1)𝑐^𝑖/𝑐(ln(𝑐)/𝑐). When 𝑖=0, we get 𝐹^_𝑐(0)=1/2, and since 𝑐≥𝑒, 𝑓^_𝑐(0)=(𝑐+1)𝑐⁰ln(𝑐)𝑐=ln(𝑐)𝑐+1𝑐>1.(A.3) That is, 𝐹^_𝑐(0)≤𝑓^_𝑐(0). Moreover, it is simple to see that 𝐹^_𝑐(𝑖) is linear, whereas 𝑓^_𝑐(𝑖) is an exponential on the variable 𝑖, and, therefore, 𝑓^_𝑐(𝑖)≥𝐹^_𝑐(𝑖) for every 𝑖≥0, as anticipated.