Topcoder_2_162

【问题描述】
    一个由非负整数数组组成的包，该包中装的是一些相同的商品，整数代表它们的数量（可能重复），它们之间顺序可以是任意的。有2个包A和B，如果A中包含的数量是由B中包含的数量组成的，那么A为B的子包。包中所有元素的和为包的总重量。
    例如：包(1,2,1,3,1) 和 (3,1,1,1,2)是相同的（以为和顺序无关），但是和 包(1,2,3,3)是不同的。包 (1,2) 和 (3,1,1)是包(1,2,1,3,1)的子包，为(1,2,2)不是。包(1,2,1,3,1)的重量是1+2+1+3+1=8。
    现在要求实现一个方法，计算所有子包中重量值是素数的子包个数。（注：0和1不是素数）

  定义：
类  PrimeSums
方法  public long getCount(int[] bag);

  约束：
1、包包含1至50个元素（包含）
2、每个元素的数量包含0至10000（包含）

  测试用例：
1、{1,1,2,7}
Returns: 5
2、{1,1,1,1,1,1,1,1,1,1}
Returns: 4
3、{4,6,8,10,12,14}
Returns: 0
4、{1,2,4,8,16,32,64,128}
Returns: 54
5、{0,0,7}
Returns: 3

1. import java.util.HashMap;
2. import java.util.Map;
4. public class PrimeSums {
5.     private Map<String,Integer> sumMap = new HashMap<String, Integer>();
7.     private boolean isPrimeNumber(int num) {
8.         double sqrt = Math.sqrt(num);
9.         if(num==0 || num==1)
10.             return false;
11.         for (int i = 2; i <= sqrt; i++) {
12.             if (num % i == 0)
13.                 return false;
14.         }
15.         return true;
16.     }
18.     private void getSubCnt(String str, int start, int[] bag) {
19.         if(start==bag.length){
20.             StringBuilder sb = new StringBuilder();
21.             String[] tmp = str.trim().split("//s");
22.             int sum=0;
23.             for (String string : tmp) {
24.                 sb.append(string).append(" ");
25.                 if(!"".equals(string))
26.                     sum += Integer.parseInt(string);
27.             }
28.             sumMap.put(sb.toString().trim(),sum);
29.             return;
30.         }
31.         getSubCnt(str, start+1, bag);
32.         getSubCnt(str+bag[start]+" ", start+1, bag);
33.     }
35.     public long getCount(int[] bag) {
36.         int count = 0;
37.         getSubCnt("", 0, bag);
38.         for (String str : sumMap.keySet()) {
39.             if (isPrimeNumber(sumMap.get(str).intValue()))
40.                 count++;
41.         }
42.         return count;
43.     }
44. }

【算法思想】
    使用递归方式得到集合中所有组合的情况，再排除重复后进行计数。