DOCSLIB.ORG

Lecture 12: Knapsack Problems

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Lecture 12: Knapsack Problems Lecture 12: Knapsack Problems Prof. Krishna R. Pattipati Dept. of Electrical and Computer Engineering University of Connecticut Contact: [email protected]; (860) 486-2890 © K. R. Pattipati, 2001-2016 Outline • Why solve this problem? • Various versions of Knapsack problem • Approximation algorithms • Optimal algorithms . Dynamic programming . Branch-and-bound VUGRAPH 2 0–1 Knapsack problem • A hitch-hiker has to fill up his knapsack of size V by selecting from among various possible objects those which will give him maximum comfort • Suppose want to invest (all or in part) a capital of V dollars among n possible investments with different expected profits and with different investment requirements to maximize total expected profit • Other applications: cargo loading, cutting stock • Mathematical formulation of 0–1 Knapsack problem n max pxii i1 n s.t. wii x V i1 xi {0,1} • A knapsack is to be filled with different objects of profit pi and of weights wi without exceeding the total weight V • pi & wi are integers (if not, scale them) • wi ≤ 푉, ∀푖 푛 • σ푖=1 푤푖 > 푉 VUGRAPH 3 Other related formulations • Bounded Knapsack problem . Suppose there are bi items of type i ⇒ Change 푥푖 ∈ {0, 1} to 0 ≤ 푥푖 ≤ 푏푖 and xi integer . Unbounded Knapsack problem ⇒ 푏푖 = ∞, 0 ≤ 푥푖 ≤ ∞, xi integer . Subset-sum problem o Find a subset of weights whose sum is closest to, without exceeding capacity n max wxii i1 n s.t. wii x V i1 xi {0,1} o Knapsack problem with wi = pi o Subset-sum is NP-hard ⇒ knapsack is NP-hard . Change-making problem n max xi i1 n s.t. wii x V i1 0xi b i , x i an integer, i 1, , n o bi finite ⇒ bounded change-making problem o bi = ∞ ⇒ unbounded change-making problem VUGRAPH 4 Other related formulation • 1-dimensional knapsack with a cost constraint • Multi-dimensional knapsack (m knapsacks) n nm max px max pxii i ij i1 ij11 n n s.t. wii x V s.t. wi x ij V; j 1, , m i1 i1 n m cii x C xij 1; i 1, , n i1 j1 x {0,1} i xij {0,1}; i 1, , n ; j 1, , m • Multi-dimensional knapsack in which profit and weight of each item depends on the knapsack selected for the item nm max pxij ij ij11 n s.t. wij x ij V j ; j 1, , m i1 m xij 1; i 1, , n j1 xij {0,1}; i 1, , n ; j 1, , m VUGRAPH 5 Other related formulation • Loading problem or variable-sized bin-packing problem . Given n objects with known volumes wi & m boxes with limited capacity cj, j=1,…,m, minimize the number of boxes used . yi = 1 if box j is used . xij = 1 if object i is put in box j n min y j j1 m s.t. xij 1; i 1, , n i1 n wi x ij c j y j ; j 1, , m i1 yxj, ij {0,1} . cj = c ⇒ bin-packing problem • See S. Martello and P. Toth, Knapsack Problems: Algorithms and Computer Implementation, John Wiley, 1990 for an in-depth survey of these problems • Here we consider only 0–1 Knapsack problem VUGRAPH 6 Relaxed LP version of Knapsack problem • Let us consider relaxed LP version of Knapsack problem . Gives us an upper and lower bound on the Knapsack problem . Assume that objects are ordered as p p p 12 n w12 w wn . LP relaxation to find an upper bound maxpi x i relax 0 1 max p i x i ii s.t. wi x i V s.t. w i x i V ii xxii{0,1} constraints 0 1 * f fLP . Dual of relaxed LP n minV max(0, pii w ) 0 i1 n n min V min V rr1 i i * pr1 i1 i1 ;:r wii V w wr1 ii11 s.t. wp s.t. ipw i i i i i p 0 * r1 , i 0 i imax(0,pw i i ) wr1 VUGRAPH 7 Relaxed LP version of Knapsack problem • Complementary slackness condition . 푥푖 = 1 ⇒휇푖 > 0 and 푤푖휆 + 휇푖 = 푝푖 . 푥푖 < 1 ⇒ 휇푖 = 0 • Optimal solution is as follows rr1 if wii V w then ii11 xi1, i 1, , r i = ( p i w i ) xii0, i r 2, , n = 0 r Vw i i1 xrr11 ; = 0 wr1 one upper bound is: rr ** pr1 f fLP p i V w i ii11wr1 p optimal r1 wr1 wi i p i p r1 ; i 1, , r wr1 ∗ • Clearly, 푓퐿푃 = optimal dual objective function value VUGRAPH 8 LP relaxation upper bound ∗ ∗ • LP relaxation solution provides the upper bound 푈1 = int 푓퐿푃 ≤ 2푓 . Both [p1, p2,…, pr] and pr+1 are feasible Knapsack solutions . Feasible solution ≤ 푓∗ ∗ . 푈1 ≤ sum of two feasible solution ≤ 2푓 • We can obtain an even tighter bound than LP relaxation (Martello and Toth) . Consider the possibility that xr+1 = 1 or xr+1 = 0 xxrr120 could be a fraction r Vw r i ˆ i1 U pir p 2 i1 wr2 xxrr1 1 could be a fraction r1 V w w r1 ir1 i1 U pi p r1 p r i1 wr r w V w r rr1 i1 pi p r1 p r i1 wr VUGRAPH 11 LP relaxation upper bound • Clearly, ˆ * U2 max U , U f • Why is this a better upper bound than LP relaxation? ෡ . Clearly, 푈 ≤ 푈1 . Can show that r1 pprr1 U1 U wi V 0 wwrr1 i1 VUGRAPH 12 Knapsack Example 푉 − σ푟 푤 . n = 8 푖=1 푖 푈෡ = 푝푟+2 . p = [15, 100, 90, 60, 40, 15, 10, 1] 푤푟+2 . w = [2, 20, 20, 30, 40, 30, 60, 10] 푟−1 푉 − σ푖=1 푤푖 − 푤푟+1 . V = 102 푈෩ = 푝 푤 푟 . Optimal solution: x = [1, 1, 1, 1, 0, 1, 0, 0] 푟 . Optimal value: f* = 280 (30)(40) . LP relaxation: (r + 1) = 5 ⇒ U = 265 + = 295 1 40 (30)(15) . Bound 푈෡ = 265 + = 280 30 (20)(60) . Bound 푈෩ = 245+ = 285 30 . Maximum of latter two bounds = 285 • These bounds can be further improved by solving two continuous relaxed LPs with the constraints that xr+1 = 1 or xr+1 = 0, respectively • Algorithm for solving Knapsack problem . Approximation algorithms . Dynamic programming . Branch-and-bound • Although the problem is NP-hard, can solve problems of size n = 100,000 in a reasonable time • Approximate algorithms…lower bounds on the optimal solution . Can obtain from a greedy heuristic VUGRAPH 13 Greedy heuristic • 0th order greedy heuristic 푝 . Load objects on the basis of 푖 푤푖 * L(0) pi f pp1 i: ii wwii1 &wVi • Kth order greedy heuristic . We can obtain a series of lower bounds by assuming that a certain set of objects J are in the knapsack where wVi iJ . And assigning the rest on the basis of greedy method . This is basically rollout concept of dynamic programming VUGRAPH 14 kth order Greedy heuristic . The bound can be computed as follows: o 푧 = 푉 − σ푖∈퐽 푤푖 o y=σ푖∈퐽 푝푖 o For 푖 = 1, … , 푛 do If (푖 ∉ 퐽 & 푤푖 ≤ 푧) then 퐽 = 퐽 ∪ 푖 푧 = 푧 − 푤푖 푦 = 푦 + 푝푖 End if o End do o 퐿(퐽) = 푦 ≤ 푓∗ VUGRAPH 15 k-approximation algorithm • Idea: what if I consider all possible combination of objects of size |J| = k & find the best lower bound & use it as a solution of the Knapsack problem . If |J| = n, optimal o We can control the complexity of the algorithm by varying k k-approximation algorithm…Knapsack(k) o f (k) ← 0 Enumerate all subset 퐽 ⊂ {1, … , 푛} such that |JV | and do iJ f( k ) max f ( k ), L ( J ) . Note: in practice, k = 2 would suffice to produce a solution within 2-5% of optimal • Example max 100x1 50 x 2 20 x 3 10 x 4 7 x 5 3 x 6 s.t. 100x1 50 x 2 20 x 3 10 x 4 7 x 5 3 x 6 165 p i 1, i wi L(0) 163 0th order heuristic k1: L ({1}) 163, L ({2}) 163, L ({3}) 140, L ({4}) 163, L ({5}) 160, L ({6}) 163 best 1st order heuristic solution = 163... in fact, this is optimal! VUGRAPH 16 k-approximation algorithm • Can we say anything about the performance of the approximation algorithm? Yes! . The recursive approximation algorithm Knapsack(k) provides a solution 푓(푘) ∋ f* f( k ) 1 fk* 1 . Before we provide a proof, let us consider its implications o If want a solution within 휖 of optimal 11 k 1 k 1 o Time complexity Number of time greedy (0) is executed kkk1 1 n ikn 1 n O()() n O n ii00i n 1 Each greedy takes O(n) operations VUGRAPH 17 Proof of the bound: setting the stage • Let R* be the set of objects included in the knapsack in an optimal solution * pii f& w V i R** i R • If | R*|≤ 푘, our approximation algorithm would have found it…so, assume otherwise Rk* ∗ * • Suppose (푝Ƹ푖, 푤ෝ푖), 1 ≤ 푖 ≤ |푅 | be the set of objects in R • Assume that we order these objects as follows: . First 푘: 푝Ƹ1 > 푝Ƹ2 > ⋯ > 푝Ƹ푘 are the largest profits 푝ො 푝ො . The rest: 푖 > 푖+1 , 푘 < 푖 < |푅∗| 푤ෝ푖 푤ෝ푖+1 pˆ p ˆ p ˆ f * • 12 ||R* k **ˆ ˆ ˆ • f pi p k1 ( k 1) p k t ; t k 1,...,| R | i1 f * pˆ kt k 1 VUGRAPH 18 Proof of the k-approximation bound - 1 • Let us look at what k-approximation algorithm does … it must have looked at the set J of largest prices in R* at least once … let k ˆ fJ p i p i i J i 1 • Let us consider what happens when k-approximation algorithm executed this iteration .
Load more

Recommended publications
  • 15.083 Lecture 21: Approximation Algorithsm I
    15.083J Integer Programming and Combinatorial Optimization Fall 2009 Approximation Algorithms I The knapsack problem • Input: nonnegative numbers p1; : : : ; pn; a1; : : : ; an; b. n X max pj xj j=1 n X s.t. aj xj ≤ b j=1 n x 2 Z+ Additive performance guarantees Theorem 1. There is a polynomial-time algorithm A for the knapsack problem such that A(I) ≥ OP T (I) − K for all instances I (1) for some constant K if and only if P = NP. Proof: • Let A be a polynomial-time algorithm satisfying (1). • Let I = (p1; : : : ; pn; a1; : : : ; an; b) be an instance of the knapsack problem. 0 0 0 • Let I = (p1 := (K + 1)p1; : : : ; pn := (K + 1)pn; a1; : : : ; an; b) be a new instance. • Clearly, x∗ is optimal for I iff it is optimal for I0. • If we apply A to I0 we obtain a solution x0 such that p0x∗ − p0x0 ≤ K: • Hence, 1 K px∗ − px0 = (p0x∗ − p0x0) ≤ < 1: K + 1 K + 1 • Since px0 and px∗ are integer, it follows that px0 = px∗, that is x0 is optimal for I. • The other direction is trivial. • Note that this technique applies to any combinatorial optimization problem with linear ob­ jective function. 1 Approximation algorithms • There are few (known) NP-hard problems for which we can find in polynomial time solutions whose value is close to that of an optimal solution in an absolute sense. (Example: edge coloring.) • In general, an approximation algorithm for an optimization Π produces, in polynomial time, a feasible solution whose objective function value is within a guaranteed factor of that of an optimal solution.
    [Show full text]
  • Quadratic Multiple Knapsack Problem with Setups and a Solution Approach
    Proceedings of the 2012 International Conference on Industrial Engineering and Operations Management Istanbul, Turkey, July 3 – 6, 2012 Quadratic Multiple Knapsack Problem with Setups and a Solution Approach Nilay Dogan, Kerem Bilgiçer and Tugba Saraç Industrial Engineering Department Eskisehir Osmangazi University Meselik 26480, Eskisehir Turkey Abstract In this study, the quadratic multiple knapsack problem that include setup costs is considered. In this problem, if any item is assigned to a knapsack, a setup cost is incurred for the class which it belongs. The objective is to assign each item to at most one of the knapsacks such that none of the capacity constraints are violated and the total profit is maximized. QMKP with setups is NP-hard. Therefore, a GA based solution algorithm is proposed to solve it. The performance of the developed algorithm compared with the instances taken from the literature. Keywords Quadratic Multiple Knapsack Problem with setups, Genetic algorithm, Combinatorial Optimization. 1. Introduction The knapsack problem (KP) is one of the well-known combinatorial optimization problems. There are different types of knapsack problems in the literature. A comprehensive survey which can be considered as a through introduction to knapsack problems and their variants was published by Kellerer et al. (2004). The classical KP seeks to select, from a finite set of items, the subset, which maximizes a linear function of the items chosen, subject to a single inequality constraint. In many real life applications it is important that the profit of a packing also should reflect how well the given items fit together. One formulation of such interdependence is the quadratic knapsack problem.
    [Show full text]
  • Approximate Algorithms for the Knapsack Problem on Parallel Computers
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by Elsevier - Publisher Connector INFORMATION AND COMPUTATION 91, 155-171 (1991) Approximate Algorithms for the Knapsack Problem on Parallel Computers P. S. GOPALAKRISHNAN IBM T. J. Watson Research Center, P. 0. Box 218, Yorktown Heights, New York 10598 I. V. RAMAKRISHNAN* Department of Computer Science, State University of New York, Stony Brook, New York 11794 AND L. N. KANAL Department of Computer Science, University of Maryland, College Park, Maryland 20742 Computingan optimal solution to the knapsack problem is known to be NP-hard. Consequently, fast parallel algorithms for finding such a solution without using an exponential number of processors appear unlikely. An attractive alter- native is to compute an approximate solution to this problem rapidly using a polynomial number of processors. In this paper, we present an efficient parallel algorithm for hnding approximate solutions to the O-l knapsack problem. Our algorithm takes an E, 0 < E < 1, as a parameter and computes a solution such that the ratio of its deviation from the optimal solution is at most a fraction E of the optimal solution. For a problem instance having n items, this computation uses O(n51*/&3’2) processors and requires O(log3 n + log* n log( l/s)) time. The upper bound on the processor requirement of our algorithm is established by reducing it to a problem on weighted bipartite graphs. This processor complexity is a signiti- cant improvement over that of other known parallel algorithms for this problem. 0 1991 Academic Press, Inc 1.
    [Show full text]
  • Bin Completion Algorithms for Multicontainer Packing, Knapsack, and Covering Problems
    Journal of Artificial Intelligence Research 28 (2007) 393-429 Submitted 6/06; published 3/07 Bin Completion Algorithms for Multicontainer Packing, Knapsack, and Covering Problems Alex S. Fukunaga [email protected] Jet Propulsion Laboratory California Institute of Technology 4800 Oak Grove Drive Pasadena, CA 91108 USA Richard E. Korf [email protected] Computer Science Department University of California, Los Angeles Los Angeles, CA 90095 Abstract Many combinatorial optimization problems such as the bin packing and multiple knap- sack problems involve assigning a set of discrete objects to multiple containers. These prob- lems can be used to model task and resource allocation problems in multi-agent systems and distributed systms, and can also be found as subproblems of scheduling problems. We propose bin completion, a branch-and-bound strategy for one-dimensional, multicontainer packing problems. Bin completion combines a bin-oriented search space with a powerful dominance criterion that enables us to prune much of the space. The performance of the basic bin completion framework can be enhanced by using a number of extensions, in- cluding nogood-based pruning techniques that allow further exploitation of the dominance criterion. Bin completion is applied to four problems: multiple knapsack, bin covering, min-cost covering, and bin packing. We show that our bin completion algorithms yield new, state-of-the-art results for the multiple knapsack, bin covering, and min-cost cov- ering problems, outperforming previous algorithms by several orders of magnitude with respect to runtime on some classes of hard, random problem instances. For the bin pack- ing problem, we demonstrate significant improvements compared to most previous results, but show that bin completion is not competitive with current state-of-the-art cutting-stock based approaches.
    [Show full text]
  • Solving Packing Problems with Few Small Items Using Rainbow Matchings
    Solving Packing Problems with Few Small Items Using Rainbow Matchings Max Bannach Institute for Theoretical Computer Science, Universität zu Lübeck, Lübeck, Germany [email protected] Sebastian Berndt Institute for IT Security, Universität zu Lübeck, Lübeck, Germany [email protected] Marten Maack Department of Computer Science, Universität Kiel, Kiel, Germany [email protected] Matthias Mnich Institut für Algorithmen und Komplexität, TU Hamburg, Hamburg, Germany [email protected] Alexandra Lassota Department of Computer Science, Universität Kiel, Kiel, Germany [email protected] Malin Rau Univ. Grenoble Alpes, CNRS, Inria, Grenoble INP, LIG, 38000 Grenoble, France [email protected] Malte Skambath Department of Computer Science, Universität Kiel, Kiel, Germany [email protected] Abstract An important area of combinatorial optimization is the study of packing and covering problems, such as Bin Packing, Multiple Knapsack, and Bin Covering. Those problems have been studied extensively from the viewpoint of approximation algorithms, but their parameterized complexity has only been investigated barely. For problem instances containing no “small” items, classical matching algorithms yield optimal solutions in polynomial time. In this paper we approach them by their distance from triviality, measuring the problem complexity by the number k of small items. Our main results are fixed-parameter algorithms for vector versions of Bin Packing, Multiple Knapsack, and Bin Covering parameterized by k. The algorithms are randomized with one-sided error and run in time 4k · k! · nO(1). To achieve this, we introduce a colored matching problem to which we reduce all these packing problems. The colored matching problem is natural in itself and we expect it to be useful for other applications.
    [Show full text]
  • CS-258 Solving Hard Problems in Combinatorial Optimization Pascal
    CS-258 Solving Hard Problems in Combinatorial Optimization Pascal Van Hentenryck Course Overview Study of combinatorial optimization from a practitioner standpoint • the main techniques and tools • several representative problems What is expected from you: • 7 team assignments (2 persons team) • Short write-up on the assignments • Final presentation of the results What you should not do in this class? • read papers/books/web/... on combinatorial optimization • Read the next slide during class Course Overview January 31: Knapsack * Assignment: Coloring February 7: LS + CP + LP + IP February 14: Linear Programming * Assignment: Supply Chain February 28: Integer Programming * Assignment: Green Zone March 7: Travelling Salesman Problem * Assignment: TSP March 14: Advanced Mathematical Programming March 21: Constraint Programming * Assignment: Nuclear Reaction April 4: Constraint-Based Scheduling April 11: Approximation Algorithms (Claire) * Assignment: Operation Hurricane April 19: Vehicle Routing April 25: Advanced Constraint Programming * Assignment: Special Ops. Knapsack Problem n c x max ∑ i i i = 1 subject to: n ∑ wi xi ≤ l i = 1 xi ∈ [0, 1] NP-Complete Problems Decision problems Polynomial-time verifiability • We can verify if a guess is a solution in polynomial time Hardest problem in NP (NP-complete) • If I solve one NP-complete problem, I solve them all Approaches Exponential Algorithms (sacrificing time) • dynamic programming • branch and bound • branch and cut • constraint programming Approximation Algorithms (sacrificing quality)
    [Show full text]
  • 1 Load Balancing / Multiprocessor Scheduling
    CS 598CSC: Approximation Algorithms Lecture date: February 4, 2009 Instructor: Chandra Chekuri Scribe: Rachit Agarwal Fixed minor errors in Spring 2018. In the last lecture, we studied the KNAPSACK problem. The KNAPSACK problem is an NP- hard problem but does admit a pseudo-polynomial time algorithm and can be solved efficiently if the input size is small. We used this pseudo-polynomial time algorithm to obtain an FPTAS for KNAPSACK. In this lecture, we study another class of problems, known as strongly NP-hard problems. Definition 1 (Strongly NP-hard Problems) An NPO problem π is said to be strongly NP-hard if it is NP-hard even if the inputs are polynomially bounded in combinatorial size of the problem 1. Many NP-hard problems are in fact strongly NP-hard. If a problem Π is strongly NP-hard, then Π does not admit a pseudo-polynomial time algorithm. For more discussion on this, refer to [1, Section 8.3] We study two such problems in this lecture, MULTIPROCESSOR SCHEDULING and BIN PACKING. 1 Load Balancing / MultiProcessor Scheduling A central problem in scheduling theory is to design a schedule such that the finishing time of the last jobs (also called makespan) is minimized. This problem is often referred to as the LOAD BAL- ANCING, the MINIMUM MAKESPAN SCHEDULING or MULTIPROCESSOR SCHEDULING problem. 1.1 Problem Description In the MULTIPROCESSOR SCHEDULING problem, we are given m identical machines M1;:::;Mm and n jobs J1;J2;:::;Jn. Job Ji has a processing time pi ≥ 0 and the goal is to assign jobs to the machines so as to minimize the maximum load2.
    [Show full text]
  • The Multiobjective Multidimensional Knapsack Problem: a Survey and a New Approach
    The multiobjective multidimensional knapsack problem: a survey and a new approach T. Lust1, J. Teghem Universit´eof Mons - Facult´ePolytechnique de Mons Laboratory of Mathematics and Operational Research 20, place du parc 7000 Mons (Belgium) Abstract: The knapsack problem (KP) and its multidimensional version (MKP) are basic problems in combinatorial optimization. In this paper we consider their multiobjective extension (MOKP and MOMKP), for which the aim is to obtain or to approximate the set of efficient solutions. In a first step, we classify and describe briefly the existing works, that are essentially based on the use of metaheuristics. In a second step, we propose the adaptation of the two- phase Pareto local search (2PPLS) to the resolution of the MOMKP. With this aim, we use a very-large scale neighborhood (VLSN) in the second phase of the method, that is the Pareto local search. We compare our results to state-of-the-art results and we show that we obtain results never reached before by heuristics, for the biobjective instances. Finally we consider the extension to three-objective instances. Keywords: Multiple objective programming ; Combinatorial optimization ; Knapsack Problems ; Metaheuristics. 1 Introduction Since the 70ies, multiobjective optimization problems (MOP) became an important field of op- erations research. In many real applications, there exists effectively more than one objective to be taken into account to evaluate the quality of the feasible solutions. A MOP is defined as follows: “max” z(x)= zk(x) k = 1,...,p (MOP) n s.t x ∈ X ⊂ R+ n th where n is the number of variables, zk(x) : R+ → R represents the k objective function and X is the set of feasible solutions.
    [Show full text]
  • Greedy Approximation Algorithms Notes
    Introduction to Algorithms Introduction to Approximation and Online Algorithms CS 4820 Spring 2016 by Eva´ Tardos In some situation finding approximately optimal solution to a maximization or minimization problem is good enough in the application. This may be useful if we either lack all the information as we have to make decisions (online algorithms) or we don't have the time to find a fully optimal solution (say as the problem is too hard). In the remaining part of the course, we will explore algorithms for such situations. 1 Knapsack First we consider the Knapsack problem. This problem is given by n items each with a weight wi and value vi, and a maximum allowed weight W . The problem is to selected a subset I of items of maximum P P total value i2I vi whose total weight i2I wi ≤ W is at most the weight given. First notice that the Subset Sum problem is a special case of this problem, when vi = wi for all i, and we ask the question if these is a subset with total value (and hence weight) at least W . This shows that Knapsack is NP-hard, at least as hard as an NP-complete problem (not NP-complete, as its an optimization problem, and hence not in NP). Here we give a simple 2-approximation algorithm for the problem. See also Section 11.8 of the book that we'll cover later that gives a much better approximation algorithm. Our simple approximation algorithm will be a form of greedy algorithm. We will consider two greedy ideas.
    [Show full text]
  • Capacitated Dynamic Programming: Faster Knapsack and Graph
    Capacitated Dynamic Programming: Faster Knapsack and Graph Algorithms Kyriakos Axiotis Christos Tzamos MIT University of Wisconsin-Madison [email protected] [email protected] Abstract One of the most fundamental problems in Computer Science is the Knapsack problem. Given a set of n items with different weights and values, it asks to pick the most valuable subset whose total weight is below a capacity threshold T . Despite its wide applicability in various areas in Computer Science, Operations Research, and Finance, the best known running time for the problem is O(Tn). The main result of our work is an improved algorithm running in time O(TD), where D is the number of distinct weights. Previously, faster runtimes for Knapsack were only possible when both weights and values are bounded by M and V respectively, running in time O(nMV ) [16]. In comparison, our algorithm implies a bound of O(nM 2) without any dependence on V , or O(nV 2) without any dependence on M. Additionally, for the unbounded Knapsack problem, we provide an algorithm running in time O(M 2) or O(V 2). Both our algorithms match recent conditional lower bounds shown for the Knapsack problem [9, 14]. We also initiate a systematic study of general capacitated dynamic programming, of which Knapsack is a core problem. This problem asks to compute the maximum weight path of length k in an edge- or node-weighted directed acyclic graph. In a graph with m edges, these problems are solvable by dynamic programming in time O(km), and we explore under which conditions the dependence on k can be eliminated.
    [Show full text]
  • Different Approaches to Solve the 0/1 Knapsack Problem
    Different Approaches to Solve the 0/1 Knapsack Problem Maya Hristakeva Computer Science Department Simpson College Indianola, IA 50125 [email protected] Dipti Shrestha Computer Science Department Simpson College Indianola, IA 50125 [email protected] Abstract The purpose of this paper is to analyze several algorithm design paradigms applied to a single problem – the 0/1 Knapsack Problem. The Knapsack problem is a combinatorial optimization problem where one has to maximize the benefit of objects in a knapsack without exceeding its capacity. It is an NP-complete problem and as such an exact solution for a large input is practically impossible to obtain. The main goal of the paper is to present a comparative study of the brute force, dynamic programming, memory functions, branch and bound, greedy, and genetic algorithms. The paper discusses the complexity of each algorithm in terms of time and memory requirements, and in terms of required programming efforts. Our experimental results show that the most promising approaches are dynamic programming and genetic algorithms. The paper examines in more details the specifics and the limitations of these two paradigms. Introduction In this project we are going to use Brute Force, Dynamic Programming, Memory Functions, Branch and Bound, and Greedy Algorithms to solve the Knapsack Problem where one has to maximize the benefit of items in a knapsack without extending its capacity. The main goal of this project is to compare the results of these algorithms and find the best one. The Knapsack Problem (KP) The Knapsack Problem is an example of a combinatorial optimization problem, which seeks for a best solution from among many other solutions.
    [Show full text]
  • A Dynamic Programming Heuristic for the Quadratic Knapsack Problem
    This article was downloaded by: [148.88.244.227] On: 11 February 2014, At: 06:59 Publisher: Institute for Operations Research and the Management Sciences (INFORMS) INFORMS is located in Maryland, USA INFORMS Journal on Computing Publication details, including instructions for authors and subscription information: http://pubsonline.informs.org A Dynamic Programming Heuristic for the Quadratic Knapsack Problem Franklin Djeumou Fomeni, Adam N. Letchford To cite this article: Franklin Djeumou Fomeni, Adam N. Letchford (2014) A Dynamic Programming Heuristic for the Quadratic Knapsack Problem. INFORMS Journal on Computing 26(1):173-182. http://dx.doi.org/10.1287/ijoc.2013.0555 Full terms and conditions of use: http://pubsonline.informs.org/page/terms-and-conditions This article may be used only for the purposes of research, teaching, and/or private study. Commercial use or systematic downloading (by robots or other automatic processes) is prohibited without explicit Publisher approval. For more information, contact [email protected]. The Publisher does not warrant or guarantee the article’s accuracy, completeness, merchantability, fitness for a particular purpose, or non-infringement. Descriptions of, or references to, products or publications, or inclusion of an advertisement in this article, neither constitutes nor implies a guarantee, endorsement, or support of claims made of that product, publication, or service. Copyright © 2014, INFORMS Please scroll down for article—it is on subsequent pages INFORMS is the largest professional society in the world for professionals in the fields of operations research, management science, and analytics. For more information on INFORMS, its publications, membership, or meetings visit http://www.informs.org INFORMS Journal on Computing Vol.
    [Show full text]