# Set packing

**Set packing** is a classical NP-complete problem in computational complexity theory and combinatorics, and was one of Karp's 21 NP-complete problems.

Suppose we have a finite set *S* and a list of subsets of *S*. Then, the set packing problem asks if some *k* subsets in the list are pairwise disjoint (in other words, no two of them share an element).

More formally, given a universe and a family of subsets of ,
a *packing* is a subfamily of sets such that all sets in are pairwise disjoint, and the size of the packing is . In the set packing decision problem, the input is a pair and an integer ; the question is whether
there is a set packing of size or more. In the set packing optimization problem, the input is a pair , and the task is to find a set packing that uses the most sets.

The problem is clearly in NP since, given *k* subsets, we can easily verify that they are pairwise disjoint in polynomial time.

The optimization version of the problem, **maximum set packing**, asks for the maximum number of pairwise disjoint sets in the list. It is a maximization problem that can be formulated naturally as an integer linear program, belongs to the class of packing problems, and its dual linear program is the set cover problem.^{[1]}

Template:Covering-Packing Problem Pairs

## Integer linear program formulation

The maximum set packing problem can be formulated as the following integer linear program.

maximize | (maximize the total number of subsets) | ||

subject to | for all | (selected sets have to be pairwise disjoint) | |

for all . | (every set is either in the set packing or not) |

## Examples

As a simple example, suppose your kitchen contains a collection of different food ingredients (), and you have a cook-book with a collection of recipes ( ). Each recipe requires a subset of the food ingredients. You want to prepare the largest possible collection of recipes from the cook-book. You are actually looking for a set-packing () on () - a collection of recipes whose sets of ingredients are pairwise disjoint.

As another example, suppose you're at a convention of foreign ambassadors, each of which speaks English and also various other languages. You want to make an announcement to a group of them, but because you don't trust them, you don't want them to be able to speak among themselves without you being able to understand them. To ensure this, you will choose a group such that no two ambassadors speak the same language, other than English. On the other hand you also want to give your announcement to as many ambassadors as possible. In this case, the elements of the set are languages other than English, and the subsets are the sets of languages spoken by a particular ambassador. If two sets are disjoint, those two ambassadors share no languages other than English. A maximum set packing will choose the largest possible number of ambassadors under the desired constraint. Although this problem is hard to solve in general, in this example a good heuristic is to choose ambassadors who only speak unusual languages first, so that not too many others are disqualified.

## Weighted version

There is a weighted version of the set packing problem in which each subset is assigned a real weight and it is this weight we wish to maximize:

In our simple example above, we might weight the recipes according to the number of friends that love the resulting dishes, so that our dinner will please the largest number of friends.

This seems to make the problem harder, but most known results for the unweighted problem apply to the weighted problem as well.

## Heuristics

The set packing problem may be hard for some *k*, but it's not hard to find a *k* for which it is easy on a particular input. For example, we can use a greedy algorithm where we look for the set which intersects the smallest number of other sets, add it to our solution, and remove the sets it intersects. We continually do this until no sets are left, and we have a set packing of some size, although it may not be the maximum set packing. Although no algorithm can always produce results close to the maximum (see next section), on many practical inputs these heuristics do so.

## Complexity

The set packing problem is not only NP-complete, but its optimization version (general maximum set packing problem) has been proven as difficult to approximate as the maximum clique problem; in particular, it cannot be approximated within any constant factor.^{[2]} The best known algorithm approximates it within a factor of . The weighted variant can also be approximated this well.

However, the problem does have a variant which is more tractable: if we assume no subset exceeds *k*≥3 elements, the answer can be approximated within a factor of *k*/2 + ε for any ε > 0; in particular, the problem with 3-element sets can be approximated within about 50%. In another more tractable variant, if no element occurs in more than *k* of the subsets, the answer can be approximated within a factor of *k*. This is also true for the weighted version.

## Equivalent problems

There is a one-to-one polynomial-time reduction between the independent set problem and the set packing problem:

- Given a set packing problem on a collection , create a graph where for each set there is a vertex , and there is an edge between and iff . Now every independent set of vertices in the generated graph corresponds to a set packing in .
- Given an independent vertex set problem on a graph , create a collection of sets where for each vertex there is a set containing all edges adjacent to . Now every set packing in the generated collection corresponds to an independent vertex set in .

This is also a bidirectional PTAS reduction, and it shows that the two problems are equally difficult to approximate.

## Special cases

Matching and 3-dimensional matching are special cases of set packing. A maximum-size matching can be found in polynomial time, but finding a largest 3-dimensional matching or a largest independent set is NP-hard.

Set packing is one among a family of problems related to covering or partitioning the elements of a set. One closely related problem is the set cover problem. Here, we are also given a set *S* and a list of sets, but the goal is to determine whether we can choose *k* sets that together contain every element of *S*. These sets may overlap. The optimization version finds the minimum number of such sets. The maximum set packing need not cover every possible element.

The NP-complete exact cover problem, on the other hand, requires every element to be contained in exactly one of the subsets. Finding such an exact cover at all, regardless of size, is an NP-complete problem. However, if we create a singleton set for each element of *S* and add these to the list, the resulting problem is about as easy as set packing.

Karp originally showed set packing NP-complete via a reduction from the clique problem.

See also: Packing in a hypergraph.

## Notes

- ↑ Template:Harvtxt
- ↑ {{#invoke:citation/CS1|citation |CitationClass=citation }}. See in particular p. 21: "Maximum clique (and therefore also maximum independent set and maximum set packing) cannot be approximated to within unless NP ⊂ ZPP."

## References

- Maximum Set Packing, Viggo Kann.
- "set packing".
*Dictionary of Algorithms and Data Structures*, editor Paul E. Black,*National Institute of Standards and Technology.*Note that the definition here is somewhat different. - Steven S. Skiena. "Set Packing".
*The Algorithm Design Manual*. Last modified June 2, 1997. - Pierluigi Crescenzi, Viggo Kann, Magnús Halldórsson, Marek Karpinski and Gerhard Woeginger. "Maximum Set Packing".
*A compendium of NP optimization problems*. Last modified March 20, 2000. - {{#invoke:citation/CS1|citation

|CitationClass=book }} A3.1: SP3, pg.221.

- {{#invoke:citation/CS1|citation

|CitationClass=book }}

## External links

- [1]: A Pascal program for solving the problem. From
*Discrete Optimization Algorithms with Pascal Programs*by MacIej M. Syslo, ISBN 0-13-215509-5. - Benchmarks with Hidden Optimum Solutions for Set Covering, Set Packing and Winner Determination
- Solving packaging problem in PHP