Solving the 0-1 Multidimensional Knapsack Problem with Resolution Search

We propose an exact method which combines the resolution search and branch&bound algorithms for solving the 0?1 Multidimensional Knapsack Problem. This algorithm is able to prove large?scale strong correlated instances. The optimal values of the 10 constraint, 500 variable instances of the OR-Library are exposed. These values were previously unknown.


Introduction
In this article, we present a new exact method which hybridizes the resolution search of Chvátal (1997) and a branch & bound algorithm inspired by a previous work from Vimont et al. (2008) for the 0-1 Multidimensional Knapsack Problem (01MKP). The 01MKP is a wellknown opitmization problem which can be viewed as a resource allocation model and can be stated as follows: x j ∈ {0, 1} j = 1, ..., n where n is the number of items, m is the number of knapsack constraints with capacities b i (i = 1, 2, ..., m), c ∈ N n , A ∈ N m×n and b ∈ N m . Each item j (j = 1, 2, ..., n) yields c j units of profit and consumes a given amount of resource a ij for each knapsack i. The proposed approach is centered on two main 01MKP results: (i) the consideration of a reduced costs constraint based on the reduced costs at the optimality of the problem's LPrelaxation (see Balas and Martin (1980); Oliva et al. (2001)) and (ii) the decomposition of the search space in several hyperplane where the number of items to choose is fixed at a given integer value (see Vasquez and Hao (2001); Vimont et al. (2008)). Our algorithm is self-sufficient and does not require any lower bound as starting value. We show that the structure of resolution search enables to explore partially and iteratively different subproblems (hyperplanes with a fixed number of items) while keeping completeness. This way of exploration enhances the diversification of the search and permits to improve the lower bound rapidly. For each hyperplane, this lower bound, associated with the upper bound (tighter than the classical one given by the LP-relaxation), enforces the strength of the so-called reduced costs constraint widely used in the algorithm. Roughly speaking, if we consider that the variables are sorted in decreasing order of their reduced costs (basic variables at the bottom of the list), the enumeration of the first variables is carried out by resolution search where the enumeration of the remaining variables is tackled by our specific branch & bound. Our approach proved all the optimality of all the 10 constraint, 500 variable instances. These optimal solutions were previously unknown.

Resolution search
Resolution search was proposed by Chvátal (1997) as an alternative to branch & bound for mixed 0-1 linear programming problems. This approach, based on an original exploration of the search space, uses the information brought by the fails that have occurred during the search to progressively shrink the search tree. Each time a terminal node is reached, a minimal partial instantiation of the variables responsible for the fail is identified. This partial instantiation, which corresponds also to a terminal node, is then recorded in a specific way in order to discard the corresponding subtree from the search space and to provide the next node in the exploration. The specificity of the recording mechanism allows the algorithm to preserve space memory while keeping completeness.
Globally, resolution search is composed of two main elements: (i) a set of partial instantiations (denoted path-like family F ) corresponding to fails encountered during the search and recorded as boolean clauses and (ii) an function called obstacle which uses the information brought by the family F to explore promising parts of the search space. From a partial instantiation u(F ) derived from F , which is not an already explored instantiation, obstacle performs two different phases: 1. The waxing phase which replaces step by step the free components u(F ) j = * by 0 or 1 until a terminal node (denoted u * ) is reached (a terminal node is a partial instantiation of the variables which does not lead to any improvement of the best known lower bound).
2. The waning phase which tries to find a minimal element S of {0, 1, * } n such that S ⊑ u * and S is a terminal node (formally, let u and v be two vectors of {0, 1, * } n , we call u an extension of v and we write u ⊑ v, if v j = u j whenever u j = * ).
Once the minimal element S is identified, it is recorded in a specific way as a clause in F . The structure of F enables both to guide the search toward prosimising parts of the search space and to guaranteed the completeness using the resolution / refutation principle. Indeed, if the minimal element S correspond to the instantiation ( * , * , ..., * ) then the best known solution is an optimal soltion of P . The algorithm 1. represents the function Resolution Search which takes as parameter a lower bound (LB) of the problem.

General approach
The 01MKP is tackled by decomposing the problem in several subproblems where the number of items to choose is fixed at a given integer value. Considering that LB is a lower bound of the problem, we can define 1} n } as the set of feasible solutions strictly better than LB and consider the following problems: where 1 is the vector of dimension n with all its components equal to one andX In what follows, we note v(P ) the optimal value of a given if(try > LB) LB = try; add S to F and update F ; Solving the 01MKP by tackling separately each of the subproblems P k for k = k min , ..., k max appeared to be an interesting approach (Vasquez and Hao (2001); Vasquez and Vimont (2005); Vimont et al. (2008)) particularly because the additional constraint (1 · x = k) provides tighter upper bounds than the classical LP-relaxation. This approach takes also into consideration a constraint based on the reduced costs of the non-basic variables. Let us consider the upper bound UB = c ·x, wherex is the optimal solution of the LP-relaxation. Letc be the vector of the reduced costs and N the indexes of the non-basic variables. If we know a lower bound LB ∈ N of the problem, then each better solution x must satisfy the following constraint: (the reader is referred to Balas and Martin (1980); Oliva et al. (2001) and Vimont et al. (2008) for more details on the subject). The use of the constraint (4), also called the reduced costs constraint, is twofold: (i) it enables us to identify the unfeasibility (with respect to the constraint c · x ≥ LB + 1) of some partial solutions and (ii) it allows us to fix those variables x j with |c j | > UB − LB at their optimal valuex j . Both the tight upper bound and the good lower bound enhance the efficiency of the reduced costs constraint.
To summarize, our approach consists of decomposing the search space in several hyperplanes then solving the LP-relaxation for each one in order to generate the reduced costs constraint. The exploration is then carried out partially and iteratively for each hyperplane with resolution search until all the search space is explored.
Indeed, thanks to the structure of resolution search, P can be solved by progressively exploring each of the hyperplanes (1 · x = k, k ∈ N). Let CFamily[k] be the family of clauses associated to resolution search for the subproblem P k . At each step of the search, CFamily [k] provides all the information about the state of the search: the terminal nodes recorded at this stage and the next node to explore. It is possible to execute some iterations of resolution search at a given P k , then continue to another P k ′ and go on with the subproblem P k again without any loss of information. The algorithm 2 detail the Iterative RS algorithm which corresponds to resolution search limited to a given number of iterations and the algorithm 3 shows the hyperplane exploration using Iterative RS. This way of exploration enforces the diversification and the convergence of the search. Note that, in algorithm 3, greedy is a simple greedy function used for providing a first lower bound.

Resolution search and branch & bound combination
In this section, we detail the exploration function obstacle embedding the branch & bound algorithm.
Starting with the node u(F ) given by the path-like family F , obstacle replaces stepby-step the components * of u(F ) by 0 or 1 which constructs the node u + . If u + is a terminal node, the function provides a minimal clause S such that S ⊑ u * and S is a terminal node. Our implementation of obstacle is based on the reduced-costs constraint (4) presented in section 3. At the beginning of the procedure, the LP-relaxation of the problem is solved for each available hyperplane in order to give us the information needed for the reduced costs constraint. Then obstacle proceeds to the following steps: • The first step, called consistency phase, consists of checking the feasibility of u(F ).
Initially, we define a value gap = UB − LB. If a constraint is violated, the descent phase stops and the corresponding partial instantiation is recorded as the clause S in F . At the same time, the reduced costs constraint (4) is checked and the gap value is updated: for each non-basic variable set at the opposite of its optimal value (1 −x j ), its reduced costs (c j ) is subtracted from the gap. If it happens that gap < 0 then the current partial solution is a terminal node. In this case, S is only composed of the variables set at the opposite of their optimal value in u(F ).
• If u(F ) is feasible, we go to the next step which we call implicit waning phase. This phase consists of branching on all the remaining free variables with a reduced cost greater than gap. Those variables must be fixed at their optimal value for satisfying the reduced costs constraint (4). The branching decisions taken in this phase are just a consequence of the instantiated variables in u(F ). Consequently they can be removed from S.
• Then the algorithm starts the so-called waxing phase which consists of assigning values to free variables. The chosen strategy is to select the free variable with the greater absolute reduced cost value and to assign its optimal valuex j to it. Obviously, each time a branching is done, the feasibility of the current partial solution is verified and in case of fail, the waxing phase stops and the corresponding clause S is added to F . Note that the variables set in the implicit waning phase are still not taken into account in S.
• Once the number of remaining free variables is less than or equal to a given number spb size, the waxing phase stops and the corresponding subproblem is solved with a branch & bound algorithm. This subproblem includes the free variables with the lowest reduced cost and the basic variables. Obviously, since the branch & bound algorithm explores the whole subtree corresponding to these variables, the clause S does not contain any branching choices made during this phase. Only the branching decisions taken during the consistency phase and/or the waxing phase are considered.
• The algorithm used to enumerate the variables with the lowest reduced cost, and the basic variables, is widely inspired by a previous one published by Vimont et al. (2008). As it is represented in figure 4 (which summarizes the exploration process), this algorithm embeds a specific Depth First Search (dfs) procedure for solving small subproblems with the last 20 variables.

Computational results
Our algorithm has been experimented on the well known OR-Library set of 01MKP instances proposed by Beasley (1990). Each instance of this set is denoted cbm.n r where m is the number of constraints, n the number of variables and r the instance's number. The 01MKP OR-Library benchmark is composed of 5, 10 and 30 constraint instances and 100, 250 and 500 variables instances. There are 9 set of 30 instances with each n × m combination.
We obtained better proof time than the exact published approaches of James and Nakagawa (2005), Vimont et al. (2008) and the commercial software CPLEX 9.2, for the 10 constraint, 250 variable instances and the 5 constraint, 500 variable instances. We observed also that for the 5 constraint, 500 variable instances, the times required for obtaining the best solutions are clearly better than the ones provided by the best known heuristics on these instances (Vasquez and Vimont (2005) and Wilbaut and Hanafi (2008)). Moreover, our algorithm proved the optimality of all the cb10.500 instances. The corresponding optimal values, which were previously unknown, are exposed in table 1. The column z opt is the optimal value of the instance, opt. (h) is the time in hours required for obtaining the optimal value and proof (h) is the time in hours for proving the optimality of the value z opt . The column z opt − z corresponds to the gap between the optimal value and the previously best known solution: (vv) indicates that z was first found by Vasquez and Vimont (2005) and (wh) indicates that z was first found by Wilbaut and Hanafi (2008).

Conclusion
Although our implementation of resolution search is quite far from the original one proposed by Chvátal, especially because we have exploited specific structures of the 01MKP (hybridization with branch & bound, 1.x = k hyperplane decomposition, reduced cost constraint to generate implicitly the partial instantiations responsible for the fails, etc.), we showed that resolution search is a promising framework for designing efficient algorithms. Since the proof times are long for the 10 constraint, 500 variable instances, we plan to improve again our algorithm in order to accelerate the resolution process in the hope of maybe closing the OR-Library 01MKP benchmark by solving the 60 last 30 constraint 250/500 variable instances.