Codility FibFrog 算法 - 将时间复杂度从 O(N * log(N) ** N) 提高到 O(N*log(N)) [重复]

Question

我正在尝试解决 Codility FibFrog 问题，我想出了以下解决方案：

def jumps_from(position, fb, A): 
    paths = set([])
    for i in fb: 
        newPos = position + i
        if newPos == len(A):
            return set([-1])
        elif newPos < len(A):
            if A[newPos] == 1: 
                paths.add(newPos)
        else: break
    return paths
            
def solution(A):
    if len(A) < 3: return 1 
    fibonaccis = fibonacci(len(A))
    if len(A) + 1 in fibonaccis: return 1
    paths = set([-1])
    steps = 0
    while True:
        paths = set([idx for pos in paths for idx in jumps_from(pos, fibonaccis, A)])
        if len(paths) == 0: return -1
        if -1 in paths: 
            return steps + 1
        steps += 1
    return steps 

def fibonacci(N): 
    arr = [0] * (N + 2)
    arr[1] = 1
    for i in range(2, N + 2): 
        arr[i] = arr[i-1] + arr[i-2]
    return dict.fromkeys(arr[2:], 1)

Codility 将其运行时检测为O(N * log(N) ** N)。

Codility 报告：https://app.codility.com/demo/results/trainingJV7YAC-G3B/

我将此与以下solution 进行比较，后者在 Codility 上的得分为 100%，运行时为 O(N * log(N))：

def gen_fib(n):
    fn = [0,1]
    i = 2
    s = 2
    while s < n:
        s = fn[i-2] + fn[i-1]
        fn.append(s)
        i+=1
    return fn

def new_paths(A, n, last_pos, fn):
    """
    Given an array A of len n.
    From index last_pos which numbers in fn jump to a leaf?
    returns list: set of indexes with leaves.
    """
    paths = []
    for f in fn:
        new_pos = last_pos + f
        if new_pos == n or (new_pos < n and A[new_pos]):
            paths.append(new_pos)
    return paths


def solution(A):
    n = len(A)
    if n < 3:
        return 1

    # A.append(1) # mark final jump
    fn = sorted(gen_fib(100000)[2:]) # Fib numbers with 0, 1, 1, 2..  clipped to just 1, 2..
    # print(fn)
    paths = set([-1]) # locate all the leaves that are one fib jump from the start position.

    jump = 1
    while True:
        # Considering each of the previous jump positions - How many leaves from there are one fib jump away
        paths =  set([idx for pos in paths for idx in new_paths(A, n, pos, fn)])

        # no new jumps means game over!
        if not paths:
            break

        # If there was a result in the new jumps record that
        if n in paths:
            return jump
            
        jump += 1

    return -1

我不确定为什么我的解决方案在运行时会有所不同，因为方法完全相同 - 计算您可以从 -1 跳转到的所有索引，然后计算您可以从新位置跳转到的所有索引，直到你到达河的另一边，否则找不到新的位置。

Answer 1

请参考我previous answer中的第一点。

如果 len(A) = 100000，您正在计算 100003 个斐波那契数，而我们只需要小于 100k 的斐波那契数，即

当前的fibonacci 函数仍然返回N 斐波那契数，而不是仅仅返回小于N 的斐波那契数。对于N=100k，应该只有 25 个数字，而不是超过 100k。

请将您的 fibonacci 函数更新为此 -

def fibonacci(N):
    arr = [1, 1]
    while arr[-1] < N:
        arr.append(arr[-1] + arr[-2])
    return dict.fromkeys(arr[1:], 1)

我刚刚在本地运行了一个测试，看起来你的 fibonacci 函数需要大约 1 秒来生成前 100k 斐波那契数，这就是它可能无法通过性能测试的原因，即使你的其余代码是最佳。我认为您应该能够在更正 fibonacci 函数后使用所需的性能限制来清除它。