Question

我一直在努力应对Greplin挑战赛的第3级。对于那些不熟悉的人，问题出在这里：

您必须找到数组的所有子集，其中最大数字是剩余数字的总和。例如，输入：

（1,2,3,4,6）

子集将是

1 + 2 = 3

1 + 3 = 4

2 + 4 = 6

1 + 2 + 3 = 6

以下是您应该输入的数字列表   运行你的代码。密码是   子集数量。在上面的例子中   答案是4。

3,4,9,14,15,19,28,37,47,50,54,56,59,61,70,73,78,81,92,95,97,99

我能够编写一个解决方案来构建22个数字的所有400万个组合，然后对它们进行全部测试，这将得到正确的答案。问题是需要40多分钟才能完成。在网络上搜索似乎有几个人能够在不到一秒的时间内编写算法来获得答案。任何人都可以用伪代码解释比计算上昂贵的暴力方法更好的解决方法吗？这让我疯了！

Answer 1

诀窍在于，您只需要跟踪有多少种方法可以做的事情。由于数字是排序和正数，这很容易。这是一个有效的解决方案。（我的笔记本电脑需要不到0.03秒。）

#! /usr/bin/python

numbers = [
    3, 4, 9, 14, 15, 19, 28, 37, 47, 50, 54, 56,
    59, 61, 70, 73, 78, 81, 92, 95, 97, 99]

max_number = max(numbers)
counts = {0: 1}
answer = 0
for number in numbers:
    if number in counts:
        answer += counts[number]
    prev = [(s,c) for (s, c) in counts.iteritems()]
    for (s, c) in prev:
        val = s+number;
        if max_number < val:
            continue
        if val not in counts:
            counts[val] = c
        else:
            counts[val] += c
print answer

Answer 2

我们知道这些值非零并且从左到右单调增长。

一个想法是枚举可能的总和（任何顺序，从左到右都很好）然后枚举该值左侧的子集，因为右边的价值观不可能参与（他们会得到总和太大）。我们没有必要实例化该集合;就像我们考虑的那样每个值，看看如何影响总和。它可能太大（只是忽略那个值，不能在集合中），恰到好处（它是集合中的最后一个成员），或者太小，此时它可能会或可能不会出现在集合中。

[这个问题让我第一次玩Python。乐趣。]

这是Python代码;根据Cprofile.run，这需要.00772秒在我的P8700 2.54Ghz笔记本电脑上。

values = [3, 4, 9, 14, 15, 19, 28, 37, 47, 50, 54, 56, 59, 61, 70, 73, 78, 81, 92, 95, 97, 99] def count(): # sort(values) # force strictly increasing order last_value=-1 duplicates=0 totalsets=0 for sum_value in values: # enumerate sum values if last_value==sum_value: duplicates+=1 last_value=sum_value totalsets+=ways_to_sum(sum_value,0) # faster, uses monotonicity of values return totalsets-len(values)+duplicates def ways_to_sum(sum,member_index): value=values[member_index] if sum<value: return 0 if sum>value: return ways_to_sum(sum-value,member_index+1)+ways_to_sum(sum,member_index+1) return 1

我得到的计数是179.（匹配另一张海报的结果。）

编辑：ways_to_sum可以使用尾递归循环部分实现：

def ways_to_sum(sum,member_index): c=0 while True: value=values[member_index] if sum<value: return c if sum==value: return c+1 member_index+=1 c+=ways_to_sum(sum-value,member_index)

这需要.005804秒才能运行： - }同样的答案。

Answer 3

运行时间不到5毫秒（python）。它使用称为memoized递归的动态编程变体。 go函数计算了第一个p+1元素的子集数，总计为target。因为列表已经排序，所以足以为每个元素调用一次函数（如target）并对结果求和：

startTime = datetime.now()
li = [3, 4, 9, 14, 15, 19, 28, 37, 47, 50, 54, 56, 59, 61, 70, 73, 78, 81, 92, 95, 97, 99]
memo = {}
def go(p, target):
    if (p, target) not in memo:
        if p == 0:
            if target == li[0]:
                memo[(p,target)] = 1
            else:
                memo[(p,target)] = 0
        else:
            c = 0       
            if li[p] == target: c = 1
            elif li[p] < target: c = go(p-1,target-li[p])
            c += go(p-1, target)
            memo[(p,target)] = c
    return memo[(p,target)]

ans = 0
for p in range(1, len(li)):
    ans += go(p-1, li[p])

print(ans)
print(datetime.now()-startTime)

Answer 4

这有效

public class A {

  static int[] a = {3,4,9,14,15,19,28,37,47,50,54,56,59,61,70,73,78,81,92,95,97,99};

  public static void main(String[] args) {
    List<Integer> b = new ArrayList<Integer>();

    int count = 0;
    for (int i = 0; i < a.length; i++) {
        System.out.println(b);
        for (Integer t:b) {
        if(a[i]==t)
        {
        System.out.println(a[i]);
            count++;
            }
        }

        int size = b.size();
        for (int j = 0; j < size; j++) {
        if(b.get(j) + a[i] <=99)
            b.add(b.get(j) + a[i]);
        }
            b.add(a[i]);
    }

    System.out.println(count);

  }
}

伪代码（附说明）：

存储以下变量

i。）到现在为止“计数”子集

ii。）一个数组b，其中包含所有可能子集的总和

2.通过阵列（比如说a）。对于每个元素a [i]

i。）通过数组b并计算a [i]的出现次数。将此添加到'count'

ii。）通过数组b和每个元素b [j] .add（a [i] + b [j]）到b，因为这是一个可能的子集和。（如果a中的[i] + b [j]> gt; max元素，你可以忽略它来添加它）

iii。）将[i]添加到b。

3.u有数：）

Answer 5

我在这里使用了Java中的组合生成器类：

http://www.merriampark.com/comb.htm

迭代组合并寻找有效的子集花了不到一秒钟。（我不认为使用外部代码符合挑战，但我也没有申请。）

Answer 6

public class Solution {

   public static void main(String arg[]) {
    int[] array = { 3, 4, 9, 14, 15, 19, 28, 37, 47, 50, 54, 56, 59, 61,
        70, 73, 78, 81, 92, 95, 97, 99 };
    int N = array.length;
    System.out.println(N);
    int count = 0;
    for (int i = 1; i < 1 << N; i++) {
        int sum = 0;
        int max = 0;
        for (int j = 0; j < N; j++) {
        if (((i >> j) & 1) == 1) {
            sum += array[j];
            max = array[j];
        }
        }
        if (sum == 2 * max)
        count++;
    }
    System.out.println(count);
    }

    public static boolean isP(int N) {
    for (int i = 3; i <= (int) Math.sqrt(1.0 * N); i++) {
        if (N % i == 0) {
        System.out.println(i);
        // return false;
        }
    }
    return true;
    }
}

希望它有所帮助，但不要只是复制和粘贴。

Answer 7

我不想打败死马，但此处发布的大多数解决方案错过了优化的关键机会，因此执行时间要长6倍。

不是迭代输入数组并搜索与每个值匹配的和，而是仅计算一次所有可能的RELEVANT总和，然后查看原始输入数组中出现哪些总和更有效。（“相关”和是任何子集和＆lt; =数组中的最大值。）

第二种方法运行速度大约快6倍 - 通常是毫秒而不是厘秒 - 仅仅因为它将递归求和函数调用了大约1/6的次数！

这个方法的代码和完整的解释可以在这个github repo中找到（它在PHP中，因为那是给我这个挑战的人所要求的）：

https://github.com/misterrobinson/greplinsubsets

计算数组的所有子集，其中最大数字是剩余数字的总和

7 个答案: