Project Euler P105:Special subset sums: testing 特殊的子集和 检验

Special subset sums: 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:

1. S(B) ≠ S(C); that is, sums of subsets cannot be equal.
2. If B contains more elements than C then S(B) > S(C).

For example, {81, 88, 75, 42, 87, 84, 86, 65} is not a special sum set because 65 + 87 + 88 = 75 + 81 + 84, whereas {157, 150, 164, 119, 79, 159, 161, 139, 158} satisfies both rules for all possible subset pair combinations and S(A) = 1286.

Using sets.txt (right click and “Save Link/Target As…”), a 4K text file with one-hundred sets containing seven to twelve elements (the two examples given above are the first two sets in the file), identify all the special sum sets, A1, A2, …, Ak, and find the value of S(A1) + S(A2) + … + S(Ak).

NOTE: This problem is related to Problem 103 and Problem 106.

---

特殊的子集和：检验

记S(A)是大小为n的集合A中所有元素的和。若任取A的任意两个非空且不相交的子集B和C都满足下列条件，我们称A是一个特殊的和集：

1. S(B) ≠ S(C)；也就是说，任意子集的和不相同。
2. 如果B中的元素比C多，则S(B) > S(C)。

例如，{81, 88, 75, 42, 87, 84, 86, 65}不是一个特殊和集，因为65 + 87 + 88 = 75 + 81 + 84，而{157, 150, 164, 119, 79, 159, 161, 139, 158}满足上述规则，且相应的S(A) = 1286。

在4K的文本文件sets.txt（右击并选择“目标另存为……”）中包含了一百组包含7至12个元素的集合（文档中的前两个例子就是上述样例），找出其中所有的特殊和集A1、A2、……、Ak，并求S(A1) + S(A2) + … + S(Ak)的值。

注意：此题和第103题及第106题有关。

解题

直接利用最优特殊子集的算法解题即可

Java

package Level4;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.TreeSet;

public class PE0105{

    public static void run(){
        String filename = "src/Level4/p105_sets.txt";
        ArrayList<int[]> sets = readSets(filename);
        int sum = 0;
        for(int i=0;i<sets.size();i++){
            int[] A = sets.get(i);
            if(isOptimum(A)){
                sum+= sum(A);
            }
        }
        System.out.println(sum);
    }
//    73702
//    running time=14s966ms
    // 验证 是否是最优子集
    // 子集  一个集合可能有多个子集，而下面的程序只是看成两个自己的情况，两个子集的并集等于原来集合，照成程序有问题
    public static boolean isOptimum(int[] a){
        // 所有的子集
        ArrayList<ArrayList<Integer>> sets = MakeSubsets(a);
        int size = sets.size();
//        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)){
                    int sum1 = sum(set1);
                    int sum2 = sum(set2);
                    if(sum1 == sum2)
                        return false;
                    if(set1.size() > set2.size() && sum1 <=sum2)
                        return false;
                    if(set1.size() < set2.size() && sum1 >= sum2)
                        return false;
                }
            }
        }
        return true;
    }

    // 求集合的和
    public static int sum(ArrayList<Integer> set){
        int sum = 0;
        for (int i=0;i<set.size();i++)
            sum+=set.get(i);
        return sum;
    }
    // 求数组的和
    public static int sum(int[] set){
        int sum = 0;
        for (int i=0;i<set.length;i++)
            sum+=set[i];
        return sum;
    }
    // 两个子集元素是否相交 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 int[] strToarr(String line){
        String[] strArr = line.split(",");
        int[] A = new int[strArr.length];
        for(int i=0;i<strArr.length;i++){
            A[i] = Integer.parseInt(strArr[i]);
        }
        return A;
    }
    public static ArrayList<int[]> readSets(String filename){
        BufferedReader bufferedReader = null;
        ArrayList<int[]> sets = new ArrayList<int[]>();
        try {
             bufferedReader = new BufferedReader(new FileReader(filename));
             String line ="";
             try {
                while((line=bufferedReader.readLine())!=null){
                     int[] A = strToarr(line);
                     sets.add(A);
                 }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                System.out.println("文件内部没有数据");
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            System.out.println("没有发现文件");
        }
        return sets;
    }
    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");
    }
}