Question

我有这个面试练习问题：

存在一个具有N步的楼梯，您可以从一组正整数X上爬任意步数吗？例如，如果X = {1、3、5}，则您一次可以爬1、3或5步。

我得到了以下实现，它似乎可以工作。

我对自己的方法有一些疑问：

1。此段代码的Big-O表示法是什么？

2。考虑到复杂性，是否会有更好的方法？

def stairA(N,X):

    print("begin")
    print(N)
    print(X)
    print(len(X))
    print("end")
    total=0

    if(len(X)==0):
        print("space_Z")
        return 0

    if (len(X)>0):
        if(X[len(X)-1]>N):
            print("space_A")
            newlist = [k for k in X if k < X[len(X)-1]]
            stairA(N,newlist) #step size greater than stair number
            #stairA(N,X[:len(T)-1]) #step size greater than stair number
        if (N==1):
            if(1 in X):
                print("space_B")
                return 1

        if (N==0):
            print("space_X")
            return 1
        if (N<0):
            print("space_Y")
            return 0


        for ind,ele in enumerate(X):                          
            a=N-ele    

            stairA(a,X)#what first step we take
            total = total + stairA(a,X)#what first step we take

    return total

结果：

1+1+1+1

1+2+1

1+1+2

1+3

2+1+1

2+2

3+1

Y=[3,1,2]
Y.sort()
print(Y)
stairA(4,Y)

Answer 1

递归，因为这是f（N）= f（n-1）+ f（n-2）+ ....

def staircase(n, X):
        if n < 0:
            return 0
        elif n == 0:
            return 1
        else:
            return sum(staircase(n - x, X) for x in X)

动态编程：

def staircase(n, X):
    cache = [0 for _ in range(n + 1)]
    cache[0] = 1
    for i in range(1, n + 1):
        cache[i] += sum(cache[i - x] for x in X if i - x >= 0)
    return cache[n]

我不知道为什么递归O（| X | ** N）而动态的是O（N * | X |）

线性组合python上的递归

1 个答案: