动态规划能节省多少时间

测试题目如下:
给你一个数组,然后指定一个位置,比如10.
然后你从前10个数中,自己选择任意几个数,要求选的数不能相邻.
最后算出前10个数中能组成的最大值是多少.

import numpy as np
import time
arr = np.random.randint(0,999,40,np.int_)
print(arr)
#递归写法
def rec_opt(arr,i):
    if i == 0:
        return arr[i]
    if i == 1:
        return arr[i]
    else:
        #递归自己
        A = rec_opt(arr,i-2)+arr[i]
        B = rec_opt(arr,i-1)
        return max(A,B)


#动态规划写法
def dp_opt(arr,i):
    opt = np.zeros(len(arr))
    opt[0] = arr[0]
    opt[1] = max(arr[0],arr[1])
    for i in range(2,len(arr)):
        A = opt[i-2]+arr[i]
        B = opt[i-1]
        opt[i] = max(A,B)
    #该选哪一个
    return opt[len(arr)-1]

# 测试数组长度40个
start_time = time.time()
print(rec_opt(arr,39))
print("用时为：%0.2f s" % (time.time() - start_time))
# 测试数组长度40个
start_time = time.time()
print(dp_opt(arr,39))
print("用时为：%0.2f s" % (time.time() - start_time))

选择数组长度为40的情况下,差距很大.但是无法看出有几倍差距,因为动态规划用时0秒

[308 239 945 796  18 379 468 456 847 423 282  21 528 228 396 268 513 415
 781 371 802 389 393 892  83 777 936 253 293 925 439  74 222 473 387 570
 418 708 178  79]
10639
用时为：26.48 s
10639.0
用时为：0.00 s

当数组长度为50时,递归直接凉凉,半天不出结果,索性就直接测试dp的天花板
直接数组内的数值怼到很大,长度老长

import numpy as np
import time
arr = np.random.randint(0,999999999,10000000,np.int_)
print(arr)

#动态规划写法
def dp_opt(arr,i):
    opt = np.zeros(len(arr))
    opt[0] = arr[0]
    opt[1] = max(arr[0],arr[1])
    for i in range(2,len(arr)):
        A = opt[i-2]+arr[i]
        B = opt[i-1]
        opt[i] = max(A,B)
    #该选哪一个
    return opt[len(arr)-1]

start_time = time.time()
print(dp_opt(arr,9999999))
print("用时为：%0.2f s" % (time.time() - start_time))

2934337680832034.0
用时为：3.20 s

dp完爆递归