Special subset sums: meta-testing
Let S(A) represent the sum of elements in set A of size n. We shall call it a special sum set if for any two non-empty disjoint subsets, B and C, the following properties are true:
- S(B) ≠ S(C); that is, sums of subsets cannot be equal.
- If B contains more elements than C then S(B) > S(C).
For this problem we shall assume that a given set contains n strictly increasing elements and it already satisfies the second rule.
Surprisingly, out of the 25 possible subset pairs that can be obtained from a set for which n = 4, only 1 of these pairs need to be tested for equality (first rule). Similarly, when n = 7, only 70 out of the 966 subset pairs need to be tested.
For n = 12, how many of the 261625 subset pairs that can be obtained need to be tested for equality?
NOTE: This problem is related to Problem 103 and Problem 105.
特殊的子集和：元检验
记S(A)是大小为n的集合A中所有元素的和。若任取A的任意两个非空且不相交的子集B和C都满足下列条件，我们称A是一个特殊的和集：
- S(B) ≠ S(C)；也就是说，任意子集的和不相同。
- 如果B中的元素比C多，则S(B) > S(C)。
在这个问题中我们假定集合中包含有n个严格单调递增的元素，并且已知其满足第二个条件。
令人惊奇的是，当n = 4时，在所有可能的25组子集对中只有1组需要检验子集和是否相等（第一个条件）。同样地，当n = 7时，在所有可能的966组子集对中只有70组需要检验。
当n = 12时，在所有可能的261625组子集对中有多少组需要检验？
解题
首先 想说的是语文差，题目没理解，搞了好久。
注意几点：
1.这里的集合和不一定是特殊子集
2.这个集合元素一定是严格递增的
3.集合是已经满足第二个条件，解题中不需要判断
4.求的是子集对可能相等的个数
4.1子集对，两个子集也一定是不相交的
4.2“需要检验”的意思是，不需要检验的子集对一定不相等，“需要检验”的子集对可能相等，注意这里面的可能 ，它也可能不相等，可以理解为：要求的是最大的个数
当 1 2 3 条都正确理解到的时候：n个数的集合只要是任意n个数的递增序列就好了，如：1、2、3、4,、、、、、、n
第4条：求子集对可能相等的个数
什么情况下两个子集B、C内元素的和是相等的？
注意：集合A是严格递增的，则子集B、C也一定是严格递增的
子集B、C元素和一定不相等的情况：
1.集合B、C的元素个数不相等
2.集合B的最小值 > 集合C的最大值
反过来
子集B、C元素和可能相等的情况：
1.集合B、C的元素个数相等 并且 B中的元素有大于C中的元素的，C中的元素有大于B中的元素的
根据上面就可解
Java
package Level4;
import java.util.ArrayList;
import java.util.Arrays;
public class PE0106{
public static void run(){
int A[] = { 1,2,3,4,5,6,7,8,9,10,11,12};
// int A[] = {1219 ,1183, 1182, 1115, 1035, 1186, 591, 1197, 1167, 887, 1184, 1175};
Arrays.sort(A);
meta_testing(A);
}
public static void meta_testing(int[] a){
// 所有的子集
ArrayList<ArrayList<Integer>> sets = MakeSubsets(a);
int size = sets.size();
int count_equal = 0;
int count_sets = 0;
System.out.println("子集总数量："+size);
for(int i=0;i<size;i++){
ArrayList<Integer> set1 = sets.get(i);
for(int j=i+1;j<size;j++){
ArrayList<Integer> set2 = sets.get(j);
//不相交
if(!isDisjoint(set1,set2) ){
count_sets++;
if(set1.size() == set2.size()){
int s = 0;
int t = 0;
for(int k = 0;k<set1.size();k++){
if(set1.get(k) > set2.get(k))
s = 1;
if(set1.get(k) < set2.get(k))
t = 1;
}
if(s == 1 && t == 1)
count_equal++;
}
}
}
}
System.out.println("子集对数量："+count_sets);
System.out.println("可能相等的子集数量："+count_equal);
}
// 两个子集元素是否相交 true 相交 false 不相交
public static boolean isDisjoint(ArrayList<Integer> set1,ArrayList<Integer> set2){
int size1 = set1.size();
int size2 = set2.size();
ArrayList<Integer> set = new ArrayList<Integer>();
for(int i=0;i<size1;i++){
int element = set1.get(i);
if(set.contains(element))
return true;
else
set.add(element);
}
for(int i=0;i<size2;i++){
int element = set2.get(i);
if(set.contains(element))
return true;
else
set.add(element);
}
set.clear();
return false;
}
// 求出所有的子集
public static ArrayList<ArrayList<Integer>> MakeSubsets(int a[]){
ArrayList<ArrayList<Integer>> sets = new ArrayList<ArrayList<Integer>>();
for(int i=1;i< (int) Math.pow(2,a.length);i++){
ArrayList<Integer> set = MakeSubset(a,i);
sets.add(set);
}
return sets;
}
// 求出子集
// 利用 和 1 进行与运算 并移位
// 001001 相当于根据 1 所在的位置取 第 2 第 5的位置对应的数
// &000001
//----------
// 1 取出该位置对应的数
// 下面右移一位后
// 000100
// 下面同理了
public static ArrayList<Integer> MakeSubset(int[] a,int m){
ArrayList<Integer> set = new ArrayList<Integer>();
for(int i=0;i<a.length ;i++){
if( m>0 &&(m&1)==1){
set.add(a[i]);
}
m =m>>1;
}
return set;
}
public static void main(String[] args){
long t0 = System.currentTimeMillis();
run();
long t1 = System.currentTimeMillis();
long t = t1 - t0;
System.out.println("running time="+t/1000+"s"+t%1000+"ms");
}
}
Java Code
子集总数量：4095 子集对数量：261625 可能相等的子集数量：21384 running time=3s496ms
Python
# coding=gbk
import itertools
se=set(range(1,13))
c=0
for i in xrange(2,len(se)):
for m in itertools.combinations(se,i):
for n in itertools.combinations(se-set(m),i):
t=0
for k in range(len(m)):
if m[k]>n[k]:
t=1
s=0
for k in range(len(m)):
if m[k]<n[k]:
s=1
if s==1 and t==1:
c+=1
print c/2.
Mathblog 中直接求出答案，所有的子集对数量比较好求，至于后来用到了卡特兰数，问题没有过多的讲解，我也不知道为什么。
答案= 
题解中看到的解答：
# coding=gbk
import itertools
def C(n,k):
result = 1
for i in range(k):
result *= n - i
result /= i + 1
return result
def Catalan(n):
return C(2 * n, n) / (n + 1)
def e106meta(n):
result = 0
for k1 in range(1,n):
for k2 in range(1,min(k1,n-k1)+1):
x = C(n,k1)*C(n-k1,k2)
if k1 == k2:
x /= 2
result += x
return result
def e106(n):
result = 0
for k in range(2,n/2 + 1):
result += C(n,2*k)*(C(2*k,k)/2 - Catalan(k))
return result
if __name__ == ‘__main__‘:
assert e106(7) == 70
print e106(12)