An Exact Algorithm for Bilevel 0-1 Knapsack Problems

Abstract

We propose a new exact method for solving bilevel 0-1 knapsack problems. A bilevel problem models a hierarchical decision process that involves two decision makers called the leader and the follower. In these processes, the leader takes his decision by considering explicitly the reaction of the follower. From an optimization standpoint, these are problems in which a subset of the variables must be the optimal solution of another (parametric) optimization problem. These problems have various applications in the field of transportation and revenue management, for example. Our approach relies on different components. We describe a polynomial time procedure to solve the linear relaxation of the bilevel 0-1 knapsack problem. Using the information provided by the solutions generated by this procedure, we compute a feasible solution (and hence a lower bound) for the problem. This bound is used together with an upper bound to reduce the size of the original problem. The optimal integer solution of the original problem is computed using dynamic programming. We report on computational experiments which are compared with the results achieved with other state-of-the-art approaches. The results attest the performance of our approach.

1. Introduction

Bilevel optimization problems were introduced for the first time in [1] in connection with the well-known Stackelberg game [2]. These problems are related to the decision making process conducted by two agents, each with his own individual objective, under a given hierarchical structure. The agent that is at the top of this hierarchy is called the leader. His distinctive feature in the process is that he knows which decision is taken by the other agent (called the follower). As a consequence, he can optimize his own objective by taking into account the decision of the follower.

The bilevel 0-1 knapsack problem (BKP) that is addressed in this paper is defined in this context. It is a hierarchical optimization problem in which the set of feasible solutions depends on the set of optimal solutions of a parametric 0-1 knapsack problem. The BKP can be formulated as follows:(BKP)max_𝑥,𝑦𝑓¹𝑥,𝑦=𝑑¹𝑥+𝑑²𝑦s.t.𝑥∈{0,1}^𝑛1,𝑦∈Argmax𝑓²𝑦^′=𝑐𝑦^′∶𝑎¹𝑥+𝑎²𝑦^′≤𝑏,𝑦^′∈{0,1}^𝑛2. (1.1) The 𝑛¹ decision variables related to the leader are denoted by 𝑥. The follower has 𝑛² decision variables which are denoted by 𝑦. The objective functions of the leader and the follower are denoted, respectively, by 𝑓¹(𝑥,𝑦) and 𝑓²(𝑦). The weights of the variables 𝑥 and 𝑦 in the objective function of the leader are denoted by 𝑑¹ and 𝑑², respectively, while the vector 𝑐 represents the coefficients of the follower variables in his own objective function. The vectors 𝑎¹ and 𝑎² are the set of coefficients related to the decision variables of the leader and the follower in the knapsack constraint of the follower, respectively. The capacity of this knapsack constraint is denoted by 𝑏. All the coefficients of the problem are assumed to be positive. The standard 0-1 knapsack problem is a special case of BKP. It is obtained from (1.1) by setting 𝑛¹=0 and 𝑑²=𝑐. As a consequence, the problem BKP is NP-hard.

Different methods have been proposed in the literature for bilevel programming problems with and without integer variables [3, 4]. A recent survey on the contributions for solving bilevel programming problems can be found in [5]. Many of these methods focus on problems with continuous variables.

The bilevel knapsack problem was addressed by Dempe and Richter [6], Plyasunov [7], and Brotcorne et al. [8], but only for the case where there is a single (continuous) variable for the leader and different binary variables for the follower. Note that, for these cases, there may be no optimal solution for the problem [4]. The branch-and-bound algorithm proposed by Moore and Bard in [9] and the method proposed by Brotcorne et al. in [10] can be adapted to solve the BKP addressed in this paper. At the end of the paper, we will compare our approach with the results obtained by these two algorithms.

Here, we consider the case where all the variables of the problem are binary variables. We propose a new exact approach for this problem based on several intermediate procedures. A lower bound for the problem is computed by applying first a polynomial time algorithm to solve the linear relaxation of BKP. The solutions generated by this algorithm are then used to compute feasible solutions to BKP and hence to obtain a valid lower bound for the problem. Using this lower bound and a given upper bound, the size of the problem is reduced by applying fixing rules. Dynamic programming rules are applied afterwards to obtain the optimal solution of BKP.

Bilevel programming problems have many applications on different fields including economics, engineering, the determination of pricing policies, production planning, transportation, and ecology. In [11], Dempe identified more than 80 references in the literature describing applications of bilevel problems. Other examples, namely, on the field of engineering are described in [12]. The BKP is a discrete bilevel problem that can be applied in many situations involving the interaction between two agents whose (binary) decisions are interrelated and with each one trying to optimize his own objective. Real applications of this problem can be found in revenue management, telecommunications, capacity allocation, and transportation, for example.

An application in revenue management may involve an individual searching for the best investment plan for his capital. The investor has the choice between placing his funds directly on financial applications with a guaranteed rate of return, letting an intermediary company (a broker, e.g.) decide how to invest these funds, or dividing the funds between these two possibilities. The intermediary company cannot invest more than the amount provided by the individual and it will do so in order to maximize its own profit. For this purpose, the intermediary will buy shares, bonds, or other financial assets that will provide it a revenue. Part of this revenue will be given back to the individual as a return on investment. In turn, the individual will decide on the amount to invest by itself and the amount to give to the intermediary with the objective of maximizing his own profit. In BKP, the individual will be the leader, while the intermediary will be considered as the follower. The value 𝑏 in (1.1) represents the capital of the individual. The coefficients of 𝑎¹ represent the amounts that the individual can invest by itself and which will provide him a guaranteed rate of return given by the vector 𝑑¹. The alternative investment plans in which the intermediary company can invest, the revenue that these plans will provide to this company, and the revenue that will be paid back to the investor are represented in (1.1) by 𝑎², 𝑐, and 𝑑², respectively. In BKP, the decision of the leader has a direct impact on the knapsack constraint of the follower. In fact, the decision of the individual (the leader) will set the capacity of the knapsack and determine the total amount of money that the intermediary (the follower) will be allowed to invest.

An alternative application of BKP occurs in telecommunications, and in particular in the problem of allocating bandwidth to different clients. An application in this area was addressed in [13] using an approach based on a bilevel programming problem with knapsack constraints. The BKP can be used in this context to model the interaction between a service provider and its competitors. The service provider can use its installed capacity to serve directly its clients, or it can grant capacity to another company that may use this capacity to route the demand of its own clients through the network of the service provider. The latter charges the company for this service, while the company will choose or not to reroute the traffic of its clients through the network of the service provider according to the offers of other competitors and so as to maximize its own profit. In this case, the leader is the service provider and the follower is the other company. The total capacity of the service provider is the coefficient 𝑏 in (1.1). The price that is charged by the service provider is represented by 𝑑², while the amount of traffic required by the clients is given by 𝑎¹ and 𝑎².

The remainder of the paper is organized as follows. In Section 2, we introduce different definitions and the notation that is used in the paper, and we describe the properties of BKP. In Section 3, we describe the details of our algorithm. We present our algorithm to solve the linear relaxation of BKP, the rules used to reduce the size of the problem, and the dynamic programming procedures developed to find the optimal solution of BKP. In Section 4, we report on computational results that illustrate the efficiency of our methods compared with the only available method from the literature [14]. Some final conclusions are drawn in Section 5.

2. The Bilevel 0-1 Knapsack Problem

2.1. Definitions

We introduce first the following standard definitions related to the bilevel 0-1 knapsack problem BKP described in the previous section:(i)the relaxed feasible set: 𝑆=𝑥,𝑦∈{0,1}^𝑛1+𝑛2∶𝑎¹𝑥+𝑎²𝑦≤𝑏; (2.1)(ii)the set of rational reactions of the follower for a fixed 𝑥: 𝑃(𝑥)=Argmax𝑓²𝑦∶𝑎²𝑦≤𝑏−𝑎¹𝑥,𝑦∈{0,1}^𝑛2; (2.2)(iii)the Inducible Region (IR), that is, the space over which the leader optimizes: IR=𝑥,𝑦∈𝑆∶𝑦∈𝑃(𝑥). (2.3)

Using this notation, we can rewrite the BKP as follows.(BKP)max_𝑥,𝑦𝑓¹𝑥,𝑦=𝑑¹𝑥+𝑑²𝑦s.t.𝑥,𝑦∈IR. (2.4)

When several optimal solutions exist for the follower problem, the previous model is not sufficient to define the optimal value of the problem because, for a leader decision, the follower can have several equivalent solutions. In this case, the solutions of the BKP can be defined either optimistically or pessimistically for each fixed leader variable [15]. These approaches can be described as follows.

(i) Optimistic
We assume that the leader can influence the decision of the follower in his favor. In this case, the problem to solve becomes max_𝑥max_𝑦𝑓¹𝑥,𝑦∶𝑦∈𝑃(𝑥)𝑥,𝑦∈𝑆, (2.5) and its optimal solution is called a weak solution.

(ii) Pessimistic
The follower takes his decision independently of the interests of the leader. In this case, the problem to solve becomes max_𝑥min_𝑦𝑓¹𝑥,𝑦∶𝑦∈𝑃(𝑥)𝑥,𝑦∈𝑆, (2.6) and its optimal solution is called a strong solution.

A detailed discussion of each approach can be found in [15]. The algorithms described in this paper can find both the strong and the weak solution of the problem. However, and for the sake of clearness, we will focus our presentation on the optimistic approach.

2.2. An Upper Bound for BKP

The linear relaxation of BKP obtained by removing all the integrality constraints does not provide a valid upper bound for the problem. Hence, we resort to an upper bound for bilevel programming problems provided by a relaxation of (1.1) called the high-point problem [9, 16]. The high point problem is obtained by removing the objective function of the follower and the integrality constraints. It is defined formally as follows:(HBKP)max_𝑥,𝑦𝑓¹𝑥,𝑦=𝑑¹𝑥+𝑑²𝑦s.t.𝑎¹𝑥+𝑎²[][].𝑦≤𝑏,𝑥∈0,1,𝑦∈0,1 (2.7) The optimal solution of this relaxation can be computed using a classical procedure for the knapsack problem [17].

2.3. Computing a Feasible Solution for BKP

A feasible solution to BKP can be computed by solving a different optimization problem related to the follower problem as shown in the following proposition.

Proposition 2.1. Let 𝑧∈{0,…,𝑏}. An optimal solution to the following problem denoted by FBKP_𝑧 is also feasible for BKP: FBKP_𝑧max_𝑥,𝑦𝑓𝑥,𝑦=𝑑¹𝑥+𝑐𝑦s.t.𝑎¹𝑎𝑥=𝑧,₂{}𝑦≤𝑏−𝑧,𝑥∈0,1^𝑛1,𝑦∈{0,1}^𝑛2. (2.8)(2.9)(2.10)

Proof. As long as FBKP_𝑧 admits a feasible solution, its optimal solution is feasible for the follower problem of BKP since the knapsack constraint of the follower is satisfied due to (2.9) and (2.10). This optimal solution is also optimal for the follower problem because it takes into account the follower objective function on the follower variables.

An optimal solution (𝑥^∗,𝑦^∗) for BKP can then be defined using FBKP_𝑧 as follows:𝑥^∗,𝑦^∗∈Argmax𝑑¹𝑥^∗_𝑧+𝑑²𝑦^∗_𝑧∶𝑥^∗_𝑧,𝑦^∗_𝑧isanoptimalsolutionofFBKP_𝑧,for𝑧=0,…,𝑏. (2.11) Clearly, finding an optimal solution for BKP by solving FBKP_𝑧 for each possible value of 𝑧 is computationally expensive. To obtain a good feasible solution for BKP, in our algorithm, we solve the problem FBKP_𝑧 for a set of good candidate values for 𝑧, which are obtained by solving the linear relaxation of BKP with the polynomial time procedure described in Section 3.1.

3. An Exact Algorithm for BKP

Before we describe our exact algorithm for BKP, we define and discuss first its different components. Our algorithm relies on the computation of an upper and lower bound for BKP. The upper bound is computed by solving exactly the problem HBKP defined previously. The lower bound is obtained by solving first a linear relaxation of BKP using the polynomial time procedure described in Section 3.1, and then by solving the problem FBKP_𝑧 for different values of the parameter 𝑧. The values of 𝑧 are associated to feasible solutions of the linear relaxation of BKP which are obtained by applying the polynomial procedure mentioned previously. The upper and lower bounds are used to fix variables of BKP to their optimal values (Section 3.2) and to further enhance the definition of the original problem so as to improve its resolution in the remaining steps (Section 3.3). The optimal value for the resulting problem is computed using dynamic programming. This value is then used to generate an optimal solution for BKP. The two phases of this dynamic programming procedure are described in Section 3.4. The outline of our exact algorithm is given in Section 3.5.

3.1. A Polynomial Time Solution Procedure for the Linear Relaxation of BKP

In this section, we show that the linear relaxation of BKP can be solved up to optimality in polynomial time, and we describe a procedure that computes this optimal solution. First, we recall the formal definition of this linear relaxation that will be denoted by CBKP (for continuous bilevel 0-1 knapsack problem):(CBKP)max_𝑥,𝑦𝑓¹𝑥,𝑦=𝑑¹𝑥+𝑑²𝑦𝑓s.t.0≤𝑥≤1,𝑦∈Argmax²𝑦^′=𝑐𝑦^′∶𝑎¹𝑥+𝑎²𝑦^′≤𝑏,0≤𝑦^′≤1. (3.1)

Now, we show that solving CBKP is equivalent to the resolution of the linear relaxation of a standard knapsack problem.

Proposition 3.1. Assume that the follower variables 𝑦₁,𝑦₂,…,𝑦_𝑛2 are sorted in decreasing order of the relative value between their profit and their weight in the knapsack constraint, that is, such that 𝑐₁/𝑎²₁≥𝑐₂/𝑎²₂≥⋯≥𝑐_𝑛2/𝑎²_𝑛2. If 𝑐_𝑖/𝑎²_𝑖=𝑐_𝑗/𝑎²_𝑗, the order between the corresponding variables is determined according to the objective function of the leader, that is, 𝑑²_𝑖/𝑎²_𝑖≥𝑑²_𝑗/𝑎²_𝑗 (in the pessimistic case, one will consider 𝑑²_𝑖/𝑎²_𝑖≤𝑑²_𝑗/𝑎²_𝑗). Let 𝑥^∗ be a decision of the leader. In this case, the total resource consumed by the leader in the knapsack constraint is given by 𝑎¹𝑥^∗. Furthermore, let 𝑘 be defined such that 𝑏−𝑎¹𝑥^∗∈[∑^𝑘_𝑖=1𝑎²_𝑖s,∑^𝑘+1_𝑖=1𝑎²_𝑖[. The reaction of the follower related to the decision 𝑥^∗ will be as follows: 𝑦₁=1,𝑦₂=1,…,𝑦_𝑘=1,𝑦_𝑘+1=𝑏−𝑎¹𝑥^∗−∑^𝑘_𝑖=1𝑎²_𝑖𝑎²_𝑘+1,𝑦_𝑘+2=0,…,𝑦_𝑛2=0. (3.2)

Proof. Indeed, for a given decision 𝑥^∗ of the leader, the problem CBKP becomes a standard 0-1 knapsack problem: CBKP_𝑥∗𝑦∈Argmax𝑓²𝑦=𝑐𝑦^′∶𝑎²𝑦^′≤𝑏−𝑎¹𝑥^∗,0≤𝑦^′≤1. (3.3)

In Algorithm 1, we describe a polynomial time procedure that generates a weak solution for CBKP. The algorithm is based on the same idea that is used to solve the standard 0-1 knapsack problem. We start by solving the knapsack problem associated to the leader variables and objective function:𝑥^∗∈Argmax𝑓¹(𝑥)=𝑑¹𝑥∶𝑎¹𝑥≤𝑏,0≤𝑥≤1, (3.4) with 𝑥^∗ being the optimal solution of this problem. Then, we solve the follower knapsack problem that results from the leader decision 𝑥^∗:𝑦^∗∈Argmax𝑓²𝑦=𝑐𝑦∶𝑎²𝑦≤𝑏−𝑎¹𝑥^∗,0≤𝑦≤1, (3.5) with 𝑦^∗ being the corresponding optimal solution. The algorithm enumerates all the nondominated feasible linear programming basic solutions starting by the solution (𝑥^∗,𝑦^∗). At each iteration, we move from a feasible basic solution to another by transferring the resources consumed by the leader to the follower. To clarify the procedure, we illustrate its execution in Example 3.2.

Let 𝑑opt denote the optimal value of the leader objective function;  Let (𝑥opt,𝑦opt) be an optimal solution of CBKP;  Initialization   Sort the variables 𝑥 and 𝑦 in decreasing order of the ratio 𝑑1𝑗/𝑎1𝑗 for 𝑥 and 𝑐𝑗/𝑎2𝑗   and 𝑑2𝑗/𝑎2𝑗 for 𝑦;   Let      𝑥∗1=1,𝑥∗2=1,…,𝑥∗𝑘=1,𝑥∗𝑘+1=(𝑏−∑𝑘𝑖=1𝑎1𝑖)𝑎1𝑘+1,𝑥∗𝑘+2=0,…,𝑥∗𝑛1=0   be the optimal solution for the following problem:           𝑥∗∈Argmax{𝑓1(𝑥)=𝑑1𝑥∶𝑎1𝑥≤𝑏,0≤𝑥≤1};   Let     𝑦∗1=1,𝑦∗2=1,…,𝑦∗𝑡=1,𝑦∗𝑡+1=(𝑏−𝑎1𝑥∗−∑𝑡𝑖=1𝑎2𝑖)𝑎2𝑡+1,𝑦∗𝑡+2=0,…,𝑦∗𝑛2=0   be the optimal solution for the following problem:          𝑦∗∈Argmax{𝑓2(𝑦)=𝑐𝑦∶𝑎2𝑦≤𝑏−𝑎1𝑥∗,0≤𝑦≤1};   /*   The indexes 𝑘+1 and 𝑡+1  are respectively the indexes of the last   leader and follower variables with a positive value according   to the ordering */   Let 𝑑opt=𝑑1𝑥∗+𝑑2𝑦∗;  𝑖=𝑘+1; 𝑗=𝑡+1;  while  (𝑖>0) and (𝑗<𝑛2+1) do   if (𝑎1𝑖𝑥∗𝑖>𝑎2𝑗(1−𝑦∗𝑗))  then    𝑥∗𝑖=𝑥∗𝑖−𝑎2𝑗(1−𝑦∗𝑗)/𝑎1𝑖; 𝑦∗𝑗=1; 𝑗=𝑗+1;   end   else  if (𝑎1𝑖𝑥∗𝑖<𝑎2𝑗(1−𝑦∗𝑗))  then     𝑥∗𝑖=0; 𝑦∗𝑗=𝑦∗𝑗−𝑎1𝑖𝑥∗𝑖/𝑎2𝑗; 𝑖=𝑖−1;   end   else  if (𝑎1𝑖𝑥∗𝑖=𝑎2𝑗(1−𝑦∗𝑗))  then     𝑥∗𝑖=0; 𝑦∗𝑗=1; 𝑖=𝑖−1; 𝑗=𝑗+1;   end   if (𝑑opt<𝑑1𝑥∗+𝑑2𝑦∗)  then    𝑑opt=𝑑1𝑥∗+𝑑2𝑦∗; (𝑥opt,𝑦opt)=(𝑥∗,𝑦∗);   end  end

Algorithm 1 

A polynomial time solution procedure for CBKP.

Example 3.2. Consider the following continuous bilevel 0-1 knapsack problem denoted by CBKP₁: CBKP₁max_𝑥,𝑦𝑓¹𝑥,𝑦=3𝑥₁+2𝑥₂+7𝑥₃+5𝑦₁+𝑦₂+2𝑦₃+𝑦₄s.t.0≤𝑥≤1,max_𝑦𝑓²𝑦=2𝑦₁+2𝑦₂+3𝑦₃+4𝑦₄s.t.3𝑥₁+𝑥₂+2𝑥₃+𝑦₁+2𝑦₂+𝑦₃+4𝑦₄≤40≤𝑦≤1. (3.6) We start by sorting the variables of the leader in decreasing order of the ratio 𝑑¹_𝑗/𝑎¹_𝑗, which results in the sequence 𝑥₃ (with 𝑑¹₃/𝑎¹₃=7/2), 𝑥₂ (with 𝑑¹₂/𝑎¹₂=2/1), and 𝑥₁ (with 𝑑¹₁/𝑎¹₁=3/3). A similar ordering is applied to the variables of the follower resulting in the sequence 𝑦₃ (with 𝑐₃/𝑎²₃=3/1), 𝑦₁ (with 𝑐₁/𝑎²₁=2/1), 𝑦₂ (with 𝑐₂/𝑎²₂=2/2), and 𝑦₄ (with 𝑐₄/𝑎²₄=4/4). Note that 𝑦₂ and 𝑦₄ have the same ratio 𝑐_𝑗/𝑎²_𝑗, but 𝑦₂ with 𝑑²₂/𝑎²₂=1/2 outperforms 𝑦₄ with 𝑑²₄/𝑎²₄=1/4. In this example, we are considering the optimistic case. In the first phase of the procedure, we solve the following problem: max_𝑥𝑓¹(𝑥)=3𝑥₁+2𝑥₂+7𝑥₃s.t.3𝑥₁+𝑥₂+2𝑥₃≤4,0≤𝑥≤1. (3.7) The optimal solution of this problem is 𝑥^∗₃=1, 𝑥^∗₂=1, and 𝑥^∗₁=1/3. The optimal reaction of the follower for this decision of the leader is 𝑦^∗=(0,0,0,0) and 𝑑_opt=10. The solutions generated at each iteration of the Algorithm 1 are described as follows:(1)𝑥^∗₃=1, 𝑥^∗₂=1, 𝑥^∗₁=1/3 and 𝑦^∗₃=0, 𝑦^∗₁=0, 𝑦^∗₂=0, 𝑦^∗₄=0 with 𝑑_opt=10;(2)𝑥^∗₃=1, 𝑥^∗₂=1, 𝑥^∗₁=0 and 𝑦^∗₃=1, 𝑦^∗₁=0, 𝑦^∗₂=0, 𝑦^∗₄=0 with 𝑑_opt=11;(3)𝑥^∗₃=1, 𝑥^∗₂=0, 𝑥^∗₁=0 and 𝑦^∗₃=1, 𝑦^∗₁=1, 𝑦^∗₂=0, 𝑦^∗₄=0 with 𝑑_opt=14;(4)𝑥^∗₃=0, 𝑥^∗₂=0, 𝑥^∗₁=0 and 𝑦^∗₃=1, 𝑦^∗₁=1, 𝑦^∗₂=1, 𝑦^∗₄=0 with 𝑑_opt=8.The value 𝑑_opt denotes the optimal value of the leader objective function as introduced in Algorithm 1. The optimal solution of CBKP₁ is obtained at the third iteration. This solution is achieved after a polynomial number of steps.

In Algorithm 1, all the nondominated feasible basic solutions of CBKP are visited. For each one of these solutions, we can associate a value for the parameter 𝑧 in FBKP_𝑧. In Example 3.2, the value of 𝑧 is equal to 4, 3, 2, and 0 at the iterations 1 to 4, respectively. These values are equal to 𝑎¹𝑥⁰, with 𝑥⁰ being the value of the leader variables of a given basic solution generated in Algorithm 1. As shown in Section 2.3, we can obtain a feasible solution for BKP by solving the problem FBKP_𝑧 using these values of 𝑧.

A basic solution of CBKP has at most two fractional variables (one for the leader, and another for the follower). If a basic solution of CBKP is integer for both the leader and the follower variables, then this solution is feasible for FBKP_𝑧 and for BKP too. If all the variables of the leader are integer, and only one variable of the follower is fractional, then we can fix the values of the leader variables in FBKP_𝑧 and solve the resulting problem which becomes a single knapsack problem. In these two cases, it is always possible to find a feasible solution for FBKP_𝑧, and hence for BKP. However, when one of the leader variables is fractional, the problem FBKP_𝑧 may be infeasible. This is due to the fact that we are considering that 𝑧∈{⌊𝑎¹𝑥⁰⌋,⌊𝑎¹𝑥⁰⌋+1}. Since there is no guarantee that the equation 𝑎¹𝑥=𝑧 in FBKP_𝑧 has a solution, the corresponding problem FBKP_𝑧 may be infeasible.

Solving the problem FBKP_𝑧 for a single value of the parameter 𝑧 can be done efficiently using branch-and-bound, for example. Clearly, solving this problem for all the values of 𝑧 in {0,…,𝑏} is much more expensive computationally. In our algorithm, our approach to generate a good feasible solution for BKP consists in inspecting a restricted set of good candidate values for 𝑧. For this purpose, we choose the values of 𝑧 that are associated to the 𝑛 best solutions generated by Algorithm 1. In Example 3.2, if we set 𝑛=2, then the values of 𝑧 associated to the two best solutions generated by Algorithm 1 (obtained at the iterations 2 and 3) will be used as a parameter in FBKP_𝑧. The problems that will be solved in this case are FBKP₂ and FBKP₃.

The feasible solution (and corresponding lower bound) that is generated using this approach can be used together with the upper bound provided by HBKP to reduce the size of the original problem BKP. This can be done by fixing the values of some variables to their optimal values. The strategies used to reduce the size of the original BKP are described in the next section.

3.2. Reducing the Size of BKP Using Fixing Rules

A strategy to improve the resolution of 0-1 mixed integer programming problems which has been used extensively in the literature consists in fixing the values of some variables to their optimal value. Many authors [18–20] reported different procedures based on this idea to reduce the size of multidimensional knapsack problems. In this section, we show that it is also possible to apply fixing rules to BKP, and we describe the procedure that we used in our algorithm.

In many cases, fixing variables to their optimal value can be done via inexpensive operations. In the sequel, we show how variables can be fixed using information on the upper and lower bounds for the problem.

Proposition 3.3. Let 𝛼∈{0,1} and LB be a lower bound for BKP. One will use the notation 𝑣(⋅) to indicate the optimal value of a given problem. The following fixing rules apply:(i)for any 𝑗∈{1,…,𝑛¹}, if 𝑣(HBKP∣𝑥_𝑗=𝛼)<LB, then 𝑥_𝑗 can be fixed to the value 1−𝛼;(ii)for any 𝑗∈{1,…,𝑛²}, if 𝑣(HBKP∣𝑦_𝑗=𝛼)<LB, then 𝑦_𝑗 can be fixed to the value 1−𝛼.

Proof. Let 𝑣(BKP) be the optimal value for BKP, and let 𝑞 denote both the variables 𝑥 and 𝑦 of the leader and follower, respectively. Note that 𝑣(BKP)=max{𝑣(BKP∣𝑞_𝑗=𝛼),𝑣(BKP∣𝑞_𝑗=1−𝛼)}. Therefore, if 𝑣(HBKP∣𝑞_𝑗=𝛼)<LB, then inevitably 𝑣(BKP)=𝑣(BKP∣𝑞_𝑗=1−𝛼), and the optimal value 𝑞^∗_𝑗 can be fixed to 1−𝛼.

These fixing rules depend only on an upper and a lower bound for the problem. The stronger the upper and lower bounds are, the more effective will be the rules for fixing the variables.

To introduce a new fixing rule, we rewrite the problem HBKP (used to derive an upper bound for BKP) in its standard form as follows:max𝑑¹𝑥+𝑑²𝑦∶𝑎¹𝑥+𝑎²𝑦+𝑠=𝑏,𝑒≥𝑥≥0,𝑒≥𝑦≥0,𝑠≥0, (3.8) where 𝑠 corresponds to the vector of slack variables and 𝑒 is the vector with all elements equal to 1. Let 𝑁¹={1,…,𝑛¹} and 𝑁²={1,…,𝑛²} be the indices of the leader and follower variables 𝑥 and 𝑦, respectively.

By reference to the LP basis that produces (𝑥,𝑦), we define ℬ={𝑗∈𝑁¹∶𝑥_𝑗 is basic}∪{𝑗∈𝑁²∶𝑦_𝑗 is basic} and ℬ={𝑗∈𝑁¹∶𝑥_𝑗 is nonbasic}∪{𝑗∈𝑁²∶𝑦_𝑗 is non-basic}. We subdivide ℬ to identify the four subsets ℬ⁰_𝑥={𝑗∈ℬ∶𝑥_𝑗=0}, ℬ⁰_𝑦={𝑗∈ℬ∶𝑦_𝑗=0}, ℬ¹_𝑥={𝑗∈ℬ∶𝑥_𝑗=1}, and ℬ¹_𝑦={𝑗∈ℬ∶𝑦_𝑗=1}.

Assume that (𝑥,𝑦) is an optimal basic solution of HBKP. The problem HBKP can be written in the optimal basis related to (𝑥,𝑦) in the following way:max𝑣(HBKP)+_{𝑗∈ℬ0𝑥}𝑑¹_𝑗𝑥_𝑗+_{𝑗∈ℬ0𝑦}𝑑²_𝑗𝑦_𝑗−_{𝑗∈ℬ1𝑥}𝑑¹_𝑗1−𝑥_𝑗−_{𝑗∈ℬ1𝑦}𝑑²_𝑗1−𝑦_𝑗+𝑙𝑠̂s.t.𝑎¹𝑥+𝑎²̂̂[]𝑦+𝑡𝑠=𝑏,𝑥∈0,1^𝑛1,𝑦∈[0,1]^𝑛2,𝑠≥0, (3.9) with 𝑣(HBKP) being the optimal value of HBKP, and (𝑑¹,𝑑²,𝑙)̂ the vector of reduced costs corresponding to the variables (𝑥,𝑦,𝑠) of the optimal basis. For a given lower bound LB for BKP, we have𝑣(HBKP)+_{𝑗∈ℬ0𝑥}𝑑¹_𝑗𝑥_𝑗+_{𝑗∈ℬ0𝑦}𝑑²_𝑗𝑦_𝑗−_{𝑗∈ℬ1𝑥}𝑑¹_𝑗1−𝑥_𝑗−_{𝑗∈ℬ1𝑦}𝑑²_𝑗1−𝑦_𝑗+𝑙𝑠̂≥LB. (3.10) The quantity 𝑙𝑠̂ is negative because of the negative reduced cost vector 𝑙̂ associated to the optimal basic solution, and the positive slack variables 𝑠. Moreover, since 𝑑¹_𝑗≤0 for 𝑗∈ℬ⁰_𝑥 (resp., 𝑑²_𝑗≤0 for 𝑗∈ℬ⁰_𝑦), and 𝑑¹_𝑗≥0 for 𝑗∈ℬ¹_𝑥 (resp., 𝑑²_𝑗≥0 for 𝑗∈ℬ¹_𝑦), we can consider the following cut based on the reduced costs:_{𝑗∈ℬ0𝑥}𝑑¹_𝑗𝑥_𝑗+_{𝑗∈ℬ0𝑦}𝑑²_𝑗𝑦_𝑗−_{𝑗∈ℬ1𝑥}𝑑¹_𝑗1−𝑥_𝑗−_{𝑗∈ℬ1𝑦}𝑑²_𝑗1−𝑦_𝑗≤𝑣(HBKP)−LB. (3.11) This inequality can be used to derive the fixing rule introduced in the next proposition.

Proposition 3.4. If 𝑥_𝑗 (resp., 𝑦_𝑗) is a nonbasic variable, and |𝑑¹_𝑗|>𝑣(HBKP)−LB (resp., |𝑑²_𝑗|>𝑣(HBKP)−LB), then at optimality one has 𝑥^∗_𝑗=𝑥_𝑗 (resp., 𝑦^∗_𝑗=𝑦_𝑗).

Proof. The proof comes directly from the previous inequality (3.11).

Applying these fixing rules is useful for reducing the size of the original problem BKP, and hence to improve its resolution. However, because they do not take into account the objective function of the follower, these rules may result in problems whose solutions are infeasible for the original BKP. The problem occurs when the leader has solutions with the same value than the optimal solution, but which are infeasible for the original BKP because they are not optimal for the follower. To clarify this issue, we apply these rules on the case described in Example 3.2. The results are given in the following example.

Example 3.5. Consider the instance of BKP whose linear relaxation is given by CBKP₁ in Example 3.2. We will denote this instance of BKP by BKP₁. In Table 1, we describe an optimal solution (𝑥,𝑦) for the corresponding problem HBKP, and we report on the values of the associated vectors of reduced costs (𝑑¹,𝑑²). Furthermore, we specify whether a given variable is a basic variable or not by reference to the solution (𝑥,𝑦), and we identify the variables that can be fixed according to the fixing rules described previously.
Let UB and LB denote, respectively, the value of an upper and lower bound for this instance of BKP. The value of the solution given in Table 1 is 14, and hence we have UB = 14. By applying Algorithm 1, we obtain a lower bound of value LB = 14, as shown in Example 3.2. According to Proposition 3.4, since UB − LB = 0, all the nonbasic variables with an absolute reduced cost greater than 0 can be fixed, and hence we have 𝑥^∗₁=0, 𝑥^∗₃=1, 𝑦^∗₁=1, 𝑦^∗₂=0, and 𝑦^∗₄=0. The variable 𝑥₂ cannot be fixed because the absolute value of its reduced cost is not greater than UB − LB. Similarly, the variable 𝑦₃ cannot be fixed because it is a basic variable. Applying the fixing rules leads to the following problem:BKP₁max_𝑥,𝑦𝑓¹𝑥,𝑦=2𝑥₂+2𝑦₃+12s.t.𝑥₂∈{0,1},max_𝑦𝑓²𝑦=3𝑦₃s.t.𝑥₂+𝑦₃𝑦≤1,₃∈{0,1}. (3.12) The resulting problem has two equivalent solutions. The first one consists in the leader action 𝑥₂=1 and the follower reaction 𝑦₃=0. In this case, the complete solution (denoted by sol₁) for the original problem is 𝑥₁=0, and 𝑥₂=1, 𝑥₃=1 and 𝑦₁=1, 𝑦₂=0, 𝑦₃=0, and 𝑦₄=0. The second solution consists in the leader action 𝑥₂=0 and the follower reaction 𝑦₃=1. The complete solution for the original problem in this case (denoted by sol₂) is 𝑥₁=0, 𝑥₂=0, and 𝑥₃=1 and 𝑦₁=1, 𝑦₂=0, 𝑦₃=1, and 𝑦₄=0. The value of both sol₁ and sol₂ is equal to 14. However, the optimal solution of original problem BKP1 is given by sol₂, since for the leader action 𝑥₁=0, 𝑥₂=0, and 𝑥₃=1 the reaction of the follower 𝑦₁=1, 𝑦₂=0, 𝑦₃=1, and 𝑦₄=0 is optimal for the follower problem. On the contrary, sol₁ is not feasible for the problem because for the leader action 𝑥₁=0, 𝑥₂=1, and 𝑥₃=1, the follower reaction should not be 𝑦₁=1, 𝑦₂=0, 𝑦₃=0, and 𝑦₄=0 with the value 2 for the follower objective function. In this case, the follower reaction should be 𝑦₁=0, 𝑦₂=0, 𝑦₃=1, and 𝑦₄=0 with a corresponding value for the follower objective function that is equal to 3.

Table 1 

An optimal solution for HBKP (Example 3.5).

As shown in Example 3.5, the optimal solution of the problem can be found even when the fixing rules described in this section are applied. However, an additional treatment on the optimal solutions of the resulting problem is necessary to identify the solutions that are optimal for the follower problem (and hence feasible for the original problem BKP). To overcome this issue, in our algorithm, we fixed only the leader variables that are not directly influenced by the objective function of the follower.

3.3. Reducing the Interval of Values for the Parameter 𝑍 in FBKP_𝑍

In this section, we show how to decrease the knapsack capacity 𝑏 of the follower problem, and hence the size of the interval of possible values for 𝑧 in FBKP_𝑧. Let lb_𝑧 and ub_𝑧 be the values of a lower and upper bound for 𝑧 in the problem FBKP_𝑧. Initially, we have lb_𝑧=0 and ub_𝑧=𝑏, and hence 𝑧∈[0,𝑏]. The smaller the size of the interval [lb_𝑧,ub_𝑧] is, the easier the problem BKP will be to solve.

To improve the values of lb_𝑧 and ub_𝑧, we solve the following two linear programming problems (denoted by LB_𝑧 and UB_𝑧) which relies on a lower bound LB for BKP. The optimal value of LB_𝑧 leads to a feasible value for lb_𝑧, while UB_𝑧 leads to a feasible value for ub_𝑧:LB_𝑧min𝑧s.t.𝑎¹𝑎𝑥=𝑧,₂𝑑𝑦≤𝑏−𝑧,₁𝑥+𝑑²[]𝑦≥LB,𝑥∈0,1^𝑛1,𝑦∈[0,1]^𝑛2,𝑧∈[0,𝑏],UB_𝑧max𝑧s.t.𝑎¹𝑎𝑥=𝑧,₂𝑑𝑦≤𝑏−𝑧,₁𝑥+𝑑²[]𝑦≥LB,𝑥∈0,1^𝑛1,𝑦∈[0,1]^𝑛2,𝑧∈[0,𝑏]. (3.13) Optimizing over the variable 𝑧 with the additional constraint 𝑑¹𝑥+𝑑²𝑦≥LB in these two linear programs ensures that the resulting lower and upper bound for 𝑧 will not cut the optimal solution of the original BKP. In the next section, we show how this new interval helps in improving the performance of the dynamic programming component of our algorithm for BKP.

3.4. Computing an Optimal Solution of BKP Using Dynamic Programming

In this section, we describe an approach based on dynamic programming to compute the optimal solution of BKP. The approach is divided into two phases. The first phase is a forward procedure whose objective is to find the value of an optimal solution for BKP. This forward phase divides in turn into two steps which are applied, respectively, to the leader variables and to the follower variables. The dynamic programming rules used for the follower variables are an extension of those used in [8]. In the second phase, a backtracking procedure is applied to generate a solution for the BKP with the value found in the forward phase. This dynamic programming algorithm has a pseudo-polynomial complexity, and it is able to solve both the optimistic and pessimistic cases mentioned previously. For the sake of brevity, we will focus our presentation on the optimistic case.

3.4.1. Computing the Optimal Value of BKP: The Forward Phase

As alluded previously, the objective of the forward phase is to find the optimal value of BKP. This phase consists in two steps. The first step applies to the variables of the leader in BKP, and it considers only the objective function of the leader. The definition of this step relies on the interaction between the leader and the follower. For a given decision 𝑥 of the leader, the follower has to maximize his total profit 𝑐𝑦 using the corresponding residual capacity 𝑏−𝑎¹𝑥. For each value of 𝜗∈[0,𝑏], the best action for the leader has to be determined: 𝑥_{𝜗∈[0,𝑏]}∈Argmax{𝑑¹𝑥∶𝑎¹𝑥=𝜗,𝑥∈{0,1}^𝑛1}. Hence, the dynamic programming subproblem for the leader states as follows:𝑓¹_𝑘(𝜗)=max^𝑘_𝑗=1𝑑¹_𝑗𝑥_𝑗∶^𝑘_𝑗=1𝑎¹_𝑗𝑥_𝑗=𝜗,𝑥∈{0,1}^𝑘, (3.14) with 𝑘∈𝑁¹.

The dynamic programming procedure for the leader in this first step of the forward phase is described in Algorithm 2. To illustrate the execution of this algorithm, we show in the following example how it applies to the instance of the BKP described in Example 3.2.

𝑓11(𝜗)=0 if 𝜗=0, 𝑑11 if 𝜗=𝑎11, −∞ otherwise;  for  𝑘=2 to 𝑛1  do      for  𝜗=0 to 𝑏  do     if 𝜗<𝑎1𝑘  then       𝑓1𝑘(𝜗)=𝑓1𝑘−1(𝜗);     end     else      𝑓1𝑘(𝜗)=max(𝑓1𝑘−1(𝜗),𝑓1𝑘−1(𝜗−𝑎1𝑘)+𝑑1𝑘);     end      end  end

Algorithm 2 

Forward procedure for the leader.

Example 3.6. Let us recall first the definition of the instance BKP₁: BKP₁max_𝑥,𝑦𝑓¹𝑥,𝑦=3𝑥₁+2𝑥₂+7𝑥₃+5𝑦₁+𝑦₂+2𝑦₃+𝑦₄s.t.𝑥∈{0,1}³,max_𝑦𝑓²𝑦=2𝑦₁+2𝑦₂+3𝑦₃+4𝑦₄s.t.3𝑥₁+𝑥₂+2𝑥₃+𝑦₁+2𝑦₂+𝑦₃+4𝑦₄{}≤4,𝑦∈0,1⁴. (3.15)
The results of the first step of the forward phase applied to the leader variables of BKP₁ are given in Table 2. In this table, we report on the optimal values of the associated subproblems at this step.
Note that the value of 𝑓¹₃(4) is smaller than 𝑓¹₃(3) because there is no solution 𝑥 with a better value which consumes exactly 4 units of capacity.

Table 2 

First step of the forward phase for the leader of BKP₁.

In the second step of the forward phase, we focus on the variables of the follower. The problem that is solved at this stage is the following:max_𝑦𝑑²𝑦s.t.𝑦∈Argmax𝑓²𝑦^′=𝑐𝑦^′∶𝑎²𝑦^′≤𝑏,𝑦^′∈{0,1}^𝑛2. (3.16) Let 𝛽=𝑏−𝜗∈[0,𝑏] denote the residual capacity associated with the leader action 𝑥_𝜗. In this second step, we consider both the leader and the follower objective functions, and we apply the forward procedure based on dynamic programming described in [8]. The objective is to determine all the reactions of the follower for a given action of the leader.

Two tables are generated in the second step of the forward phase: one that stores the optimal values of the follower (𝑓²_𝑘(𝛽)), and a second one that stores the optimal values of the leader values (𝑓¹_𝑘(𝛽)) with𝑓²_𝑘𝛽=max^𝑘_𝑗=1𝑐_𝑗𝑦_𝑗∶^𝑘_𝑗=1𝑎²_𝑗𝑦_𝑗≤𝛽,𝑦∈{0,1}^𝑘,𝑓¹_𝑘𝛽=max^𝑘_𝑗=1𝑑²_𝑗𝑦_𝑗∶𝑦∈Argmax𝑓²_𝑘𝛽, (3.17) and 𝑘∈𝑁². To illustrate the execution of the forward procedure for the follower, we applied it to the instance BKP₁ used in the previous examples. The results are reported in Example 3.7.

Example 3.7. The results after the second step of the forward phase are reported in Table 3. This example shows that the values of the leader subproblems do not increase always because of the choice of the follower. For 𝑦₃ (𝑘=3) and 𝛽=1, the value for the leader decreases from 5 (for 𝑦₂ and 𝛽=1) to 2. This new value is associated with 𝑑²₃=2 in order to satisfy the objective of the follower. Note that we applied the dynamic recurrence rules on the leader objective function for 𝑦₂ (𝑘=2) and 𝛽=2. The two values of the follower are equivalent: 𝑓²_𝑦1(2)=𝑓²_𝑦1(0)+𝑐₂=2. In this case, the value for the leader is 5 because (𝑓¹_𝑦1(2)=5)>(𝑓¹_𝑦1(0)+𝑑²₂=1).

Table 3 

Second step of the forward phase for the follower of BKP₁.

This dynamic programming approach can be improved by fixing some variables of the problem BKP to their optimal value, and by reducing the size of the interval [lb_𝑧,ub_𝑧] as discussed in the previous sections. Once this new interval has been computed, the first step of the forward phase can be applied with 𝜗∈[0,ub_𝑧] instead of 𝜗∈[0,𝑏]. Since 𝑏≥ub_𝑧, this may reduce the number of steps of Algorithm 2. We do not apply this dynamic programming procedure up to the value of 𝑏, because there is no solution with a value better than LB for 𝜗>ub_𝑧. Similarly, in the second step of the forward phase, we use the following interval for 𝛽: 𝛽∈[0,𝑏−lb_𝑧].

3.4.2. Generating an Optimal Solution for BKP: The Backtracking Phase

Let (𝑥^∗,𝑦^∗) be an optimal solution for BKP. The objective of the backtracking phase is to generate a solution (𝑥^∗,𝑦^∗) with a value that is equal to the value computed in the forward phase. Before we introduce the backtracking procedure, we define first the optimal value that is determined in the forward phase. The optimal solution can be defined using the following rule:𝑑¹𝑥^∗+𝑑²𝑦^∗=𝑓¹_𝑛1𝜗^∗+𝑓¹_𝑛2𝑏−𝜗^∗=max_{0≤𝜗≤𝑏}𝑓¹_𝑛1(𝜗)+𝑓¹_𝑛2(𝑏−𝜗). (3.18) The main idea is based on the fact that for each leader decision with 𝜗 resources consumed, the follower reaction has to be optimum for the remaining 𝑏−𝜗 resources.

From the value 𝜗^∗, we apply the backtracking procedure on the leader variables described in Algorithm 3. For the follower variables, we apply the backtracking procedure described in [8] by taking into account both the leader and the follower objective functions, and starting with the value 𝑏−𝜗^∗.

𝜗←𝜗∗; for  𝑘=𝑛1 to 2 do     if 𝑓1𝑘(𝜗)=𝑓1𝑘−1(𝜗−𝑎1𝑘)+𝑑1𝑘  then     𝑥∗𝑘=1;     𝜗←𝜗−𝑎1𝑘;     end     else     𝑥∗𝑘=0;     end end if  𝑓11(𝜗)=0  then  𝑥∗1=0; else  𝑥∗1=1; end

Algorithm 3 

Backtracking procedure for the leader.

For a given 𝑘, if the follower has different equivalent choices, the value of 𝑦^∗_𝑘 is determined according to the profit of the leader. Note that the variable 𝑦^∗_𝑘 can take the value 0 or 1, if the two choices are equivalent for the leader and the follower. In Example 3.8, we illustrate the execution of the backtracking procedure on the instance BKP₁ used in the previous examples.

Example 3.8. The optimal value for the problem BKP₁ described in Example 3.2 is determined from Tables 2 and 3 as follows: max_0≤𝜗≤4𝑓¹_𝑛1(0)+𝑓¹_𝑛2(4),𝑓¹_𝑛1(1)+𝑓¹_𝑛2(3),𝑓¹_𝑛1(2)+𝑓¹_𝑛2(2),𝑓¹_𝑛1(3)+𝑓¹_𝑛2(1),𝑓¹_𝑛1(4)+𝑓¹_𝑛2(0)=14, (3.19) with 𝜗^∗=2.
The results of the backtracking procedure for the follower and leader of BKP₁ are given in Table 4. To determine the optimal action of the leader, we apply Algorithm 3 starting with 𝜗^∗=2. The optimal action for the leader is 𝑥^∗₁=0, 𝑥^∗₂=0, and 𝑥^∗₃=1. For the follower, we apply the backtracking procedure described in [8], starting from 4−𝜗^∗=2. The optimal reaction of the follower is 𝑦^∗₁=1, 𝑦^∗₂=0, 𝑦^∗₃=1, and 𝑦^∗₄=0.

Table 4 

Backtracking procedure for the follower and leader of BKP₁.

3.5. Outline of the Algorithm

The outline of our exact algorithm for BKP is given in Figure 1. Each box in this figure corresponds to a step of our algorithm. The numbers identify the sequence by which the operations are performed.

Figure 1 

Outline of the algorithm.

The algorithm starts by computing an upper bound for BKP through the exact resolution of HBKP. The next step consists in finding a good lower bound for BKP by computing a feasible solution for the problem. For this purpose, we solve first the problem CBKP using Algorithm 1. As referred to in Section 3.1, each solution generated by Algorithm 1 can be associated to a value of the parameter 𝑧 in FBKP_𝑧. From the set of solutions found by Algorithm 1, we select the 𝑛 best solutions, and we solve the 𝑛 problems FBKP_𝑧 for the corresponding values of the parameter 𝑧.

The upper and lower bounds (denoted, resp., by UB and LB in Figure 1) obtained in the previous steps are used to fix the variables of the leader to their optimal values. This is done by applying the fixing rules discussed in Section 3.2. The resulting problem is called the reduced problem in Figure 1. The lower bound LB is then used to reduce the size of the interval of possible values for 𝑧. The new computed interval may help in reducing the number of steps of the dynamic programming procedures that are applied next. Similarly, the size of the reduced problem (i.e., solved with dynamic programming in the next step of the algorithm) is smaller than the original BKP, and hence, it is easier to solve using dynamic programming.

The next step of our algorithm consists in applying the forward phase of the dynamic programming procedure to the reduced problem in order to compute the value of an optimal solution for BKP. Finally, from this optimal value, an optimal solution for BKP is generated using the backtracking procedure described in Section 3.4.2.

4. Computational Results

In this section, we report on the results of the computational study that was performed to evaluate the performance of our algorithm. Our approach is compared with other methods proposed in the literature. The limits of our algorithm are discussed, and a strategy to overcome these limits is presented and tested. All the algorithms analyzed in this section were coded in C++. We used the version 12.0 of the commercial optimization solver CPLEX. The experiments were conducted on a PC with 2.4 GHz with 4 GB of RAM.

Three sets of computational experiments were performed. In the first one, we compare our algorithm with the branch-and-bound algorithm proposed by Moore and Bard in [9]. In the second one, we perform a comparative study between our algorithm and the method of Brotcorne et al. described in [10]. The third set of experiments was conducted to analyze the impact of each component of our algorithm in the performance of our global approach. The limits of our algorithm are illustrated from a computational standpoint, and a variant that handles these issues is described and tested.

We used the generator proposed by Martello et al. [21] to generate instances of the knapsack problem. This generator gives us the data for the coefficients 𝑎¹, 𝑎², 𝑑¹, and 𝑐 of BKP. The value of 𝑏 is computed as follows: 𝑏=𝛼(∑^𝑛1_𝑖=1𝑎¹_𝑖+∑^𝑛2_𝑗=1𝑎²_𝑗), with 𝛼∈{0.50,0.75}. The input data for the leader (𝑑²) is generated randomly, such that all the coefficients are in the interval [1,𝐿], with 𝐿∈{100,1000}. We generated instances with uncorrelated coefficients (UC), and with correlated coefficients (C) [17].

In Table 5, we compare the performance of our algorithm (denoted by MACH1) with the branch-and-bound algorithm proposed in [9] (denoted by BM). For these experiments, we used a set of small instances with uncorrelated coefficients with 𝛼=0.25 and 𝐿=100. We generated 5 instances for each set of instances characterized by the parameters 𝑛¹ and 𝑛². In Table 5, we report on the average computing time (in seconds) required by BM and MACH1 to find an optimal solution for these instances. The computing times for BM and MACH1 are given, respectively, in the columns 𝑡_BM and 𝑡_MACH1.

Table 5 

Computing time for BM and MACH1 for uncorrelated instances with 𝐿=100 and 𝛼=0.25.

Table 5 shows the difficulty of the branch-and-bound algorithm of Moore and Bard in solving these instances, while our approach remains very fast. Note that the branch-and-bound algorithm is not able to find the optimal solution of medium instances with 𝛼=0.5, 𝑛¹=200, and 𝑛²=200 and correlated coefficients in less than one hour. As we will see in the next experiments, our approach can solve these (and larger) instances very efficiently.

The results of our second set of experiments are reported in Table 6. We compare the performance of our algorithm with the method described in [10]. In the sequel, the latter will be denoted by BHM. The algorithm BHM is composed by two phases: the first phase is a dynamic programming procedure applied to the follower problem to determine all the possible reactions of the follower; in the second phase, a reformulated integer problem is solved by making the link between the actions of the leader and the reactions of the follower.

Table 6 

Comparison between BHM and MACH1.

For these experiments, we used harder instances. The sets of instances are characterized by the parameters 𝑛¹, 𝑛², and 𝛼. Again, we generated randomly 5 instances for each set. The parameters were chosen as follows: 𝑛¹∈{50,100}, 𝑛²∈{50,100}, and 𝛼∈{0.50,0.75}. The coefficients were generated in the interval [1,1000], and we considered both uncorrelated and correlated instances. For these experiments, we used a maximum time limit of 600 seconds.

In column opt_BHM, we give the number of times the algorithm BHM finds a proven optimal solution within the maximum time limit. Note that our algorithm always finds an optimal solution within this time limit. The average computing time required by BHM and MACH1 to find a proven optimal solution is given in the columns 𝑡_BHM and 𝑡_MACH1, respectively. For BHM, the average time reported in Table 6 corresponds only to the cases where this algorithm finds a proven optimal solution within the time limit of 600 seconds.

From the results of Table 6, it is clear that our algorithm outperforms the approach of Brotcorne et al. [10]. Our approach remains very fast both for the uncorrelated and the correlated instances, while BHM is not able to find the optimum solution for most of the correlated instances. The performance of our algorithm is due in a large part to the strategies used for fixing the value of some variables, to our procedures for computing lower and upper bounds, and in particular to the strategy for reducing the interval of values for the parameter 𝑧 in FBKP_𝑧. Note that our algorithm does not have any difficulty in proving the optimality of the solution found in the backtracking phase, since the optimal value is known at the end of the forward phase. The algorithm BHM spends more time precisely in its second phase when it solves the reformulated problem. At this stage, this algorithm has no information for the value of the optimal solution. Its computing time increases quickly with the correlation of the instances because in this case the size of the reformulated integer problem becomes larger.

In our final set of experiments, we focus on our algorithm. Despite its efficiency compared with other approaches, our algorithm may experience some difficulties with memory space for larger instances. These difficulties are illustrated in Table 7. The instances used in this case were generated as in the previous experiments, and with the parameters 𝑛¹, 𝑛², and 𝛼 given in Table 7. For each case, we generated 5 instances. Since these difficulties are due to the dynamic programming part of our algorithm, we used in these experiments a version of MACH1 in which the procedures described in Sections 3.1, 3.2, and 3.3 are disabled. We will denote this version by MACH1′. Table 7 reports the average computing time for the MACH1′ and for a variant that will be described hereinafter. The entry mem in Table 7 means that MACH1’ did not complete because of the memory space required for its execution. This problem arises for the largest instances with 𝑛¹=500, 𝑛²=500, and 𝛼=0.75. Recall that, for the coefficient 𝑏, we have 𝑏=𝛼(∑^𝑛1_𝑖=1𝑎¹_𝑖+∑^𝑛2_𝑗=1𝑎²_𝑗). In this case, the value of 𝑏 can be very large, and that is the main cause for this memory problem.

Table 7 

Comparison between MACH1′ and MACH2′.

To overcome this issue, we propose a variant of the algorithm MACH1 (denoted by MACH2) that consists in replacing the backtracking phase based on dynamic programming in MACH1 by the exact resolution of the problem FBKP_𝑧 right after the forward phase. The forward phase gives us the optimal value for BKP. This optimal value is used for solving FBKP_𝑧. Since we know this optimal value in advance, the resolution of FBKP_𝑧 becomes easier. In MACH2, we keep only two columns for dynamic programming at each iteration of the forward phase, and hence, the memory space that is necessary decreases.

In Table 7, we report on the average computing time required by a version of this variant without the procedures described in Sections 3.1, 3.2, and 3.3 (as in MACH1’). This version will be denoted by MACH2’. All the instances are solved up to optimality with a very small increase in the computing time compared to MACH1’. With this new variant, the problem with memory space does not occur anymore.

In Table 8, we compare the complete version of the algorithm MACH2 with the version MACH2′. In our implementation of MACH2, we solved the problem FBKP_𝑧 with the 10 best solutions generated by Algorithm 1 to find a valid lower bound. The objective of these experiments was to evaluate the impact of the additional components of our approach, namely, the polynomial procedure for solving CBKP described in Section 3.1 (Algorithm 1) and the reduction procedures described in Sections 3.2 and 3.3. We generated randomly 5 instances for each set of instances as in the previous experiments with the parameters 𝑛¹, 𝑛², and 𝛼 given in Table 8. The meaning of the entries in Table 8 is the following:(i)qual_ℎ: quality of the solution obtained with Algorithm 1 described in Section 3.1 (value of the best solution given by Algorithm 1 divided by the value of the optimal solution of the BKP);(ii)𝑡_ℎ: computing time (in seconds) required by Algorithm 1;(iii)fix: percentage of variables that were fixed;(iv)int_𝑧: measure of the reduction achieved with the procedure described in Section 3.3; the values in this column are computed as follows: (ub_𝑧−lb_𝑧)/𝑏;(v)𝑡_MACH2′: computing time (in seconds) required by MACH2′;(vi)𝑡_MACH2: computing time (in seconds) required by MACH2.

Table 8 

Comparison between MACH2′ and MACH2.

From the results of Table 8, we can observe that the additional components of the algorithm have a positive impact on the performance of our global approach. The average computing times for all the sets of instances decreased with MACH2. For the set of instances with 𝑛¹=1000, 𝑛²=500, and 𝛼=0.75, the reduction is greater than 50%.

The lower bound given by CBKP is strong. Furthermore, it is computed very efficiently with Algorithm 1. The average computing time required by this algorithm is always smaller than 4 seconds. The fixing rules presented in Section 3.2 have a limited impact on the correlated instances. This can be explained by the quality of the upper bound that was considered (given by HBKP), and by the correlation between the coefficients of the instances. These rules perform better on the uncorrelated instances. While the lower bound on the optimal value of BKP does not seem to be very useful for fixing the values of the variables, it is for reducing the interval of feasible values for 𝑧. Although the size of this interval decreases for all the instances, it is more significant for the uncorrelated instances. The reduction of the size of this interval has a strong influence on the resolution of the reduced problem with dynamic programming. Indeed, it implies reducing the capacity of the knapsack constraint at each step of the dynamic programming procedures. That explains in part the better performance of MACH2 compared with MACH2′.

5. Conclusions

In this paper, we described a new exact algorithm for bilevel 0-1 knapsack problems (BKPs). We developed an original method for solving the linear relaxation of BKP, and we proposed a method for computing good feasible solutions for this problem using the information provided by the solutions of this linear relaxation. We described different strategies to enhance the resolution of BKP based on a valid upper and lower bound for the problem. Finally, we presented a dynamic programming procedure to find the integer optimal solution of the problem. To evaluate the performance of our approach, we conducted a set of computational experiments. Our results were compared with other algorithms proposed in the literature. The results that we obtained show that our algorithm clearly outperforms other state-of-the-art methods presented so far.

Acknowledgments

This work was partially supported by the Portuguese Science and Technology Foundation through the postdoctoral Gsssrant SFRH/BPD/64766/2009 for Raid Mansi, by the Algoritmi Research Center of the University of Minho for Cláudio Alves and José Valério de Carvalho, and by the International Campus on Safety and Intermodality in Transportation, the Nord-Pas-de-Calais Region, the European Community, the Regional Delegation for Research and Technology, the Ministry of Higher Education and Research, and the National Center for Scientific Research for Saïd Hanafi. The authors would like to thank the anonymous referees for their constructive comments, which helped improving the quality of the paper.