精华内容
下载资源
问答
  • 斐波那契算法时间复杂度
    2021-08-07 10:37:43

    Fibonacci线性递归算法时间复杂度分析

    前言

    个人见解,有错误欢迎指正

    铺垫

    计算 Fibonacci 数列第 n n n 项的线性递归算法如下

    /************************************************************************
     * Data Structures in C++
     * ISBN: 7-302-33064-6 & 7-302-33065-3 & 7-302-29652-2 & 7-302-26883-3
     * Junhui DENG, deng@tsinghua.edu.cn
     * Computer Science & Technology, Tsinghua University
     * Copyright (c) 2003-2020. All rights reserved.
     ************************************************************************/
    
    __int64 fib ( int n ) { //计算Fibonacci数列的第n项(二分递归版):O(2^n)
       return ( 2 > n ) ?
              ( __int64 ) n //若到达递归基,直接取值
              : fib ( n - 1 ) + fib ( n - 2 ); //否则,递归计算前两项,其和即为正解
    }
    

    时间复杂度分析:

    • 递归基的时间复杂度 T ( 0 ) = 1 T(0) = 1 T(0)=1 T ( 1 ) = 1 T(1) = 1 T(1)=1
    • 通项: T ( n ) = T ( n − 1 ) + T ( n − 2 ) + 1 , n > 1 T(n) = T(n-1) + T(n-2) + 1, \quad n > 1 T(n)=T(n1)+T(n2)+1,n>1

    问题:如何求出 T ( n ) T(n) T(n) 的解析表达式呢?


    分析

    为了简化问题,不妨设

    S ( n ) = T ( n ) + 1 2 (1) S(n) = \frac{T(n) + 1}{2} \tag{1} S(n)=2T(n)+1(1)

    因此可以得到

    S ( 0 ) = 1 = fib ( 1 ) S ( 1 ) = 1 = fib ( 2 ) S(0) = 1 = \text{fib}(1) \\ S(1) = 1 = \text{fib}(2) S(0)=1=fib(1)S(1)=1=fib(2)

    进而推广到公式(2),成功消去了 T ( n ) T(n) T(n) 通项中讨厌的常数

    S ( n ) = S ( n − 1 ) + S ( n − 2 ) = fib ( n + 1 ) (2) S(n) = S(n-1) + S(n-2) = \text{fib}(n+1) \tag{2} S(n)=S(n1)+S(n2)=fib(n+1)(2)

    下面来计算 S ( n ) S(n) S(n) 的解析表达式,在 n n n 趋于无穷大时,推测

    S ( n ) = k S ( n − 1 ) (3) S(n) = k S(n-1) \tag{3} S(n)=kS(n1)(3)

    将公式(3)代入公式(2) 可得

    S ( n ) = ( 1 + 1 k ) ⋅ S ( n − 1 ) (4) S(n) = \left(1+\frac{1}{k}\right) \cdot S(n-1) \tag{4} S(n)=(1+k1)S(n1)(4)

    又因为 S ( n ) = k S ( n − 1 ) S(n) = k S(n-1) S(n)=kS(n1),得到下面的方程

    k = 1 + 1 k k = 1 + \frac{1}{k} k=1+k1

    方程两边同时乘以 k k k,解得 k = ( 1 + 5 ) / 2 k = (1+\sqrt{5})/2 k=(1+5 )/2。因此公式(3) 变为

    S ( n ) = 1 + 5 2 S ( n − 1 ) (5) S(n) = \frac{1 + \sqrt{5}}{2} S(n-1) \tag{5} S(n)=21+5 S(n1)(5)

    反解公式(1) 并回代到公式(5) 可得

    T ( n ) = 2 S ( n ) − 1 = 2 ⋅ fib ( n + 1 ) − 1 = O ( fib ( n + 1 ) ) = O ( S ( n ) ) = O ( Φ n ) = O ( 2 n ) , Φ = 1 + 5 2 \begin{aligned} T(n) = 2 S(n) - 1 &= 2 \cdot \text{fib}(n+1) - 1 \\ &= O(\text{fib}(n+1)) \\ &= O(S(n)) \\ &= O(\Phi^n) = O(2^n), \quad \Phi = \frac{1 + \sqrt{5}}{2} \end{aligned} T(n)=2S(n)1=2fib(n+1)1=O(fib(n+1))=O(S(n))=O(Φn)=O(2n),Φ=21+5

    原理

    ⚠️ 上面求解 S ( n ) S(n) S(n) 的表达式其实是误打误撞,只能当作初步的估算,不具有一般性

    注意到 S ( n ) S(n) S(n) 本身其实又构成了一个斐波那契序列,由斐波那契序列的极限性质

    lim ⁡ n → + ∞ F n + 1 F n = 1 + 5 2 \lim_{n \rarr + \infty} \frac{F_{n+1}}{F_n} = \frac{1 + \sqrt 5}{2} n+limFnFn+1=21+5

    可以直接得出 S ( n + 1 ) S(n+1) S(n+1) S ( n ) S(n) S(n) 之间是有比例关系的,且比值为 ( 1 + 5 ) / 2 (1 + \sqrt 5) / 2 (1+5 )/2


    扩展

    【1】斐波那契数列,它漂亮的性质让我们着迷——知乎日报
    【2】斐波那契数列的通项公式——自由哲人

    更多相关内容
  • 还跑了实验,但这是我人生中第 次看到有人犯将大数算术运算的复杂度视为 的“错误”了在一个更贴近现实的计算模型中,将两个 位大整数相加需要 的时间,而大整数相乘需要 (暴力算法)或 (FFT)的时间。pyt...

    今天我在timeline上刷到了@Pika369 的这篇文章:https://zhuanlan.zhihu.com/p/165877869​zhuanlan.zhihu.com

    文章挺详细,还跑了实验,但这是我人生中第

    次看到有人犯将大数算术运算的复杂度视为

    的“错误”了

    在一个更贴近现实的计算模型中,将两个

    位大整数相加需要

    的时间,而大整数相乘需要

    (暴力算法)或

    (FFT)的时间。python的乘法使用的是Karatsuba算法

    ,下文简记为

    。可以看出,单纯按照“进行大整数运算的次数”来衡量算法复杂度是极不准确的,还需要考虑到大整数的长度以及算术运算的种类。知道了这点之后,我们可以重新分析一下原文中提到的各个计算Fibonacci数列算法的复杂度,并与实际运行时间进行对照

    算法一:暴力递推

    def F1(n):

    a,b=1,1

    for i in range(n-2): a,b=b,a+b

    return b

    根据fibonacci数的通项公式,我们可以看出第

    个fibonacci数的长度为

    。这里我们做了

    次大数加法,总复杂度为

    时运行时间为1.10s。把递归改成递推解决爆栈问题后跑

    的数据还是小看它了。

    算法零:通项公式法

    经评论区提醒补充分析一下这个,

    从数值计算的角度来说,根据数值分析的知识可知只需要对运算过程中涉及到的实数保留

    位精度就可以了。高精度实数开根可以在

    时间内完成,而exp可以用AGM方法在

    时间内完成

    从符号计算的角度来说,因为域扩张

    是一个有限扩张,所以维护下

    前的系数就可以了

    前的系数一定为0,不会产生精度问题(

    就是一个可怜的工具人)。实际运算和快速幂是等价的。

    这里有用mpfr库写的C++代码,还是很快的,不过我们就不欺负python了。

    算法二:矩阵的快速幂

    import sympy as sym

    def Matrix_fastPower(A,n):

    size = A.shape[0]

    result = sym.eye(size)

    base = A

    power = n

    while power > 0:

    if power % 2 == 1:

    result = result * base

    power = power // 2

    base = base * base

    return result

    def F2(n):

    return Matrix_fastPower(sym.Matrix([[1,1],[1,0]]),n)[1,0]

    把快速幂看成递归的话,递归深度为

    ,大整数的算术运算总次数也为

    。但注意到递归过程中大整数的长度呈几何级数变化

    ,即一次

    位大整数乘法的常数倍。

    时运行时间为81.6s,可以看出算法的常数比较大。

    算法三:Fibonacci的一组恒等式

    。这个算法是Dijkstra在1978年发现的。

    from functools import lru_cache

    @lru_cache(None)

    def F3(n):

    if n == 1 or n == 2:

    return 1

    k = n // 2

    a = F3(k)

    b = F3(k + 1)

    if n % 2:

    return a * a + b * b

    else:

    return a * (2 * b - a)

    复杂度的计算和算法二类似,因为递归过程中大整数的长度呈几何级数变化,总复杂度也为

    时运行时间为5.53s,常数比算法二小了很多。

    注:原文代码在我本机的运行时间为5.71s,并且实际上“预先生成字典”对运行时间并没有什么影响。(与原作者确认过了)

    算法3.1:

    这里以对算法三的一个小改动为例,展示学会正确的复杂度分析可以如何帮助我们优化算法。

    注意到算法三虽然进行了

    次大整数运算,但复杂度的瓶颈为最后一次乘法,这与实验结果是相符的:最后对

    的计算(根据

    的奇偶性需要1~2次乘法,这里为1次)花费了2.42s,占据了总运行时间的44%。可想而知,只要能在最后这次乘法上优化一点常数,总时间也可以被提升一个常数。这时候,我们需要一点关于凑因式分解的初中知识:

    先考虑

    的情形。想法是多递归一层:令

    ,则

    。令

    ,直接用递归式计算的话这里需要一次长度为

    的乘法,以及三次长度为

    的乘法(

    )。但我们可以换一种方法计算多项式的值:令

    ,则

    。这样,长度为

    的乘法被减少到了两次(计算

    )。

    其他情况同理。对于

    对于

    对于

    def F4(n):

    a=F3(n//4)

    b=F3(n//4+1)

    t=a*(2*b-a)

    t1=b*(2*a+b)

    if n%4==0:

    return t*(t1*2-3*t)

    elif n%4==1:

    c=t1-t

    return t*t+c*c

    elif n%4==2:

    return (t1-t)*(t1+t)

    else:

    c=t1-t

    return c*c+t1*t1

    时运行时间为5.05s,仅为算法三的91%。

    (

    时运行时间比为

    时为

    时为

    。)

    最后可以用以上技巧重新实现算法三,将运行时间进一步降低到原来的88%。起到的效果和这篇文章14%(

    为偶数时)。

    def F3_(n):

    if n==0: return 0,1

    a,b=F3_(n//2)

    t=a*(2*b-a)

    t1=b*(2*a+b)

    if n%2==0: return t,t1-t

    else: return t1-t,t1

    def F4_(n):

    a,b=F3_(n//4)

    t=a*(2*b-a)

    t1=b*(2*a+b)

    if n%4==0: return t*(t1*2-3*t)

    elif n%4==1: return t*t+(t1-t)**2

    elif n%4==2: return (t1-t)*(t1+t)

    else: return (t1-t)**2+t1*t1

    注:写文章的时候我不小心用32位python跑的,所以所有运行时间都那么慢。改回64位之后所有瓶颈是乘法的代码都可以快4倍左右,就不改正文了。

    参考

    展开全文
  • Dijkstra算法时间复杂度分析

    万次阅读 多人点赞 2021-02-24 20:35:04
    文章目录Dijkstra算法的思路与关键点Dijkstra算法时间复杂度 之前一直默认Dijkstra算法时间复杂度为 o(n2)o(n^{2})o(n2),没有思考过具体的时间复杂度,今天把这个弄清楚。 Dijkstra算法的思路与关键点 思路:...


    之前一直默认Dijkstra算法时间复杂度为 o ( n 2 ) o(n^{2}) o(n2),没有思考过具体的时间复杂度,今天把这个弄清楚。

    Dijkstra算法的思路与关键点

    • 思路:广度优先 + 松弛
    1. 所有点分为两个集合 S S S T T T S S S最开始只包括源点 s s s,剩余点都位于 T T T S S S集合表示已经计算出最短路径的点集合, T T T表示尚未计算出最短路径的点集合。
    2. 每次从集合 T T T中选出一个与集合 S S S距离最短的点 v v v,将点 v v v加入集合 S S S。通过点 v v v对集合 T T T中的点进行松弛,即更新 T T T中点的最短距离。
    3. 不断重复此步骤2,直至T集合中无法找出与集合 S S S相邻的点。
    • 关键点:每次从 T T T中选出的点,距离源点的距离一定不会被松弛,因此每次选出的点都将加入集合 S S S.。

    Dijkstra算法的时间复杂度

    设图中的节点数为 n n n,边个数为 m m m,平均每个点的边数 k = m / n k=m/n k=m/n

    算法步骤2需要执行 n − 1 n-1 n1次,每次从集合 T T T中选出一个与集合 S S S相距最近的点,具体实现方式有4种。

    • 顺序遍历集合 T T T
    • 使用二叉堆作为优先队列
    • 使用二项堆作为优先队列
    • 使用斐波那契堆作为优先队列

    前提知识:二叉堆,二项堆,斐波那契堆的各种操作时间复杂度
    在这里插入图片描述

    对于Dijkstra算法,给出时间复杂度的计算公式
    ( n − 1 ) ∗ ( T E X T R A C T − M I N + T D E L E T E + T D E C R E A S E − K E Y ∗ k ) (n-1)*(T_{EXTRACT-MIN}+T_{DELETE}+T_{DECREASE-KEY}*k) (n1)(TEXTRACTMIN+TDELETE+TDECREASEKEYk)

    下面对于上述四种方式,分别计算其时间复杂度。

    1. 时 间 复 杂 度 = ( n − 1 ) ∗ ( T E X T R A C T − M I N + T D E L E T E + T D E C R E A S E − K E Y ∗ k ) = ( n − 1 ) ∗ ( n + 1 + k ) = n ∗ ( n + k ) = n 2 + m = n 2 \begin{aligned} 时间复杂度&=(n-1)*(T_{EXTRACT-MIN}+T_{DELETE}+T_{DECREASE-KEY}*k) \\ &=(n-1)*(n+1+k)\\ &=n*(n+k)\\ &=n^{2}+m &=n^{2} \end{aligned} =(n1)(TEXTRACTMIN+TDELETE+TDECREASEKEYk)=(n1)(n+1+k)=n(n+k)=n2+m=n2
    2. 时 间 复 杂 度 = ( n − 1 ) ∗ ( T E X T R A C T − M I N + T D E L E T E + T D E C R E A S E − K E Y ∗ k ) = ( n − 1 ) ∗ ( 1 + log ⁡ n + k ∗ log ⁡ ( n ) ) = n ∗ ( 1 + k ) log ⁡ n = ( n + m ) log ⁡ n \begin{aligned} 时间复杂度&=(n-1)*(T_{EXTRACT-MIN}+T_{DELETE}+T_{DECREASE-KEY}*k) \\ &=(n-1)*(1+\log{n}+k*\log(n))\\ &=n*(1+k)\log{n}\\ &=(n+m)\log{n} \end{aligned} =(n1)(TEXTRACTMIN+TDELETE+TDECREASEKEYk)=(n1)(1+logn+klog(n))=n(1+k)logn=(n+m)logn
    3. 时 间 复 杂 度 = ( n − 1 ) ∗ ( T E X T R A C T − M I N + T D E L E T E + T D E C R E A S E − K E Y ∗ k ) = ( n − 1 ) ∗ ( log ⁡ n + log ⁡ n + k ∗ log ⁡ ( n ) ) = n ∗ ( 2 + k ) log ⁡ n = ( 2 n + m ) log ⁡ n = ( n + m ) log ⁡ n \begin{aligned} 时间复杂度&=(n-1)*(T_{EXTRACT-MIN}+T_{DELETE}+T_{DECREASE-KEY}*k) \\ &=(n-1)*(\log{n}+\log{n}+k*\log(n))\\ &=n*(2+k)\log{n}\\ &=(2n+m)\log{n}\\ &=(n+m)\log{n} \end{aligned} =(n1)(TEXTRACTMIN+TDELETE+TDECREASEKEYk)=(n1)(logn+logn+klog(n))=n(2+k)logn=(2n+m)logn=(n+m)logn
    4. 时 间 复 杂 度 = ( n − 1 ) ∗ ( T E X T R A C T − M I N + T D E L E T E + T D E C R E A S E − K E Y ∗ k ) = ( n − 1 ) ∗ ( log ⁡ n + log ⁡ n + k ∗ 1 ) = n ∗ ( 2 log ⁡ n + k ) = 2 n log ⁡ n + m = n log ⁡ n + m \begin{aligned} 时间复杂度&=(n-1)*(T_{EXTRACT-MIN}+T_{DELETE}+T_{DECREASE-KEY}*k) \\ &=(n-1)*(\log{n}+\log{n}+k*1)\\ &=n*(2\log{n}+k)\\ &=2n\log{n}+m\\ &=n\log{n}+m\\ \end{aligned} =(n1)(TEXTRACTMIN+TDELETE+TDECREASEKEYk)=(n1)(logn+logn+k1)=n(2logn+k)=2nlogn+m=nlogn+m
    展开全文
  • 一、主定理 1、 主要是计算 n_log_b_a 。求出来之后和后面的Fn进行比较,然后按照规则些出结果就行。 2、一句话解释:这两个值哪一个...斐波那契数列(Fibonacci sequence),又称黄金分割数列、因数学家列昂纳多·斐
  • } //快速幂算法才使得复杂度为logn public int[][] pow(int[][] a, int n) { //这里其实是对ret进行了一次初始化,1001其实相当于矩阵中的1,乘其他矩阵等于其他矩阵自身的值 int[][] ret = {{1, 0}, {0, 1}};...

    矩阵分解

    在这里插入图片描述

    class Solution {
        static final int MOD = 1000000007;
    
        public int fib(int n) {
            if (n < 2) {
                return n;
            }
            int[][] q = {{1, 1}, {1, 0}};
            int[][] res = pow(q, n - 1);
            return res[0][0];
        }
        
        //快速幂算法才使得复杂度为logn
        public int[][] pow(int[][] a, int n) {
            //这里其实是对ret进行了一次初始化,1001其实相当于矩阵中的1,乘其他矩阵等于其他矩阵自身的值
            int[][] ret = {{1, 0}, {0, 1}};
            while (n > 0) {
                //判断n是否为奇数,如果为奇数则执行if
                if ((n & 1) == 1) {
                    ret = multiply(ret, a);
                }
                //n向右一位,即除2
                n >>= 1;
                a = multiply(a, a);
            }
            return ret;
        }
    
        public int[][] multiply(int[][] a, int[][] b) {
            int[][] c = new int[2][2];
            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 2; j++) {
                    c[i][j] = (int) (((long) a[i][0] * b[0][j] + (long) a[i][1] * b[1][j]) % MOD);
                }
            }
            return c;
        }
    }
    
    作者:LeetCode-Solution
    链接:https://leetcode-cn.com/problems/fei-bo-na-qi-shu-lie-lcof/solution/fei-bo-na-qi-shu-lie-by-leetcode-solutio-hbss/
    来源:力扣(LeetCode
    展开全文
  • 关于斐波那契数列的简介:斐波那契数列,又称黄金分割数列,指的是这样一个数列:0、1、1、2、3、5、8、13、21、34、……在数学上,斐波纳契数列以如下被以递归的方法定义:F(0)=0,F(1)=1,F(n)=F(n-1)+F(n-2)(n≥2...
  • 斐波那契数列的时间和空间复杂度2.二分法的时间复杂度和空间复杂度 1.算法复杂度算法时间复杂度和空间复杂度合称为算法复杂度。 ​ 时间复杂度时间复杂度是指执行算法所需要的计算工作量; ​ 空间...
  • 斐波那契数的时间复杂度、空间复杂度详解

    万次阅读 多人点赞 2018-05-26 01:00:21
    斐波那契数:斐波那契数列指的是1、1、2、3、5、8、13、21...时间复杂度的O渐进表示:算法语句总的执行次数是关于问题规模N的某个函数,记为f(N),N称为问题的规模。语句总的执行次数记为T(N),当N不断变化时,...
  • 斐波那契数列的时间复杂度

    千次阅读 2021-07-07 21:49:07
    求解斐波那契数列 F(n)={1,n=0,1F(n−1)+F(n−2),n>1F(n) =\left\{ ...有两种常用的算法:递归算法和非递归算法,根据不同算法分析它的时间复杂度。 递归算法 int fibo(int n){ if(n<=1) return 1; retur
  • 时间复杂度,空间复杂度
  • 算法时间复杂度和空间复杂度

    多人点赞 热门讨论 2022-03-05 21:09:08
    1.什么是算法 算法(Algorithm)是对某一特定类型的问题求解步骤的一种描述,是指定的有限序列,字面意思就是用于计算的方法。 1.2算法特性 ...通常用算法复杂度来衡量一个算法的好坏。那么,什么是复杂
  •  斐波那契数列,又称黄金分割数列,指的是这样一个数列:0、1、1、2、3、5、8、13、21、34、……在数学上,斐波纳契数列以如下被以递归的方法定义:F(0)=0,F(1)=1,F(n)=F(n-1)+F(n-2)(n≥2,n∈N*)在现代...
  • 递归算法时间复杂度分析

    万次阅读 多人点赞 2018-09-17 16:16:59
    递归算法时间复杂度分析 时间复杂度: 一般情况下,算法中基本操作重复的次数就是问题规模n的某个函数f(n),进而分析f(n)随n的变化情况并确定T(n)的数量级。这里用‘o’来表示数量级,给出算法时间复杂度。 T...
  • 代码】求斐波那契数列的递归算法(含时间复杂度
  • 斐波那契数列——递归与非递归算法时间复杂度分析
  • 斐波那契数列递归算法时间复杂度、空间复杂度

    千次阅读 多人点赞 2020-03-04 19:28:47
    一.结论 时间复杂度:O(2^n) 空间复杂度:O(n) ...一般算法分析都是使用RAM计算模型,而递归算法主要的时间花销就在于函数调用,也就是下图(2)中的子程序调用以及 return 语句。 三.具体分析 ...
  • 首先斐波拉契数列指的是这样一个数列"0,1,1,2,3,5,8,13......."从第三项开始,每一项都... 也就是每加入一项时间复杂度加2的n次方,这就是递归实现Fibonacci,可以清楚的看到它的时间复杂度高的原因是因为n-..
  • 斐波那契数列时间复杂度

    千次阅读 2019-10-16 19:03:05
    1.时间复杂度 O(2^n) 空间复杂度 O(n) def fib(n): if(n<3): return 1 return f(n-1)+f(n-2) 推导:时间复杂度 f(n) = f(n-1) + f(n-2) 每一层都包含一个加法操作 例如n = 8时,T(n) = 2^0 + 2^1 + 2^2 + 2^...
  • 因此,我在Java中有一个递归方法来获取'n'的斐波纳契数 - 我唯一的问题是:时间复杂度是多少? 我认为这是O(2 ^ n),但我可能会弄错? (我知道迭代更好,但这是一个练习)public int fibonacciRecursive(int n){if(n ...
  • 斐波那契数列:前两项是1,后面的每项是其前两项之和。比如:1 1 2 3 5 8 13… 递归实现: def Fab(n): ...递归算法时间复杂度为(二叉树的节点个数):O()=(2h)-1=2n。空间复杂度为树的高度:h即o(n). ...
  • 欧几里得算法时间复杂度简单分析

    万次阅读 2016-11-28 20:27:41
    前言这个问题是在《数据结构与算法C++描述(第三版中文)》所遇到的,文中给出的迭代次数O(logN)的结果就像是教授所说的“显然”一样高深莫测,有点云里雾里的感觉!在“网罗”了一些资料后,在这里找到了自己想要的...
  • 斐波那契数列-循环3.fib方法的时间复杂度分析4.斐波那契的线性代数解法-特征方程4.算法的优化方向5.后续 1.复杂度 1.什么是算法? 2.如何评判一个算法的好坏? 3.大O表示法(Big O) 1.对数阶的细节 2.常见的复杂度 ...
  • C++算法算法时间复杂度图解

    千次阅读 多人点赞 2019-12-22 16:00:09
    究竟什么是时间复杂度呢?让我们来想象一个场景:某一天,小灰和大黄同时加入了一个公司...... 一天过后,小灰和大黄各自交付了代码,两端代码实现的功能都差不多。大黄的代码运行一次要花100毫秒,内存占用5MB...
  • 斐波那契数列的三种算法以及复杂度

    万次阅读 多人点赞 2017-12-20 22:48:57
    斐波那契数列: f(n)=f(n-1)+f(n-2)(n>2) f(0)=1;f(1)=1; 即有名的兔子繁衍问题 在本篇文章我将会给出三种解法 递归 (1)递归:函数自己调用自己 (2)递归的"缺陷":递归到一定程度,会发生"栈溢出" (3...
  • 算法时间复杂度,用来度量算法的运行时间,记作: T(n) = O(f(n))。它表示随着 输入大小n 的增大,算法执行需要的时间的增长速度可以用 f(n) 来描述。 显然如果 T(n) = n^2,那么 T(n) = O(n^2),T(n) = O(n^3),T...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,529
精华内容 7,811
热门标签
关键字:

斐波那契算法时间复杂度