Note: On the set-union knapsack problem

Note: On the Set-Union Knapsack Problem

Olivier Goldschmidt and David Nehme Department of Mechanical Engineering, The University of Texas at Austin

Gang Yu Department of Management Science and Information Systems,

The University of Texas at Austin

We consider a generalization of the 0- 1 knapsack problem called the set-union knapsack problem (SKP). In the SKP, each item is a set of elements, each item has a nonnegative value, and each element has a nonnegative weight. The total weight of a collection of items is given by the total weight of the elements in the union of the items’ sets. This problem has applications to data-base partitioning and to machine loading in flexible manufacturing systems. We show that the SKP remains NP-hard, even in very restricted cases. We present an exact, dynamic programming algorithm for the SKP and show sufficient conditions for it to run in polynomial time. 0 1994 John Wiley & Sons, Inc.

1. INTRODUCTION

Given a group of items, each associated with a nonnegative weight and a nonnegative value, the 0- 1 knapsack problem is to select the set of items with largest total value, subject to the constraint that the total weight of the selected items does not exceed a fixed capacity. This, and other related problems, are discussed by Martello and Toth in [ 1 1 1. This article concerns a variation of the 0- 1 knapsack problem, which we call the set-union knapsack problem, in which each item is a set of elements. Each element has a nonnegative weight. The total weight of a set of items is defined as the sum of the weights of the elements in the union of the sets of the items.

The set-union knapsack problem ( SKP) has several industrial applications. Two exam- ples are given below. Consider the following flexible manufacturing system: A single machine is designed to process multiple products. We wish to reduce the total set-up time required to process all the products. For the machine to process a product, a given set of tools must be present in the machine’s tool magazine. To switch production from one product to another there are two main steps.

I . Place all the tools required for the product onto the tool magazine. 2. Reprogram the machine to operate the tools correctly.

Step 1 involves the physical loading and unloading of the tools, but step 2 only involves loading a new computer program. Thus, in general, step 1 requires much more time than step 2. Some tools are common to several products. The machine’s tool magazine has limited capacity, and the space each tool occupies on the tool magazine is proportional to its size. We then face the problem of grouping products so that for each group, the union

Naval Research Logistics, Vol. 4 1, p. 833-842 ( 1994) Copyright 0 1994 by John Wiley & Sons, Inc. CCC 0894-069)3/94/060833- 10

834 Naval Research Logistics, Vol. 41 ( 1994)

of the sets of tools required by each product in that group will fit into the tool magazine. If all the products are placed into these groups, then there is a production schedule, with each product run once, where step 1 is performed only once per group. Step 1 must be performed only when production changes from a product in one group to a product in another group. The application of the set-union knapsack problem, suggested by Hirabayashi, Suzuki, and Tsuchiya [ 81 to the above situation, is when a single long run without a tool change is required, say for an overnight period when the machine will be unattended.

Another application is the allocation of storage to fields in a data base [ 12 1. In this application, there is a main memory and a secondary memory. The entire data base can not be stored in main memory. There is a set of queries that will be performed on the data base. Each query requires access to a given subset of the fields. A query will be fast if all the fields it requires reside in the main memory. The problem is to assign each field to either main or secondary memory to maximize the number of fast queries. In the SKP model of this problem, each element corresponds to a field and each item corresponds to a query (represented by the set of fields required for the query). The size of each element equals the amount of memory required for the corresponding field. The value of each item equals the relative frequency of the corresponding query.

The set-union bin-packing problem (SBP) is analogous to the SKP. In this problem, the goal is to place all the items into as few knapsacks (bins) as possible. The concept of SBP as a generalization of the bin-packing problem was introduced by Tang and Denardo [ 1 5 3 .

Several authors have published empirical results on the SBP and SKP. Tang and De- nardo [ 15 3 developed a branch-and-bound procedure for solving the SBP. They gave only empirical results on the quality of the bounds used and the speed of the algorithm.

A number of authors have proposed heuristics for generating feasible solutions, based on sequentially filling bins with items, opening a new bin only when a current bin cannot fit any additional item. Tang and Denardo [ 151, Whitney and Gaul [ 161, Yu, Nayak, and Nehme [ 181, and Rajagopalan [ 131 have proposed different rules for selecting the next item to add to the bin. In all these articles no guarantees on the quality of the objective value of heuristic with respect to optimal solution are given. Tang and Denardo [ 15 ] have also provided lower bounds on the optimal objective value.

Hwang [ 91 has devised a greedy algorithm for SBP. At each iteration, an SKP is solved optimally for the remaining items. The items selected in the knapsack are then removed. The SKP subproblems are solved using a branch-and-bound method. Hirabayashi, Suzuki, and Tsuchiya [ 81 propose a set-covering formulation for SBP. Their formulation has an exponential number of decision variables (=number of covering sets). To overcome this, they use a column generation approach, which has the SKP as its column generation sub- problem. They also give an exact, LP-based, branch-and-bound algorithm for SKP. Crama and Oerlemans [ 41 have used this column generation approach, together with the above heuristics, to develop an exact algorithm for SBP. They used approximate solutions to the dual of the set-covering formulation to generate lower bounds on the objective value that, empirically, were stronger than those of Tang and Denardo. Their computational results show they were able to optimally solve most randomly generated instances of up to 60 items, up to 60 distinct elements, with a bin capacity of up to 30. Crama and Oerlemans have also noted that SKP is NP-hard even in the case where all items have unit weight and all elements have unit value. Crama and Mazzola [ 31 have found some of the facets of the SKP polytope.

To our knowledge, the only polynomial-time algorithms for the SBP with guaranteed

Goldschmidt et al.: Note on the Set-Union Knapsack Problem 835

bounds are due to Goldschmidt, Hochbaum, and Yu in [ 61. In this article the authors present a constant approximation algorithm for the case where all items have two elements, all items have unit value, all elements have unit weight, and the bin capacity is bounded by a constant.

In Section 2, we give a formulation of the set-union knapsack problem. In Section 3, we prove that the set-union knapsack problem is strongly NP-hard even if all elements have equal weight, all items have equal value, each item contains exactly two elements, and the set of elements can be partitioned into two subsets such that every item contains exactly one element of each set.

In Section 4, we describe a dynamic programming exact method for solving the set- union knapsack problem which is bounded by an exponential function with respect to the cut width of the item-adjacency graph. The item-adjacency graph has a vertex for each element and two vertices connected by an edge if and only if an item contains both of the corresponding elements. In Section 6 we will summarize our results and suggest future research directions.

2. PROBLEM FORMULATION AND NOTATION

Formally, the set-union knapsack problem is defined as follows: There are n elements and m items, and the set of elements of item i is denoted by Pi. Uz I P; = { 1, . . . , n } . The value of item i is denoted by zt; and the weight of element j is denoted by sj. The capacity of the knapsack is b. For K c { 1, . . . , m } , define PK = U i E ~ Pi.

The SKP is defined by the following mathematical program:

We define the item-edge hypergraph, H = ( V, E ) , with

V = { 1 , . . . , n } ,

Thus, we may refer to placing nodes and edges into a knapsack instead of elements and items.

For the case where 1 P, 1 = 2, i E { I , . . . , m } , the item-edge hypergraph is a graph that will be called the item-edge graph.

The item-adjacencygraph, G, = (V, E,) is defined as follows:

V = { l , . . . , n } , ( 1 )

E,= { { j I , h } I j l , j2E { I , . . . , n } and3iE { 1,. . . , m } such that { j l , j 2 } c P;}. ( 2 )

836 Naval Research Logistics, Vol. 4 1 ( 1994)

Figure 1. An item-adjacency graph.

Note that for the case 1 Pi I = 2 the item-adjacency graph, the item-edge hypergraph, and the item-edge graph all represent the same graph.

EXAMPLE: Figure 1 shows the item-adjacency graph for the following instance of SKP: PI = { 1,2,3}; P2 = { 3,4}; P3 = { 4 ,5} ; P4 = { 5,6}; Ps = { 6, 1); P7 = { 6 ,7} ; Ps =

{ 5 , 7 } ; P 9 = { 5 , 8 } .

If b 2 C:=, s,, the instance of the SKP is trivial; thus we will assume b < ZJn=, s,. In the case of unit element size b = O( n) and if s, is polynomial in n then h is polynomial in n . Note that any graph, together with an integer b , will define an instance to the SKP with unit item values and unit element weights. Thus, the SKP restricted to I P, I = 2 can be interpreted as finding a densest subgraph induced by b nodes.

Note that the special case of SKP where P, f l P, I = 0 for i, i' = 1,2, . . . , rn , i Z it, is the traditional 0- 1 knapsack problem.

3. COMPLEXITY OF THE SET-UNION KNAPSACK PROBLEM

In the recognition version of the SKP, an additional parameter k is given and the question is to decide if the objective value of the optimal solution is at least k .

THEOREM 1. The recognition SKP restricted to the case where 1 P, 1 = 2, s, = 1, and vi = 1 for i = 1, . . . , rn; j = 1, . . . , n , and the item-edge graph is bipartite with all the nodes on one side of the partition having degree 2 is NP-complete.

PROOF: The proof is by reduction from maximum clique problem [5]. k is restricted to be at least 4. This will not invalidate the proof, because determining if there is a clique of size k for k bounded by any fixed constant can be found in polynomial time by explicit enumeration.

For any graph G = (V, E ) and integer k , define bipartite graph B = (V ' U V " , E') as follows:


(u : , ul) E E‘ - ej E E and ei is incident to uj in G.

In other words, each node in V” corresponds to a node of graph G, and each node in V’ corresponds to an edge in graph G. Note that the nodes in V’ all have degree 2. We now show that there is a k clique in G if and only if the SKP with item-edge graph B and bin capacity b = (5) + k has a feasible solution with 2 (i) items.

only i$ Suppose there is a clique of size k in G. The knapsack containing the k nodes from Vr that correspond to the nodes of the k clique and the ($) nodes from V r that correspond to the edges in the k clique will contain 2 ( 5 ) items.

Consider a feasible solution to the above-defined SKP with 2 ( $) items. Let the number of nodes from V’ that are included in the knapsack be ($) + p . Let B’ be the subgraph of B induced by the nodes included in the knapsack and let z be the number of items included in the knapsack. Because every node in V r can be incident to only two edges, z I 2 ($) + 2 p . Therefore, p 2 0. Now suppose p > 0. A node of V r will be of degree 2 in B‘ only if both endpoints of the corresponding edge in G correspond to nodes of V” that are included in the knapsack. Because there are k - p nodes from V” included in the knapsack, there can be at most ( kFp) such edges. Therefore we have

z I 2 . ( I ” ) + I .[ (t) + P - ( p ) ]

- 2k2 - 2 k + p 2 + 3 p - 2kp - * L

= 2 . ( ;) + P 2 + 3P - 2kP 2 ( 3 )

Ifp > 0, the second term of ( 3 ) is negative for k > ( p + 3 ) / 2 . But p I k , otherwise there would be more than ($) + k nodes included in the knapsack. By the assumptions of the proof k > 3, so the second term will be negative if 0 < p I k .

Thus, we can assume that p = 0. Because z = 2 ( : ) , each node of V r included in the knapsack must have degree 2 in B’. Therefore all endpoints of the corresponding edges of G must correspond to nodes of V” included in the knapsack. Because there are only k such nodes, these nodes must form a k clique in G .

Some restricted cases of the SKP can be solved in polynomial time, for example, when sj = v j = 1, I P, I = 2 and the item-edge graph is a forest. The proof for this and other special cases can be found in [ 7 1.

4. DYNAMIC PROGRAMMING ALGORITHM

In this section, we present an exact dynamic programming algorithm (DP) for the SKP. This algorithm is valid for all instances, but runs in polynomial time only for special cases.

The DP presented is an extension of the DP for solving the standard 0-1 knapsack problem [ 1 1, pp. 36-39] . In the forward DP formulation ofthe standard 0-1 knapsack problem, the optimality function, f( j , b’), is the optimal value of the knapsack problem with bin capacity b‘ and items 1, . . . , j . It is given by

838 Naval Research Logistics, Vol. 4 1 ( 1994)

with the boundary conditionsf( 0,b’) = 0 for b‘ 2 0, andf( j , b’) = - co for b‘ < 0. This algorithm delivers an optimal solution because when 6’ capacity is remaining, the

value of selecting or rejecting items 1, . . . , j is independent of which items amongj + 1, . . . , n use the capacity b - b’. This algorithm will not directly translate to the SKP because the value gained by adding a particular element depends on which other elements have already been placed. More precisely, suppose that at stagej of a DP for the SKP, the selection decisions of elements j + I , . . . , n have already been decided. To determine the optimal status of elements 1, . . . , j , we must know the individual status of elementj’ E { j + 1, . . . , n } if there exists a product containing both j‘ and at least one element from { 1, . . . , j } . This information is necessary in addition to the remaining capacity. For the general SKP, the set of such elements might be as large as O( n ) , and thus the state space of each stage might contain O( n ) binary variables.

More precisely, let

h( j) = { j’lj’ > j and 3i E { 1, . . . , m}, j ” E { 1, . . . , j } such that { j”, j’) E Pi}, ( 5 )

h’( j) = { j’ I j’ E h(j) and element j ’ has been included in the knapsack}, ( 6 )

In other words, h ( j ) is the subset of the nodes { j + 1, . . . , n } that are neighbors to any of the nodes { 1, . . . , j 1 in the item-adjacency graph.

We can define the recursion by

f ( j , b‘, h’( j)) = The optimal value of additional items that can be included by adding some of the elements { 1, . . . , j} , given that the elements h ’ ( j ) are already in the knapsack and the elements h - ( j ) are not included in the knapsack and given that the remaining capacity of the knapsack is b’.

where

p rod( j , h+( j ) )= { i I j E P i a n d P j ~ h + ( j ) U { j } }

and


b’E ( 0 , . . . , b } , f(0, b’, rZr) = [ O’

-a, otherwise.

At stagej of this algorithm, we need to decide, for each possible value of b’ and h + ( j ) , if nodej is to be included in the knapsack. There are b.2 l h ( ’ ) ’ possible states for stagej. A simple procedure to evaluate

takes O( mn) time in the worst case. So the entire DP takes O( mnb C:=, 2 I h ( ’ ) l ) time. The run-time complexity of this DP is polynomial if b is polynomial in n + m, sj E { 1, 2, . . . , b } , and

max Ih(J) l = O(log(n + m ) ) . j E { l . . . . , n )

5. RELATION TO CUT-WIDTH PROBLEM

To further characterize when the DP algorithm of Section 4 will run in polynomial time, consider the minimum cut-width problem [ 1, lo]. A layout L of a graph G = (V, E ) is a bisection of the set of vertices to the set { 1, . . . , I V I } :

The cut width of a graph G under layout L is defined as

cw(G, L ) = maxi( f k , I } E EIL(k) I L ( j ) and L(1) > L ( j ) } I . j € V

The minimum cut-width problem is to find a layout L such that cw( G, L ) is minimized. The corresponding recognition problem is defined as follows:

Instance: Graph G and integer k . Question: Is there a layout L of graph G such that the cut width G under L is at most k?

This problem is NP-complete for general graphs [5], but can be solved in polynomial time for trees [ 171 or ifthe minimum cw( G, L ) is bounded by a constant [ 101.

THEOREM 2: If the nodes of the item-adjacency graph G = (V, E ) are labeled according to a layout L and the cut width of G under L is cw( G, L ) , then

max lh( j ) l <cw(G,L). j e { l , . . ., n )

PROOF In order for a node to be in set h ( j ) , it must have a label greater than j and be adjacent to a node with a label less than or equal t o j . Therefore, for every node in h ( j ) thereisatleast oneedge ( k , f } EEsotha tL(k)sL( j )andL(f )>L( j ) .

840

Thus

Naval Research Logistics, Vol. 4 1 ( 1994)

max l h ( j ) l s c w ( G , L ) . j € V

H

THEOREM 3: The SKP restricted to the case where b is polynomial in n + m, sj E { 1, . . . , b } , and the item-adjacency graph has a known layout with cut width O( log( n + m ) ) can be solved in polynomial time using dynamic programming.

PROOF: Relabel the nodes of the graph according to layout L and run the dynamic program described in Section 4. The size of the largest of the sets h( j ) will be at most the cut width of G under L. H

The condition of Theorem 3 has two parts. First, the item-adjacency graph must have a cut width that is bounded by a logarithmic function of the size of the graph. Second, there must exist a polynomial-time algorithm that can find a layout of the graph with a cut width that is bounded by a logarithmic function of the size of the graph. For graphs with minimum cut width bounded by a constant, Makedon and Sudborough [ 101 have presented an exact polynomial-time algorithm to find the optimal layout. This fact implies the following.

THEOREM 4: I f the item-adjacency graph of a SKP has bounded cut width, b is polynomial in n + m , and s, E { 1, . . . , b } , then the problem can be solved in polynomial time.

PROOF Use the algorithm of Makedon and Sudborough to find a layout of the item- adjacency graph with bounded cut width; relabel the nodes of the graph according to the layout; then use the algorithm in Section 4. H

For graphs with a cut width that is not constant, but is O( log( n + m ) ) of the graph, Theorem 3 requires a constant approximation algorithm for the cut-width problem. We know of no polynomial-time algorithm constant approximation algorithm for the cut- width problem on general graphs. In [ 171, Yannakakis presents an exact polynomial-time algorithm for the minimum cut-width problem on trees. Chung and Seymour [ 2 ] show that if the degree of the nodes in a graph is bounded and it contains no refinement of a bounded complete binary tree, then the cut width of the graph is bounded. A refinement of a graph is any graph where one or more edges have been replaced by paths.

THEOREM 5: I f the item-adjacency graph of a SKP is a tree with cut width that is O(log(n + m ) ) , b is polynomial in n + m , ands,E { 1 , . . . , b } , then the problem can be solved in polynomial time.

PROOF: Use the cut-width algorithm of Yannakakis to sequence the elements; then apply the dynamic programming algorithm of Section 4.

The item-edge graph might have a small cut width if the elements can be associated with some measurement, say speed, and if most items only include elements with comparable

Goldschmidt et al.: Note on the Set-Union Knapsack Problem 84 1

speeds. In this case, a good layout of the elements might be found simply by sorting the elements according to speed.

6. CONCLUSION

We have defined the SKP and discussed some applications for it. The SKP is NP-hard even for very restricted cases. We have presented an exact, dynamic programming algorithm and characterized when it will run in polynomial time. Open problems include nar- rowing the gap between special cases of SKP that are known to be NP-hard and those that are known to be polynomially solvable. To our knowledge, it is not known if a constant approximation algorithm exists that will work on all instances of SKP.

ACKNOWLEDGMENTS

Gang Yu’s research is supported in part by ONR Grants No. NO00 14-9 1 -J- 124 1 and No. NO00 14-92-5- 1538, and by URI and FADRC grants from the University of Texas at Austin.

REFERENCES

[ 1 ] Chinn, P.Z., Chvitalovi, J., Dewdney, A.K., and Gibbs, N.E., “The Bandwidth Problem for Graphs and Matrices-A Survey,” Journal of Graph Theory, 6,223-254 ( 1982).

[ 21 Chung, F.R.K., and Seymour, P.D., “Graphs with Small Bandwidth and Cutwidth,” Discrete Mathematics, 75, 113-1 19 ( 1989).

[ 31 Crama, Y., and Mazzola, J., “Facets of the Dense Subhypergraph Problem,” European Journal of Operations Research (in press).

[ 41 Crama, Y., and Oerlemans, A., “A Column Generations Approach to Job Grouping for Flexi- ble Manufacturing Systems,” Research Memorandum No. 92.0 10, Department of Quantita- tive Economics, University of Limburg, The Netherlands, 1992.

[ 51 Carey, M.R., and Johnson, D.S., Computers and Intractability: A Guide to the Theory ofNP- Completeness, W.H. Freeman and Company, New York, 1979.

[ 61 Goldschmidt, O., Hochbaum, D.S., and Yu, G., “Component Assembly in the Semiconductor Industry: A Study of Covering in Graphs and Hypergraphs,” Working Paper No. 92193-3-3, Graduate School of Business, University of Texas, 1992.

[ 71 Goldschmidt, O., Nehme, D., and Yu, G., “On a Generalization ofthe Knapsack Problem with Applications to Flexible Manufacturing Systems and Database Partitioning,” Working Paper No. 92193-3-7, Graduate School of Business, University of Texas at Austin, 1992.

[ 81 Hirabayashi, R., Suzuki, H., and Tsuchiya, N., “Optimal Tool Module Design Problem for NC Machine Tools,” Journal of the Operations Research Society of Japan, 27,205-228 ( 1984).

[9] Hwang, S., “A Constraint-Directed Method to Solve the Part Selection Problem in Flexible Manufacturing Systems Planning Stage,” in K. Stecke and I. Kim (Eds.), Proceedings ofthe Second ORSA/TIMS Conference on Flexible Manufacturing Systems, Elsevier Science Pub- lishers BV, New York, 1986, pp. 297-309.

[ 101 Makedon, F.S., and Sudborough, I.H., “On Minimizing Width in Linear Layouts,” Discrete AppliedMathematics, 23,243-265 ( 1989).

[ 1 1 ] Martello, S., and Toth, P., Knapsack Problems: Algorithms and Computer Implementations, John Wiley and Sons, New York, 1990.

[ 121 Navathe, S., Ceri, S., Wiederhold, G., and Dou, J., “Vertical Partitioning Algorithms for Data- base Design,” ACM Transactions on Database Systems, 9,680-7 10, 1984.

[ 131 Rajagopalan, S., “Formulation and Heuristic Solutions for Parts Grouping and Tool Loading in Flexible Manufacturing Systems,” in K. Stecke and I. Kim (Eds.), Proceedings of the Second

842 Naval Research Logistics, Vol. 4 1 ( I994 )

ORSA/TIMS Conference on Flexible Manufacturing Syslems, Elsevier Science Publishers BV, New York, 1986, pp. 3 1 1-320.

[ 141 Rhys, J.M.W., “A Selection Problem of Shared Fixed Costs and Network Flows,” Management Science, 17,200-207 ( 1970).

[ 151 Tang, C.S., and Denardo, E.V., “Models Arising from a Flexible Manufacturing Machine, Part 11: Minimizing the Number of Switching Instants,” Operations Research, 36,778-784 ( 1988).

[ 161 Whitney, C., and Gaul, T., “Sequential Decision Problems for Batching and Balancing in FMSs,” Annuls of Operations Research, 3,30 1-3 16 ( 1985 ).

[ 171 Yannakakis, M., “A Polynomial Time Algorithm for the Min Cut Linear Arrangement of Trees,” Journal ofthe ACM, 32,950-959 ( 1985).

[ 181 Yu, G., Nayak, N., and Nehme, D., “Product Sequencing in Multiple Product Setups for Elec- tronic Card Assembly Process,” IBM Report No. TR5 I .07 I I , 1992.

Manuscript received March 9, 1993 Revised manuscript received November 23, 1993 Accepted April 29, 1994

Note: On the set-union knapsack problem

Documents

Transcript of Note: On the set-union knapsack problem