如何让我的递归选择 k 函数在 Python 中处理大数字？

Question

标题说明了一切，我的函数不适用于大数字。 例如 (1000 C 800) 会使它崩溃。

def choose(n, k):
    if n == k:
        return 1
    elif k == 0:
        return 1
    else:
        return choose(n-1, k) + choose(n-1, k-1)

Answer 1

def choose(n, k):
  dp = [[0 for x in xrange(k+1)] for x in xrange(n+1)]

  for i in xrange(n+1):
    for j in xrange(k+1):
      if j > i:
        continue
      if j == 0:
        dp[i][j] = 1
      elif j == i:
        dp[i][j] = 1
      else:
        dp[i][j] = dp[i-1][j-1] + dp[i-1][j]

  return dp[n][k]

您可以使用动态规划来避免一遍又一遍地计算相同的子问题。 这是以一些空间为代价的。

Answer 2

为避免重复重新计算相同的子结果，您可以使用自下而上的迭代解决方案，构建一行Pascal's triangle ，然后从中构建下一个，...等：

def choose(n, k):
    lst = [1] * (n+1)
    for j in range(1, n):
        for i in range(j, 0, -1):
            lst[i] += lst[i-1]
    return lst[k]

print(choose(1000, 800))

661715556065930365627163346132458831897321703017638669364788134708891795956726411057801285583913163781806953211915554723373931451847059830252175887712457307547649354135460619296383882957897161889636280577155889117185

这只是为了展示如何使该方法更有效，但当然有几种更有效的方法来计算 C(n,k) 。

Answer 3

您可以通过划分因子来使递归方法的性能更好：

def choose(n, k):
    if k == 0:
        return 1
    return n * choose(n-1, k-1) // k

这使用递归关系：

这种方法将立即计算 1000 C 800 而不会破坏递归堆栈。 但是，潜在的问题仍然存在——它只是被推迟到更大的数字上。 您可能更喜欢使用各种封闭形式的解决方案之一，例如：

from math import factorial

def choose(n, k):
    if n < k:
        n = k - n
    return factorial(n) // (factorial(k) * factorial(n-k))