An efficient hybrid heuristic method for the 0-1 exact k-item quadratic knapsack problem

An efficient hybrid heuristic method for the 0-1 exact k-item quadratic knapsack problem

Lucas LétocartI, ^*; Marie-Christine Plateau^II; Gérard Plateau^I

^IUniversité Paris 13, Sorbonne Paris Cité, LIPN, CNRS, (UMR 7030), F-93430 Villetaneuse, France. E-mails: [e-mail], [e-mail]

^IIGDF SUEZ, 2, place Samuel de Champlain, F-92930 Paris La Défense cedex, France. E-mail: [e-mail]

ABSTRACT

The 0-1 exact k-item quadratic knapsack problem (E - kQKP) consists of maximizing a quadratic function subject to two linear constraints: the first one is the classical linear capacity constraint; the second one is an equality cardinality constraint on the number of items in the knapsack. Most instances of this NP-hard problem with more than forty variables cannot be solved within one hour by a commercial software such as CPLEX 12.1. We propose therefore a fast and efficient heuristic method which produces both good lower and upper bounds on the value of the problem in reasonable time. Specifically, it integrates a primal heuristic and a semidefinite programming reduction phase within a surrogate dual heuristic. A large computational experiments over randomly generated instances with up to 200 variables validates the relevance of the bounds produced by our hybrid dual heuristic, which yields known optima (and prove optimality) in 90% (resp. 76%) within 100 seconds on the average.

Keywords: quadratic programming; 0-1 knapsack; quadratic convex reformulation; semidefinite programming; surrogate duality; hybridization, experiments.

1 INTRODUCTION

The 0-1 exact k-item quadratic knapsack problem consists of maximizing a quadratic function subject to a linear capacity constraint with an additional equality cardinality constraint:

where n denotes the number of items, and all the data, k (number of items to be placed in the knapsack), a_j (weight of item j), c_ij (profit associated with the selection of items i and j) and b (capacity of the knapsack) are nonnegative integers. Without loss of generality, matrix C = (c_ij) is assumed to be symmetric.

Moreover, we assume that max in order to avoid either trivial solutions or variable fixing via constraint (1). Let us denote by k_max the largest number of items which could be filled in the knapsack, that is the largest number of the smallest aj whose sum does not exceed b. We assume that k Є {2,..., k_max},where k_max can be found in O(n) time [3, 20]. If not, either the value of the problem is equal to max_i=1,...,ncii (for k = 1), or the domain of (E - kQKP) is empty (for k > k_max).

Let us also note that on the one hand, by dropping constraint (1), (E - kQKP) isa k-cluster problem [6], and that on the other hand, by dropping constraint (2), it becomes a classical quadratic knapsack problem [32]. We can therefore conclude that problem (E - kQKP) is NP-hard, as it includes two classical NP-hard subproblems.

Numerous approaches have been proposed for solving general 0-1 quadratic problems (QP). Many are devoted to reformulations before searching an optimal solution of (QP), including 0-1 linear reformulations [1, 36] and 0-1 convex quadratic reformulations [8, 9]. Various heuristic and exact methods have been designed for (QP), including algebraic, dynamic programming, cutting plane, penalty and enumerative methods as well as metaheuristics, using different types of relaxations, such as roof duality, Lagrangian relaxation and decomposition, semidefinite programming, convex quadratic relaxation or convex hull relaxation (see, e.g., [12, 16, 25, 26, 30, 37]).

To the best of our knowledge, however, problem (E - kQKP) has not been studied before. It is an extension of the 0-1 exact k-item linear knapsack problem [13, 19, 28] which may be considered as a subproblem of the 0-1 collapsing knapsack problem (see, e.g., [34]). Its applications cover those found in previous references for k-cluster or classical quadratic knapsack problems (e.g., task assignment problems in a client-server architecture with limited memory), but also multivariate linear regression and portfolio selection. Specific heuristic and exact methods including branch-and-bound and branch-and-cut with surrogate relaxations have been designed for these applications (see, e.g., [4, 5, 10, 31, 35]).

Section 2 shows that this NP-hard problem can be considered as unsolvable to optimality for sizes exceeding 40 variables by using a state-of-the-art software (e.g., CPLEX 12.1). More specifically, it cannot be guaranteed that instances of equal or larger sizes can be solved exactly within an hour (Section 2.2). Even using a quadratic convex reformulation [8, 9] as a preprocessing phase, CPLEX cannot solve to optimality instances with sizes greater than 90 variables (Section 2.3).

After presenting a basic primal heuristic (Section 3), we present efficient dual heuristics that produce both good lower and upper bounds on the value of problem (E - kQKP) in reasonable time. For this purpose, we propose to explore the potential of different types of duals of (E - kQKP) based on either Lagrangian relaxations, or a positive semidefinite relaxation or a surrogate relaxation (this work extends our previous works on this subject [29]).

Testing different types of Lagrangian relaxations and Lagrangian decompositions produces poor computational results, namely, weak upper bounds and large computation times. This lead us to exclude the construction of effective bounds in this way.

Section 4 describes our first effective and fast dual heuristic. It is based on the quadratic convex reformulation [8, 9] of Section 2.3 associated with the solution of a semidefinite relaxation. More specifically, each step of this iterative procedure consists in fixing variables to zero in a solution produced by a semidefinite relaxation, before using our fast primal heuristic over the reduced problem.

Section 5 details another efficient dual heuristic. It is based on a surrogate relaxation after relaxing constraint (2) as an inequality constraint, and exploits the tree searches used at each step of the solution of the surrogate dual.

Finally, in Section 6 we propose a fast and efficient hybrid heuristic method that combines our previous three heuristics. It integrates the primal heuristic and the surrogate dual heuristic within the semidefinite programming reduction phase.

A number of computational results obtained for randomly generated instances with up to 200 variables is presented throughout the paper (see Section 2.1 for details about the computational environment). They validate the relevance of the bounds produced by our hybrid heuristic method, which yields known optima (and prove optimality) in 90% (resp. 76%) within 100 seconds on the average.

2 PRACTICAL DIFFICULTY OF THE PROBLEM

This section proposes to detail computational experiments to exhibit the practical difficulty of the NP-hard problem (E - kQKP). For this purpose, we study the experimental behaviour of the state-of-the-art software CPLEX 12.1 for solving exactly the benchmark instances described in Section 2.1. We conduct two series of experiments by using CPLEX 12.1 with default settings: the first one, on the original models, that is in particular without any previous reformulation of the problem (Section 2.2); the second one, on the modified models produced by the quadratic convex reformulation method QCR of the problem [8, 9] (Section 2.3). They show that CPLEX either without or with this previous reformulation, is not able to solve to optimality instances with more than 90 variables in a reasonable time.

2.1 Computational environment

All the experiments have been carried out on an Intel Xeon bi-processor dual core 3 GHz with 2 GB of RAM (using 4 cores for Sections 2.2 and 2.3, and only one core for all the other Sections).

For the benchmark, we always present average values over 10 instances. For n Є {10, 20, 30,..., 200},we fix k Є [1, n/4], b Є [50, 30k],and aj, C_ijЄ [1, 100]. These data intervals have been empirically chosen with the aim to get hard instances.

We always use the standard solver CPLEX 12.1 with default settings [18]. To solve semidefinite programs, we choose the software CSDP, integrated into COIN-OR [17], which applies the interior point method developed by Borchers [11].

In all the tables:

- δ represents the density of the quadratic matrix,

- the CPU time values are given in seconds,

- the duality gap for each upper bound proposed in this paper is defined as100 , where opt is the best known lower bound for the value of the problem, that is either the optimal value, or the best lower bound found by one of our heuristics,

- in the same way, the duality gap for each lower bound proposed in this paper is defined as , where opt is the best known upper bound for the value of the problem, that is either the optimal value, or the best upper bound computed by one of our dual algorithms or by CPLEX 12.1.

Note that to compute these gaps, some optimal values and some best upper bounds were obtained using CPLEX on a supercomputer (40 cores and 500 GB of RAM).

2.2 Numerical experiments with CPLEX 12.1

As the default preprocessing of CPLEX is able to convexify a non convex 0-1 problem, it is possible to run this state-of-the-art software without any previous reformulation of the problem. Results of Tables 1 and 2 highlight how huge the duality gaps are, i.e., the gaps between the optimal continuous and integer values. For smaller densities (Table 1), all instances can be solved within one hour, except for δ = 50%, where one instance cannot be solved to optimality. For larger densities (Table 2), for 40 and 50 variables, one or two instances cannot be solved exactly (see the numbers in brackets).

2.3 A quadratic convex reformulation of the problem

Recent work by Billionnet, Elloumi & M-C. Plateau [9] and Billionnet, Elloumi & Lambert [8] highlights the great interest of an adequate convexification of the problem. Indeed, the performance of a state-of-the-art solver is greatly improved when it is applied after their quadratic convex reformulation called QCR, i.e., these authors observed a drastic improvement in bound quality as well as in efficiency. This is the case for the instances of our benchmark (see the results of Section 2.3.2). Section 2.3.1 details before the application of the QCR method for our problem.

2.3.1 The QCR method

It consists of reformulating a nonconvex 0-1 quadratic maximization problem into an equivalent 0-1 program with a concave quadratic function. Then, the reformulated problem can be efficiently solved by a classical branch-and-bound algorithm based on continuous relaxation. The fundamental objective of this convexification method is therefore to construct a model whose continuous relaxation is as tight as possible.

In summary, QCR is a two-phase method, whose main phase is the preprocessing one:

•Phase 1 - Replace the objective function f(x) by a concave quadratic objective function f_α,u(x) depending on two parameters α and u both in ℝⁿ to get an equivalent convex 0-1 program (see below).

•Phase 2 - Apply a standard 0-1 convex quadratic solver to this new problem.

To be more specific, the first phase consists of perturbing the objective function by subtracting two functions, equal to zero on the feasible set and depending on two parameters.

Billionnet, Elloumi & M-C. Plateau [9] replace f (x) by:

Following the results of Faye & Roupin [21], Billionnet, Elloumi & Lambert [8] propose to replace f(x) by:

The use of either of these new functions leads to identical bounds at the end of phase 1 of the QCR method. The use of the second, however, consumes the least amount of computation time. We propose thus to exploit f_u,v (x) for our experiments.

The aim is thus to determine the best values of the parameters u* Є ℝⁿ and v* Є ℝ so that the new function f_u*,v* (x) is concave and the upper bound obtained by its continuous relaxation is minimal. They are the values that optimize the following problem:

To obtain these optimal parameters, following Billionnet et al. [8], we solve the following semi-definite relaxation of (E - kQKP):

where constraint (4) has been introduced to tighten the optimal value of the problem. It consists of replacing each product x_ix_j by a variable X_ij in (i.e., the square of constraint (2)).

The optimal values u_i* (i = 1,...,n) (resp. v*) of problem (P) are simply given by the optimal values of the dual variables of (E - kQKP_SDP) associated with constraints (3) (resp. (4)).

2.3.2 Numerical experiments

As it is shown in [8, 9], the general QCR method produces better upper bounds and so better CPU times (including times taken to solve SDP) for different classes of 0-1 quadratic programming problems. Applying the QCR reformulation before solving our instances with CPLEX 12.1, it is now possible to solve efficiently instances up to 90 items, except for one instance with δ = 75% (see Tables 3 and 4, where CPU times include the QCR reformulation effort). For larger sizes, up to 5 instances per class cannot be solved to optimality (see the numbers into brackets). Thus, in spite of the major improvement realized by using the QCR method (see for n equal to 50, the large gap between results reached by CPLEX alone and CPLEX via QCR), all these experiments reinforce our purpose to elaborate dual heuristics which are able to produce within reasonable time both good lower and upper bounds for the value of problem (E - kQKP).

3 A PRIMAL HEURISTIC

This section presents a first lower bound for the value of problem (E - kQKP).This basic primal heuristic, denoted by H_pri, is derived from a classical heuristic devoted to the quadratic knapsack problem [7]. As this straightforward approach exclusively provides a lower bound and consumes negligible computation times, it should be considered as a basic tool for our dual heuristics (see next Sections).

3.1 The heuristic H_pri

The primal heuristic method proposed below, denoted by H_pri, is an adaptation of a well-known heuristic developed by Billionnet & Calmels [7] for the classical quadratic knapsack problem (QKP). Thus, our approach links together a destructive phase and a constructive phase, the latter including a greedy algorithm and a local search. These two phases are summarized below (see Fig. 1 for more details):

• Destructive phase - A greedy algorithm derived from that of Chaillou, Hansen & Ma-hieu [15], is performed to produce a solution starting from the vector e = 1ⁿ of ℝⁿ. This destructive procedure is simply adapted to provide a solution satisfying the capacity constraint and with a number of items is less than or equal to k . This is achieved by removing iteratively item i with the smallest utility function of the type

•Constructive phase - This part performs fill up and exchange procedures. Derived from Gallo, Hammer & Simeone's method [23], its objective is two-fold: first, to get from a feasible solution of (E - kQKP), that is a solution satisfying the constraint capacity whose number of items placed in the knapsack is now exactly equal to k (i.e., a < b and e = k); second, to find finally a solution ^pri which improves the quality of solution .

3.2 Numerical experiments

As a general remark, we note that our primal heuristic H_pri is very fast, since for all instances it took less than 0.04 seconds. The duality gaps are rather small, for all instance sizes (see Fig. 2 and Table 5). The best gap values are obtained for the larger densities. Nevertheless, these gaps are markedly greater than those obtained for the classical quadratic knapsack problem, which are generally less than 1%.

4 A SEMIDEFINITE PROGRAMMING HEURISTIC

Our first effective and fast dual heuristic, denoted by H_sdp, is based on semidefinite programming (Section 4.1). Each step of this iterative procedure consists in fixing variables to zero in a solution produced by a semidefinite relaxation of the problem, before using our very fast primal heuristic over the reduced problem (Section 4.2). The computational experiments highlight the gain obtained by this algorithmic tool which dominates heuristics H_pri for all instances (Section 4.3). H_sdp is very fast, since for all instances it tooks less than 4 seconds on the average.

4.1 The semidefinite programming relaxation

Let us recall [8] that from the semidefinite relaxation (E - kQKP_SDP) defined in Section 2.3.1, we get optimal multipliers u* Є ℝⁿ and v* Є ℝ for the QCR method such that:

We can therefore expect that problem (E - kQKP_SDP) produces good upper bounds for problem (E - kQKP) and at the same time, produces a solution, denoted by x^sdp, which is not too far from a good solution of (E - kQKP) (see [26, 27] for results concerning other types of 0-1 quadratic problems).

Numerical experiments. Solving the semidefinite relaxation (E - kQKP_SDP) is rather fast: CPU times increase with the sizes of the instances without exceeding five seconds. Observing gap quality for all densities of matrix C in Figure 4 (a), the behavior of this relaxation is clearly unstable. Even if the average gap can be large (up to 150% for some instances), we still propose to use this semidefinite program for designing our heuristic H_sdp.

4.2 The heuristic H_sdp

This heuristic method solves first the semidefinite relaxation (E - kQKP_SDP) defined in Sections 2.3.1 and 4.1. Then an iterative procedure based on the associated solution x^sdp is initiated. More specifically, each step of this procedure consists in fixing more and more variables to zero in x^sdp, before using our very fast primal heuristic H_pri over the reduced problem. An attempt to update the solution produced by H_pri is then applied by performing the fill-up and exchange procedure of Figure 1 on the global problem, i.e., with the n variables (see Fig. 3 for more details).

4.3 Numerical experiments

The performance of heuristic H_sdp is analyzed through the numerical results laid out in Tables 5, 6 and 7. Table 5 shows a great improvement regarding the quality of the duality gap. It is about three times better than that obtained by H_pri. Tables 6 and 7 complete this information by splitting the results into two categories: small sizes (n < 100) and larger sizes (n ≥ 110). They reveal that CPU times remain rather low, since heuristic H_sdp tooks less than 4 seconds on the average.

5 A SURROGATE DUAL HEURISTIC FOR (E - kQKP)

Let us consider another effective dual heuristic, denoted by H_sur, based on a surrogate relaxation. Eventually, this algorithmic tool will prove to be an efficient and robust method: it proves optimality for 46% of the 640 instances, within one minute on the average.

5.1 A surrogate dual algorithm

We actually use a double relaxation. We first consider the following problem for which the equality cardinality constraint (2) is transformed into an inequality constraint (2'):

Second, we consider a surrogate relaxation of this 0-1 quadratic bi-knapsack problem, by combining the two constraints (1) and (2'). To solve the associated surrogate dual problem, we use the scheme of the algorithm SADE² developed by Fréville & G. Plateau [22] for the surrogate dual of linear 0-1 bi-dimensional knapsack problems. SADE² is a one-dimensional dichotomic search over the compact interval [0,1], which revisits Glover's method [24] for guaranteeing optimality in a finite number of iterations.

In short, given a multiplier µЄ [0, 1], algorithm SADE² determines first an order on the two constraints (1) and (2'), so that the surrogate relaxation can be written as:

with either

or

For a given µ, let x* (µ) be an optimal solution of problem (S(µ)), if x* (µ) satisfies simultaneously the two constraints, it is obviously an optimal solution of problem (kQKP). If, in addition, ax*(µ) = k, the problem (E - kQKP) is solved. Otherwise, procedure SADE² performs its dichotomic search by using the fact that x*(µ) satisfies the first (resp. second) constraint and violates the second (resp. first) one, and by exploiting the ratio (b₁ - A₁x*(µ))/A2x*(µ)- b₂) to update the interval bounds (see [22]).

As the theoretical results for this method depend only on properties of the bi-constraint system, its adaptation for the quadratic case is straightforward. In addition, at each iteration of the procedure, we propose to exploit the approach of Caprara, Pisinger & Toth [14] for solving the associated quadratic 0-1 knapsack instance (this requires to adapt their code for accepting a constraint with real data). The first step of Caprara et al.'s method consists of linearizing (S(µ)) as follows:

where N denotes the set of {1,..., n}. For this 0-1 linear problem, denoted by (LP(µ)),the binary variables y_ij are introduced to replace the product x_i x_j . These new variables are linked to the old one by suitable inequalities. Indeed, constraints (5) result from multiplying the capacity constraint by each variable and replacing x²_j by x_j since the variables are binary variables. They are redundant as long as the integer restriction on the variables is imposed. Caprara et al. solve this problem by a branch-and-bound method based on a depth-first search strategy with a static order of the variables for branching. It uses a preprocessing phase which reduces the size of the problem through variable fixing. Its effectiveness is obtained by algorithmic choices and data structures that favor simplicity and incrementality (as for the algorithm designed for the linear 0-1 knapsack problem in [33]). In particular, their evaluation of nodes is based on a Lagrangian relaxation of (LP(µ)) which dualizes the symmetric constraints (6). The authors highlight a beautiful decomposition result which shows that solving this relaxation is equivalent to solve n + 1 linear 0-1 knapsack problems. Furthermore, for controling time complexity, the authors decide to relax the integer conditions on variables. This leads to an evaluation which can be produced in 0(n²) time since each continuous linear knapsack problem can be solved in 0(n) time [20].

From a practical point of view, in order to control CPU times (i.e., to speed up achieving good upper bound for v(kQKP) and thus for v(E - kQKP)), we propose to search an approximate value of the surrogate dual (S) of (kQKP) by means of the following two algorithmic adaptations:

- approximation 1 (solving problem (S(µ))):

We add a CPU time limit (one minute, in our case) in the branch-and-bound search of Caprara et al.'s method. Obviously, this stopping criterion is effective when the Lagrangian relaxation evaluation is inefficient. In practice, this occurs for values of µ close to zero, or for the greater instance sizes (around 200 variables). In this situation, we have retained first the upper bound v^up (S(µ)) on the value of (S(µ)), equal to the maximal evaluation over the pending nodes of the search tree, and also the associated solution x^up(µ) of (S(µ)).

- approximation 2 (in the dichotomic search):

The performance of Caprara et al.'s method is poor for a problem like (S(0)), whose constraint coefficients are all identical (equal to one here). When no solution is found by Caprara et al.'s method within the CPU time limit, we propose to increase multiplier µ step by step from zero (i.e., we start with value 0.01, then double that value each time). This process stops as soon as a multiplier x^t is found such that problem (S(µ^t)) can be solved to optimality within the CPU time limit.

While approximation 2 implies that the set M of multipliers generated by our approximate dual algorithm may miss the optimal multiplier µ* for (S), with approximation 1, we can conclude that our dual algorithm finds an upper bound (S) of v(S) defined as follows:

where is equal to v^up(S(µ)) if approximation 1 is being used, or v(S(µ)) otherwise. We can then state the following result:

Proposition.

Finally, in the algorithm of Figure 5, for any µ, solving (S(µ)) may be solve (S(µ)) approximately when approximation 1 occurs. In this case, we exploit the solution x^up (µ) (see above) that may differ from x* (µ). All along our approximate dual method, we propose to denote this solution by (µ), which is equal to x^up (µ) if approximation 1 is being used, or x* (µ) otherwise.

Numerical experiments. As for the linear case, our approximate surrogate dual value is reached in a finite number of iterations (at most 10 iterations here). From the results obtained with this dichotomic procedure, two global remarks may be mentioned: first, CPU times do not exceed seven minutes on the average and above all the quality of upper bounds is very good (see Fig. 4(b)). Second, more than 75% of gap values are improved in comparison with those produced by the semidefinite programming relaxation (see Section 4).

5.2 The surrogate dual heuristic H_sur

Classically, our surrogate dual heuristic, denoted by H_sur, keeps the best feasible solution of (E - kQKP), denoted by ^sur, produced by the dichotomic procedure described in Figure 5. It computes both a lower bound f(^sur) and an upper bound (S) (see Section 5.1) of v(E - kQKP).

More specifically, at each iteration of our dichotomic procedure, that is for each multiplier µ in the set m defined above, we retain the best feasible solution - denoted by (µ) - produced by the branch-and-bound depth first search, which satisfies the cardinality constraint exactly (i.e., a (µ) < b and e(µ) = k).

As the procedure starts by using the very fast heuristic H_pri, the solution ^sur produced by our heuristic H_sur is such that:

Using an analysis of the experimental results of the previous section, the single adjustment of our procedure consists in reducing to half a minute the CPU time threshold for solving (S(µ)) approximately (its solution is denoted by (µ) (see Section 5.1)). This allows first, to speed up the search with a negligible loss in gap quality and second, to get a dual heuristic which is both effective and robust. Finally, it should be noted that problem (E - kQKP) is solved exactly when a problem S(µ) is solved exactly for a given µ in m and when its optimal solution (µ) is primal feasible for (E - kQKP) (see Proposition of Section 5.1).

Numerical experiments. The numerical results of Figure 6 (associated with those of Table 6 and Table 7) show the high quality of the lower bounds provided by our surrogate dual heuristic H_sur. It tends to dominate heuristic H_sdp on the instances of small sizes (n < 100), while the reverse is true for the larger sizes (n ≥ 110). It should be noted that 46% of the instances are in fact exactly solved by our surrogate dual heuristic. Although CPU times of H_sur increase with the size of the instances, they never exceed two minutes. Moreover, for each density, the mean time is around one minute.

6 A HYBRID DUAL HEURISTIC

Our fast and efficient hybrid heuristic method, denoted by H_hybrid, combines the heuristics described in Sections 3, 4 and 5. It integrates the primal heuristic and the surrogate dual heuristic within the semidefinite programming reduction phase. It proves to get best duality gaps in a reasonable time for all instances of our benchmark.

6.1 The heuristic H_hybrid

The aim of this heuristic (see Fig. 7) is to get better solutions than those provided by our heuristics H_sdp and H_sur. It starts by performing H_sur which includes heuristic H_pri (see Fig. 5). We then apply heuristic H_sdp (see Fig. 3) in which heuristic Hsur is used for a second and last time. We are thefore sure to And a solution x^hybrid as good as that produced by both heuristics H_pri, H_sdp and H_sur. In addition, computation times remain reasonable since heuristic H_sur is used only two times. They are in addition to the reasonable time of H_sdp.

6.2 Numerical experiments

The computational experiments validate the relevance of the bounds produced by our hybrid heuristic method which combines quality (i.e., duality gap is about 1.20 % on the average) and efficiency (i.e., CPU time is about one minute and a half on the average).

Figure 8 with Tables 6, 7 and 8 summarize the performance of heuristic H_hybrid. Additional computational experiments have been realized by performing CPLEX 12.1, instance by instance, within the associated CPU time of heuristic H_hybrid. The results with this limited time CPLEX software, denoted by LT - CPLEX, are listed in Tables 6 and 7. Figure 9(a) (duality gaps) show clearly, instance size by instance size, the dominance of H_hybrid over H_sur and LT - CPLEX.

Table 8

For the set of 550 instances (resp. 640 instances), heuristic H_hybrid yields thus known optima in 90% (resp. 76%) of the cases and proves optimality in 63% (resp. 49%) of the cases, within less than 100 seconds on the average. These scores are even better for instances with sizes from 50 to 100 variables. For example, H_hybrid yields known optima in 96% of the cases (i.e., 232 of 240 instances).

Finally, Figure 9(b) shows that CPU time of H_hybrid increases with the size of the instances, but never exceed two minutes and a half.

7 CONCLUSION

This paper proposes fast computations of lower and upper bounds for the 0-1 exact k-item quadratic knapsack problem (E - kQKP). Thanks to these bounds, our experiments highlight the possibility to solve now instances up to 200 variables whatever their density. Computational experiments point out the efficiency and the robustness of our hybrid heuristic method: it yields known optima in 90% of the cases and proves optimality in 76% of the cases, within 100 seconds in average. Further work concerns obviously the improvement of the lower bounds but we presume that we have to concentrate one's effort on the upper bounds for instances with large sizes. Thus, we plan to study new types of relaxations such that the convex hull relaxation (see [2]). A final perspective consists in embedding these high-quality bounds in a branch-and-bound scheme for the exact solving of (E - kQKP).

ACKNOWLEDGEMENTS

This work was partially conducted on the Magi cluster at Université Paris 13, and available at http://www.univ-paris13.fr/calcul/wiki/.

Received March 11, 2013

Accepted February 21, 2014

• [1] Adams WP, Forrester R & Glover F. 2004. Comparisons and enhance ment strategies for linearizing mixed 0-1 quadratic programs. Discrete Optimization, 1(2): 99-120.
• [2] Ahlatjoglu A & Guignard M. 2007. The convex hull relaxation for nonlinear programs with linear constraints. Technical report, OPIM Department, Wharton School (USA).
• [3] Balas E & Zemel E. 1980. An algorithm for large zero-one knapsack problems. Operations Research, 28: 1130-1154.
• [4] Bertsimas D & Shioda R. 2009. Algorithm for cardinality-constrained quadratic optimization. Computational Optimization and Applications, 43: 1-22.
• [5] Bienstock D. 1996. Computational study of a family of mixed-integer quadratic programming problems. Mathematical Programming, 74: 121-140.
• [6] Billionnet A. 2005. Different formulations for solving the heaviest k-subgraph problem. Information Systems and Operational Research, 43(3): 171-186.
• [7] Billionnet A & Calmels D. 1996. Linear programming for the 0-1 quadratic knapsack problem. European Journal of Operational Research, 92: 310-325.
• [8] Billionnet A, Elloumi S& Lambert A. Extending the QCR method to general mixed-integer programs. Mathematical Programming, Pub. on line, 21 pages, Doi: 10.1007/s10107-010-0381-7.
• [9] Billionnet A, Elloumi S & Plateau M-C. 2009. Improving the performance of standard solvers via a tighter convex reformulation of constrained quadratic 0-1 programs: the QCR method. Discrete Applied Mathematics, 157: 1185-1197.
• [10] Bonami P & Lejeune M. 2009. An exact solution approach for portfolio optimization problems under stochastic and integer constraints. Operations Research, 57: 650-670.
• [11] Borchers S. 1999. CSDP, a C library for semidefinite programming. Optimization methods and Software, 11(1): 613-623.
• [12] Boros E & Hammer P. 2002. Pseudo-boolean optimization. Discrete Applied Mathematics, 123:115-225.
• [13] Caprara A, Kellerer H, Pferschy U & Pisinger D. 2000. Approximate algorithms for knapsack problems with cardinality constraints. European Journal of Operational Research, 123: 333-345.
• [14] Caprara A, Pisinger D & Toth P. 1999. Exact solution of the quadratic knapsack problem. INFORMS Journal on Computing, 11: 125-137.
• [15] ChaillouP, Hansen P & Mahieu Y. 1986. Best network flow bounds for the quadratic knapsack problem. Lecture Notes in Mathematics, 1403: 226-235.
• [16] Chardaire P & Sutter A. 1995. A decomposition method for quadratic 0-1 programming. Management Science, 41 (4): 704-712.
• [17] COIN-OR. Computational INfrastructure for Operations Research. http://www.coin-or.org
• [18] CPLEX. 2009. IBM ILOG CPLEX Callable library version 12.1 Reference manual. http://docs.hpc.maths.unsw.edu.au/ilog/cplex/12.1
• [19] Dudzinski K. 1989. On a cardinality constrained linear programming knapsack problem. Operations Research Letters, 8: 215-218.
• [20] Fayard D & Plateau G. 1982. Algorithm 47: an algorithm for the solution of the 0-1 knapsack problem. Computing, 28: 269-287.
• [21] Faye A & Roupin F. 2007. Partial Lagrangian relaxation for general quadratic programming. 4OR, 5(1): 75-88.
• [22] Freville A & Plateau G. 1993. An exact search for the solution of the surrogate dual of the 0-1 bidimensional knapsack problem. European Journal of Operational Research, 68: 413-421.
• [23] Gallo G, Hammer PL & Simeone B. 1980. Quadratic knapsack problems. Mathematical Programming Study, 12: 132-149.
• [24] Glover F. 1965. A multiphase dual algorithm for the 0-1 integer programming problem. Operations Research, 13(6): 879-919.
• [25] Hammer P, Hansen P & Simeone B. 1984. Roof duality, Complementation and Persistency in Quadratic 0-1 Optimization. Mathematical Programming, 28: 121-155.
• [26] Helmberg C & Rendl F. 1998. Solving quadratic (0,1)-problems by semidefinite programs and cutting planes. Mathematical Programming, 8(3): 291-315.
• [27] Helmberg C, Rendl F& Weismantel R. 2000. A semidefinite programming approach to quadratic knapsack problems. Journal of Combinatorial Optimization, 4: 197-215.
• [28] Kellerer H, Pferschy U & Pisinger D. 2004. Knapsack Problems. Springer-Verlag.
• [29] Létocart L, Plateau MC & Plateau G. 2007. Lagrangean and convexificationmethods for the 0-1 £-item quadratic knapsack problem. In Proceedings of NCP07 (International Conference on Non Convex Programming), Rouen (France), December.
• [30] Michelon P& Maculan N. 1991. Lagrangean decomposition for integer nonlinear programming with linear constraints. Mathematical Programming, 52(2): 303-314.
• [31] Mitra G, Ellison F & Scowcroft A. 2007. Quadratic programming for portfolio planning: Insights into algorithmic and computational issues. Part ii: Processing of portfolio planning models with discrete constraints. Journal of Asset Management, 8: 249-258.
• [32] Pisinger D. 2007. The quadratic knapsack problem: a survey. Discrete Applied Mathematics, 155:623-648.
• [33] Plateau G & Nagih A. 2010. 0-1 Knapsack Problems. In Combinatorial Optimization: Paradigms of Combinatorial Optimization (V. Paschos eds), ISTE ltd-John WILEY and Sons Pub., volume 2, chapter 8, 215-242.
• [34] Posner ME & Guignard M. 1978. The collapsing 0-1 knapsack problem. Mathematical Programming, 15: 155-161.
• [35] Shawa D, Liub S & Kopmanb L. 2008. Lagrangean relaxation procedure for cardinality-constrained portfolio optimization. Optimization Methods and Software, 23: 411-420.
• [36] Sherali HD & Adams WP. 1999. A Reformulation-Linearization Tech nique for Solving Discrete and Continuous Nonconvex Problems. Kluwer Academic Publ., Dordrecht, Boston, London.
• [37] Zhu WX. 2003. Penalty parameter for linearly constrained 0-1 quadratic programming. Journal of Optimization Theory and Applications, 116(1): 229-239.

*

Corresponding author

Publication Dates

• Publication in this collection
  08 May 2014
• Date of issue
  Apr 2014

History

• Accepted
  21 Feb 2014
• Received
  11 Mar 2013