LeetCode--509--斐波拉契数【C++、递归、优化】

萌新记录~多多指教 😃
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fibonacci-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
本文还参照了博主 labuladong的题解思路！讲解的非常清晰！
题目描述：
斐波那契数，通常用 F(n)表示，形成的序列称为斐波那契数列。
该数列由 0和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
给定 N，计算 F(N)。

示例 1：
输入：2
输出：1
解释：F(2) = F(1) + F(0) = 1 + 0 = 1.

示例 2：
输入：3
输出：2
解释：F(3) = F(2) + F(1) = 1 + 1 = 2.

示例 3：
输入：4
输出：3
解释：F(4) = F(3) + F(2) = 2 + 1 = 3.

提示：
0 ≤ N ≤ 30

解法1 自顶向下 暴力递归

思路：
首先最笨的办法当然是递归啦！代码非常简单，但是通过画出它的递归树，我们可以发现进行了非常多的重复运算！
就是说想要计算原问题f(20)，我就得先计算出⼦问题f(19)和f(18) ，然后要计算f(19)，就要先算出⼦问题f(18)和 f(17) ，
以此类推。最后遇到f(1)或者f(2) 的时候，结果已知，就能直接返回结果，递归树不再向下⽣⻓了。
其次，由于使用的是递归，它的时间复杂度 = 子问题个数 * 解决一个子问题需要的时间。
⼦问题个数，即递归树中节点的总数。显然⼆叉树节点总数为指数级别，所以⼦问题个数为 $O(2^N)$。
解决⼀个子问题的时间，在本算法中，没有循环，只有fib(n - 1) + fib(n - 2)⼀个加法操作，时间为 O(1)。
它的时间复杂度达到了$O(2^N)$指数级别!!!

class Solution {
public:
    int fib(int N) {
        if (N <= 1) 
        {
            return N;
        }
        return fib(N-1) + fib(N-2);
    }
};

解法2 自顶向下 减少复杂度

通过上述分析，我们可以构建一个数组用来作为“备忘录”。先将数组全部初始化为0。
然后用来存放已经算过的F[n]的值。然后在函数中加入判断，是否已经算过。从而减少子问题的个数（即递归图中节点的个数）。
在本算法中，节点数减少到了N个，而且每个子问题解决没有循环，所以时间复杂度为O(N)。
此外还需要注意的是这种方法是 自顶向下的。
啥叫**「自顶向下」？注意我们刚才画的递归树（或者说图），是从上向下延伸，都是从⼀个规模较⼤的原问题⽐如说 f(20)，向下逐渐分解规模，直到 f(1) 和 f(2) 触底，然后逐层返回答案，这就叫「⾃顶向下」。
啥叫「自底向上」？**反过来，我们直接从最底下，最简单，问题规模最⼩的f(1)和f(2) 开始往上推，直到推到我们想要的答案 f(20)，这就是动态规划的思路，这也是为什么动态规划⼀般都脱离了递归，⽽是由循环迭代完成计算。

class Solution {
public:
    int fib(int N) {
       
       if(N<1)
       return 0;

       int memo[N+5];//小细节：定义数组时大几个空间
       memset(memo,0,sizeof(memo));
       return helper(memo,N);
    }
    int helper(int memo[],int N)
    {
        if(N==1 || N==2)
           return 1;
        if(memo[N]!=0)
           return memo[N];
        memo[N]=helper(memo,N-1)+helper(memo,N-2);
        return memo[N];
    }
};

解法3 自底向上 dp数组迭代写法

从以下代码可以看出，算法时间复杂度为O(N) 空间复杂度也为O(N)

class Solution {
public:
    int fib(int N) {
        vector<int> dp(N+10,0);
        dp[0]=0;
        dp[1]=dp[2]=1;
        if(N>=3)
        {
            for(int i=3;i<=N;i++)
               dp[i]=dp[i-1]+dp[i-2]; //自底向上，迭代
        }
        return dp[N];
    }
};

其实还可以在空间上进行优化，因为F[N]只与前两个状态F[N-1] 和F[N-2]有关，
因此不用全部保存所有的F[N],只保存前两个状态就行。空间复杂度为O(1),仅仅使用了sum,a1,a2;

class Solution {
public:
    int fib(int N) {
         if(N==1 || N==2)
            return 1;
         if(N==0)
            return 0;
         int a1=1,a2=1,sum=0;
        for(int i=3;i<=N;i++)
            {  sum = a1 + a2;
               a1 = a2;
               a2 = sum;
            }
        return sum;
    }
};