Subsets with equal sum

问题

I want to calculate how many pairs of disjoint subsets S1 and S2 (S1 U S2 may not be S) of a set S exists for which sum of elements in S1 = sum of elements in S2.

Say i have calculated all the subset sums for all the possible 2^n subsets. How do i find how many disjoint subsets have equal sum.

For a sum value A, can we use the count of subsets having sum A/2 to solve this ?

As an example : S ={1,2,3,4}

Various S1 and S2 sets possible are:

S1 = {1,2} and S2 = {3}

S1 = {1,3} and S2 = {4}

S1 = {1,4} nd S2 = {2,3}

Here is the link to the problem : http://www.usaco.org/index.php?page=viewproblem2&cpid=139

回答1:

[EDIT: Fixed stupid complexity mistakes. Thanks kash!]

Actually I believe you'll need to use the O(3^n) algorithm described here to answer this question -- the O(2^n) partitioning algorithm is only good enough to enumerate all pairs of disjoint subsets whose union is the entire ground set.

As described at the answer I linked to, for each element you are essentially deciding whether to:

1. Put it in the first set,
2. Put it in the second set, or
3. Ignore it.

Considering every possible way to do this generates a tree where each vertex has 3 children: hence O(3^n) time. One thing to note is that if you generate a solution (S1, S2) then you should not also count the solution (S2, S1): this can be achieved by always maintaining an asymmetry between the two sets as you build them up, e.g. enforcing that the smallest element in S1 must always be smaller than the smallest element in S2. (This asymmetry enforcement has the nice side-effect of halving the execution time :))

---

A speedup for a special (but perhaps common in practice) case

If you expect that there will be many small numbers in the set, there is another possible speedup available to you: First, sort all the numbers in the list in increasing order. Choose some maximum value m, the larger the better, but small enough that you can afford an m-size array of integers. We will now break the list of numbers into 2 parts that we will process separately: an initial list of numbers that sum to at most m (this list may be quite small), and the rest. Suppose the first k <= n numbers fit into the first list, and call this first list Sk. The rest of the original list we will call S'.

First, initialise a size-m array d[] of integers to all 0, and solve the problem for Sk as usual -- but instead of only recording the number of disjoint subsets having equal sums, increment d[abs(|Sk1| - |Sk2|)] for every pair of disjoint subsets Sk1 and Sk2 formed from these first k numbers. (Also increment d[0] to count the case when Sk1 = Sk2 = {}.) The idea is that after this first phase has finished, d[i] will record the number of ways that 2 disjoint subsets having a difference of i can be generated from the first k elements of S.

Second, process the remainder (S') as usual -- but instead of only recording the number of disjoint subsets having equal sums, whenever |S1'| - |S2'| <= m, add d[abs(|S1'| - |S2'|)] to the total number of solutions. This is because we know that there are that many ways of building a pair of disjoint subsets from the first k elements having this difference -- and for each of these subset pairs (Sk1, Sk2), we can add the smaller of Sk1 or Sk2 to the larger of S1' or S2', and the other one to the other one, to wind up with a pair of disjoint subsets having equal sum.

回答2:

Here is a clojure solution.

It defines s to be a set of 1, 2, 3, 4 Then all-subsets is defined to be a list of all sets of size 1 - 3

Once all the subsets are defined, it looks at all pairs of subsets and selects only the pairs that are not equal, do not union to the original set, and whose sum is equal

(require 'clojure.set)
(use 'clojure.math.combinatorics)

(def s #{1, 2, 3, 4})
(def subsets (mapcat #(combinations s %) (take 3 (iterate inc 1))))

(for [x all-subsets y all-subsets 
          :when (and (= (reduce + x) (reduce + y)) 
                     (not= s (clojure.set/union (set x) (set y))) 
                     (not= x y))] 
      [x y])

Produces the following:

([(3) (1 2)] [(4) (1 3)] [(1 2) (3)] [(1 3) (4)])

来源：https://stackoverflow.com/questions/19499544/subsets-with-equal-sum