Question

尽管这似乎是重复的（也许是重复的，但我尚未找到解决此问题版本的方法），但我认为不是。

下面是我的递归函数，它破坏了python的递归限制，我需要使其进行迭代，但是在查看如何实现方面存在问题。

def countChain(n, cache):
    if cache[n] != -1:
        return cache[n]

    if n % 2 == 0:
        cache[n] = 1 + countChain(n / 2, cache)
    else:
        cache[n] = 2 + countChain((3 * n + 1) / 2, cache)

    return cache[n]

请注意，这里的缓存列表中有100万个元素...（这就是递归杀死python的原因）。我已经看到人们使用累加器来完成这项工作，但是在这里，我没有直接返回递归调用的结果，这使该想法难以实现。

编辑

第一次递归调用应该是cache[n] = 1 + countChain(n / 2, cache)而不是cache[n] = 1 + countChain(n, cache)

编辑2

有人要求提供数据，所以我将只键入整个代码（不那么长），以便更好地理解。

import time
import sys
import math

def main():
    target = int(sys.argv[1])

    start = time.time()
    longest = 0
    answer = -1

    for i in range(int(target/2), target):
        if countChain(i) > longest:
            longest = countChain(i)
            answer = i

    print("Result = ", answer, " in ", (time.time() - start), " seconds")

def countChain(n,cache={1:0}):
    if n not in cache: 
        if n % 2 == 0:
            cache[n] = 1 + countChain(n//2, cache)
        else:
            cache[n] = 2 + countChain((3 * n + 1) // 2, cache)
    return cache[n]

if __name__ == "__main__":
    main()

通常的输入是1000000

另外，其他应该是2 + ...

Answer 1

三个版本： natural 递归并缓存了一个：

def countchain_recursive_cache(n):
    if n not in cache: 
        if n % 2 == 0:
            cache[n] = 1 + countchain_recursif(n//2)
        else:
            cache[n] = 1 + countchain_recursif(3 * n + 1)
    return cache[n]

一个纯粹的迭代器：

def countchain_iterative(n):
    count=0
    while n>1:
        if n%2 == 0 : 
            n //= 2
            count += 1
        else :
            n = (3*n+1)//2
            count += 2
    return count

还有一个无堆栈的缓存版本：

def countchain_iterative_cache(n):
    count = 0
    n0=n
    while n not in cache:
            count += 1
            if n%2 == 0 : n //= 2
            else : n = 3*n+1
    count+= cache[n]
    n=n0
    while n not in cache:
            cache[n]=count
            count-=1
            if n%2 == 0 : n //= 2
            else : n = 3*n+1
    return cache[n]

如果缓存在函数中，则缓存机制不起作用。一定是全球范围内以加快通话速度。

以下是计时：

%time  for i in range(1,10**4) : countchain_iterative(i)
cache={1:0}
%time  for i in range(1,10**4) : countchain_iterative_cache(i)
cache={1:0}
%time  for i in range(1,10**4) : countchain_recursive_cache(i)
%time  for i in range(1,10**4) : countChain_morcedist(i)

# respectively :
Wall time: 490 ms
Wall time: 80 ms
Wall time: 54 ms
Wall time: 3.82 s

但是最有效的方法是如果您只想要一个计数链，则为未缓存的迭代方法：

%time countchain_iterative(10**10_000)  
Wall time: 6.37 s
Out[381]: 177856

最后，我猜想您永远不会在迭代构造中使快速递归函数崩溃：

%time for i in range(1,10**7): countchain_recursif(i)
Wall time: 1min 8s

Answer 2

您始终可以通过使用堆栈将递归函数转换为迭代函数。这是我的处理方式：

def countChain(n):
    cache = { 1: 0 }
    stack = [n]
    while n not in cache:
      n_curr = stack.pop()

      if n_curr % 2 == 0:
        if n_curr / 2 in cache:
          cache[n_curr] = 1 + cache[n_curr / 2]
        else:
          stack.append(n_curr)
          stack.append(n_curr / 2)
      else:
        if (3 * n_curr + 1) / 2 in cache:
          cache[n_curr] = 3 + cache[(3 * n_curr + 1) / 2]
        else:
          stack.append(n_curr)
          stack.append((3 * n_curr + 1) / 2)

    return cache[n]

将递归函数转换为迭代函数

2 个答案: