通过从每个集合中仅选择一个值来选择 k 个大小的子集

Question

给定一个长度为 n 个元素的数组，其中每个元素表示集合大小，确定可以选择 K 大小集合的方式数。

条件：您不能从一组中选择多个元素。如何 解决这个问题（任何程序）

例子：

输入：

n = 4
k = 3
{1,2,1,1} Each value represents number of elements in each set

输出：7

Example : 

{1},{2,3},{4},{5}

{1,2,4}
{1,2,5}
{1,3,4}
{1,3,5}
{1,4,5}
{2,4,5}
{3,4,5}

我尝试过的代码，但它返回 10 个不符合条件的值 我在这里犯了什么错误？ 他们只是给出了子集长度而不是实际子集。所以我基于所有子集长度的总和，我正在形成一个新数组

count = 0

def printCombination(arr, n, r):
    global count
    data = [0]*r
    combinationUtil(arr, data, 0,
                    n - 1, 0, r)


def combinationUtil(arr, data, start,
                    end, index, r):
    global count

    if (index == r):

        for j in range(r):
            print(data[j], end=" ")
        print()
        count += 1
        return
    i = start
    while(i <= end and end - i + 1 >= r - index):
        data[index] = arr[i]
        combinationUtil(arr, data, i + 1,
                        end, index + 1, r)
        i += 1

in_val = [1,2,1,1] 
arr = list(range(1,sum(in_val)+1)) r = 3 
n = len(arr) 
printCombination(arr, n, r) 
print(count)

我们可以用一些公式用最少的时间解决这个问题，而不是模拟每个子集并遍历。请对此有所了解或给我建议以进一步进行。

Answer 1

假设所有输入集都是不相交的，动态规划方法允许我们在O(n) 时间内计算此类组合的数量，其中n 是集的数量（假设输入集的基数由一个常数限定; 否则，时间复杂度为O(n, max_size)，其中max_size 是具有最大大小的输入集的基数。

import random # testing
from functools import lru_cache # memoization

xs = [{1},{2,3},{4},{5}]
k = 3
sizes = [len(x) for x in xs]
# [1, 2, 1, 1]

# dynamic programming approach
def count_combinations(sizes, k=3):
  @lru_cache(None)
  def f(n, k):
    if (n < k) or (k < 0):
      # no combination possible
      return 0
    elif n == k:
      # return product sizes[:n]
      res = 1
      for x in sizes[:n]:
        res *= x
      return res
    else:
      # recursive memoized call
      # f(n-1, k-1) ways to select k-1 elts from n-1 sets
      # times size of n-1'st set (counting from 0)
      # plus f(n-1, k) ways to select k elts from n-1 sets
      return sizes[n-1] * f(n-1, k-1) + f(n-1, k)
  return f(len(sizes), k)

# assert count_combs(sizes, k=k) == count_combinations(sizes, k)

---

# larger benchmark
n = 25
k = n // 2
xs = [{random.randint(0, n) for i in  range(n)} for _ in range(n)]
sizes = [len(x) for x in xs]

%time count_combs(sizes, k)          # O(n choose k), 8.6 s
%timeit count_combinations(sizes, k) # O(n), 112 µs

这避免了明确考虑大小 k 的所有可能组合，将复杂性从 O(n choose k) 降低到 O(n)。

Answer 2

确定可以选择 K 尺寸集的方法数。

from itertools import combinations
from functools import reduce

def count_combs(arr, k):
  if k > len(arr):
    return 0  # Not possible
  elif k == len(arr):
    return reduce(lambda a, b: a*b, arr) # multiply values in arr
  else:
    """sum of answer to each sub-set of arr of size k
       subsets of arr of size k are combinations(arr, k)"""
    return sum(count_combs(x, k) for x in combinations(arr, k))

测试

arr = [1, 2, 1, 1]
print(count_combs(arr, 3))
# Outputs 7

arr = [1, 1, 1, 1]
print(count_combs(arr, 3))
# Outputs 4

arr = [1, 1, 1, 2]
print(count_combs(arr, 2))
# Output 9

说明

三种情况

1. k > len(arr): 不可能，所以答案是 0
2. k == len(arr)：它是我们可以从每个数组索引中一次获取一个元素的方法数，它是数组 arr 值的乘积。
3. k