Algorithm For Knapsack Problem Research Articles

Artificial Glowworm Swarm Optimization Algorithm for Solving 0-1 Knapsack Problem

In this paper, an artificial glowworm swarm optimization algorithm for solving 0-1 knapsack problem is proposed, and the detailed realization of the algorithm is illustrated. According to intelligent algorithm for knapsack problem, the question of sensitive parameter’s choice is avoided under the greed idea. Simulation results show that the artificial glowworm swarm optimization algorithm for solving 0-1 knapsack problems is feasible and effective.

A cross entropy algorithm for the Knapsack problem with setups

In this article we propose a new metaheuristic-based algorithm for the Integer Knapsack Problem with Setups. This problem is a generalization of the standard Integer Knapsack Problem, complicated by the presence of setup costs in the objective function as well as in the constraints. We propose a cross entropy based algorithm, where the metaheuristic scheme allows to relax the original problem to a series of well chosen standard Knapsack problems, solved through a dynamic programming algorithm. To increase the computational effectiveness of the proposed algorithm, we use a turnpike theorem, which sensibly reduces the number of iterations of the dynamic algorithm. Finally, to testify the robustness of the proposed scheme, we present extensive computational results. First, we illustrate the step-by-step behavior of the algorithm on a smaller, yet difficult, problem. Subsequently, to test the solution quality of the algorithm, we compare the results obtained on very large scale instances with the output of a branch and bound scheme. We conclude that the proposed algorithm is effective in terms of solution quality as well as computational time.

Hybrid rounding techniques for knapsack problems

We address the classical knapsack problem and a variant in which an upper bound is imposed on the number of items that can be selected. We show that appropriate combinations of rounding techniques yield novel and more powerful ways of rounding. Moreover, we present a linear-storage polynomial time approximation scheme (PTAS) and a fully polynomial time approximation scheme (FPTAS) that compute an approximate solution, of any fixed accuracy, in linear time. These linear complexity bounds give a substantial improvement of the best previously known polynomial bounds [A. Caprara, et al., Approximation algorithms for knapsack problems with cardinality constraints, European J. Oper. Res. 123 (2000) 333–345].

Proposal of Adjustment Type Genetic Algorithm for Knapsack Problem

The greedy algorithm is one of solution methods for knapsack problem. Although this algorithm does not necessarily obtain the optimal solution, it can obtain a good solution in short time. We consider this algorithm is very effective at judging the importance of each item.In this paper, we propose a new genetic algorithm for solving a knapsack problem. The algorithm can adjust a search area in consideration of the stability of each item which can obtain from the greedy algorithm. Moreover, we apply the proposed method to a multi-objective problem and a large-scale problem, and test the effectiveness.

Cost Based Filtering for the Constrained Knapsack Problem

We present cost based filtering methods for Knapsack Problems (KPs). Cost based filtering aims at fixing variables with respect to the objective function. It is an important technique when solving complex problems such as Quadratic Knapsack Problems, or KPs with additional constraints (Constrained Knapsack Problems (CKPs)). They evolve, e.g., when Constraint Based Column Generation is applied to appropriate optimization problems. We develop new reduction algorithms for KP. They are used as propagation routines for the CKP with Θ(nlog n) preprocessing time and Θ(n) time per call. This sums up to an amortized time Θ(n) for Ω(log n) incremental calls where the subsequent problems may differ with respect to arbitrary sets of necessarily included and excluded items.

Approximation algorithms for knapsack problems with cardinality constraints

We address a variant of the classical knapsack problem in which an upper bound is imposed on the number of items that can be selected. This problem arises in the solution of real-life cutting stock problems by column generation, and may be used to separate cover inequalities with small support within cutting-plane approaches to integer linear programs. We focus our attention on approximation algorithms for the problem, describing a linear-storage Polynomial Time Approximation Scheme (PTAS) and a dynamic-programming based Fully Polynomial Time Approximation Scheme (FPTAS). The main ideas contained in our PTAS are used to derive PTAS's for the knapsack problem and its multi-dimensional generalization which improve on the previously proposed PTAS's. We finally illustrate better PTAS's and FPTAS's for the subset sum case of the problem in which profits and weights coincide.

Linear Time Algorithms for Knapsack Problems with Bounded Weights

A new technique called balancing is presented for the solution of Knapsack Problems. It is proved that an optimal solution to the Knapsack Problem is balanced, and thus only balanced feasible solutions need to be enumerated in order to solve the problem to optimality. Restricting a dynamic programming algorithm to only consider balanced states implies that the Subset-sum Problem, 0–1 Knapsack Problem, Multiple-choice Subset-sum Problem, and Bounded Knapsack Problem all are solvable in linear time, provided that the weights and profits are bounded by a constant. Extensive computational experiments are presented to document that the derived algorithm for the Subset-sum Problem is able to solve several problems from the literature which could not be solved previously.

A Minimal Algorithm for the 0-1 Knapsack Problem

Several types of large-sized 0-1 Knapsack Problems (KP) may be easily solved, but in such cases most of the computational effort is used for sorting and reduction. In order to avoid this problem it has been proposed to solve the so-called core of the problem: a Knapsack Problem defined on a small subset of the variables. The exact core cannot, however, be identified before KP is solved to optimality, thus, previous algorithms had to rely on approximate core sizes. In this paper we present an algorithm for KP where the enumerated core size is minimal, and the computational effort for sorting and reduction also is limited according to a hierarchy. The algorithm is based on a dynamic programming approach, where the core size is extended by need, and the sorting and reduction is performed in a similar “lazy” way. Computational experiments are presented for several commonly occurring types of data instances. Experience from these tests indicate that the presented approach outperforms any known algorithm for KP, having very stable solution times.

Fast Approximation Algorithms for Knapsack Problems

Fully polynomial approximation schemes for knapsack problems are presented. These algorithms are based on ideas of Ibarra and Kim, with modifications which yield better time and space bounds, and also tend to improve the practicality of the procedures. Among the principal improvements are the introduction of a more efficient method of scaling and the use of a median-finding routine to eliminate sorting. The 0-1 knapsack problem, for n items and accuracy ϵ > 0, is solved in (n log(1/ϵ) + 1/ϵ4) time and O(n + 1/ϵ3) space. The time bound is reduced to O(n + 1/ϵ3) for the “unbounded” knapsack problem. For the “subset-sum” problem, O(n + 1/ϵ3) time and O(n + 1/ϵ2) space, or O(n + (1/ϵ2)log(1/ϵ)) time and space, are achieved. The “multiple choice” problem, with m equivalence classes, is solved in O(n log n + mn/ϵ) time and O(n + m2/ϵ) space.

Reduction Algorithm for Zero-One Single Knapsack Problems

A simple algorithm is described for the reduction of 0-1 single knapsack problems to significantly smaller problems. The time required by the reduction algorithm is proportional to the number of variables. When used in conjunction with available algorithms for knapsack problems it substantially reduces total time and space requirements.