Question

我知道迭代解决方案：

给出一组n元素

保存int v = 2^n并生成最多为v的所有二进制文件。

但是如果n＆gt; 32？

我知道它已经有2 ^ 32个子集，但是 - 绕过32个元素限制的方法是什么？

Answer 1

如果您对64项限制感到满意，可以使用long。

ArrayList s / int的数组/ long。有一个next函数，如：

bool next(uint[] arr)
  for (int i = 0; i < arr.length; i++)
    if (arr[i] == 2^n-1) // 11111 -> 00000
      arr[i] = 0
    else
      arr[i]++
      return true
  return false // reached the end -> there is no next

BitArray。与上述相比，可能不是一个非常有效的选择。

您可以使用next函数将最低有效位0设置为1，将所有剩余位设置为0.例如：
```
10010 -> 10011
10011 -> 10100
```

注意 - 这可能会花费很长时间，因为有很多子集，但这不是问题。

Answer 2

您可以使用@biziclop方法，通过以下方式传播进位：将您的数字存储为长度为K的32位“数字”的向量。因此，您可以生成2 ^（K * 32）个子集，并且每个增量操作最多需要O（K）操作。我能想到的另一件事是递归回溯，它将在一个数组中生成所有子集。

Answer 3

你可以写一个简洁的Haskell实现的模拟：

powerSet = filterM (const [True, False])

除了C＃中没有内置filterM。这没问题，你可以自己实现。以下是我的尝试：

public static IEnumerable<IEnumerable<T>> PowerSet<T>(IEnumerable<T> els)
{
    return FilterM(_ => new[] {true, false}, els);
}

public static IEnumerable<IEnumerable<T>> FilterM<T>(
    Func<T, IEnumerable<bool>> p,
    IEnumerable<T> els)
{
    var en = els.GetEnumerator();
    if (!en.MoveNext())
    {
        yield return Enumerable.Empty<T>();
        yield break;
    }

    T el = en.Current;
    IEnumerable<T> tail = els.Skip(1);
    foreach (var x in
        from flg in p(el)
        from ys in FilterM(p, tail)
        select flg ? new[] { el }.Concat(ys) : ys)
    {
        yield return x;
    }
}

然后你可以像这样使用它：

foreach (IEnumerable<int> subset in PowerSet(new [] { 1, 2, 3, 4 }))
{
    Console.WriteLine("'{0}'", string.Join(",", subset));
}

如您所见，int和long都未在实现中的任何位置显式使用，因此这里的实际限制是当前堆栈大小限制可以达到的最大递归深度。

UPD： Rosetta Code提供非递归实现：

public static IEnumerable<IEnumerable<T>> GetPowerSet<T>(IEnumerable<T> input)
{
    var seed = new List<IEnumerable<T>>() { Enumerable.Empty<T>() }
        as IEnumerable<IEnumerable<T>>;

    return input.Aggregate(seed, (a, b) =>
        a.Concat(a.Select(x => x.Concat(new List<T> { b }))));
}

迭代地获取特定集的所有子集

3 个答案: