斐波那契数列

时间限制：1秒 空间限制：32768K

题目描述：
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。n<=39。

1、递归实现，效率很低
时间复杂度：n的指数增长

int Fibonacci(int n) {
        if(n > 39 || n < 0)
            return -1;
        if(n == 0 || n == 1)
            return n;
        else
            return Fibonacci(n-1) + Fibonacci(n-2);
    }

2、用数组实现，记录之前的数，便于后面查找使用。
时间复杂度：$O(n)$

int Fibonacci(int n) {
        if(n > 39 || n < 0)
            return -1;
        int* array = new int[n+1](); // vector<int > array(n+1);
        if(n == 0 || n == 1)
            return n;
        array[0] = 0;
        array[1] = 1;
        int i = 2;
        while(i < n+1)
        {
            array[i] = array[i-1] + array[i-2];
            i++;
        }
        return array[n];
    }
/*
运行时间：3ms

占用内存：480k

*/

或者只保留最后三个斐波那契数

int Fibonacci(int n) {
        if(n > 39 || n < 0)
            return -1;
        int* array = new int[3]();
        if(n == 0 || n == 1)
            return n;
        array[0] = 0;
        array[1] = 1;
        n = n-2;
        while(n>=0)
        {
            array[2] = array[0] + array[1];
            array[0] = array[1];
            array[1] = array[2];
            n--;
        }
        return array[2];
    }
/*
运行时间：3ms

占用内存：467k
*/

应用场景：跳台阶
一只青蛙一次可以跳一级阶梯，也可以一次跳两级阶梯。求该青蛙跳上一个n级阶梯总共有多少中跳法？

分析：
如果只有一级阶梯，则只有1种方法，记f(1) = 1
如果只有两级阶梯，第一种：每次跳一阶；第二种：一次跳两阶。则有2种方法，记f(2) = 2
如果n>2，考虑第一步跳一阶，则后面需要跳(n-1)级阶梯，有f(n-1)种方法；若第一步跳两阶，则后面还需要跳(n-2)级阶梯，有f(n-2)种方法；那么跳n级阶梯，总计f(n) = f(n-1) + f(n-2)种方法

int jumpFloor(int number) {
        if(number <= 0)
            return -1;
        if(number == 1 || number == 2)
            return number;
        long long a1 = 1;
        long long a2 = 2;
        long long a = 0;
        number = number - 2;
        while(number)
        {
            a = a1 + a2;
            a1 = a2;
            a2 = a;
            number--;
        }
        return a;
    }

应用场景：变态跳台阶
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

int jumpFloorII(int number) {
        if(number <= 0)
            return -1;

        vector<long long > array(number+1);
        long long temp = 0;
        for(int i=0; i<number+1; i++)
        {
            if(i==0)
            {
                array[i] = 1;
                continue;
            }
            if(i==1)
            {
                array[i] = 1;
                continue;
            }
            for(int j=0; j<i; j++)
            {
                temp += array[j];
            }
            array[i] = temp;
            temp = 0;
        }
        return array[number];
    }
    /* 
    运行时间：4ms

    占用内存：504k
    */

应用场景3
题目描述
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

分析：记有f(n)种方法
第一块摆放的方式
1、竖着放：剩下的2*(n-1)有f(n-1)种方法
2、横着放：横着放的上方或者下方必然也是横向放置，剩下的2*(n-2)有f(n-2)种方法
因此：f(n) = f(n-1) + f(n-2)

int rectCover(int n) {
        if(n < 0)
            return -1;
        int* array = new int[3]();
        if(n==0 || n == 1 || n == 2)
            return n;
        array[0] = 1;
        array[1] = 2;
        n = n-2;
        while(n>0)
        {
            array[2] = array[0] + array[1];
            array[0] = array[1];
            array[1] = array[2];
            n--;
        }
        return array[2];
    }
    /*
    运行时间：6ms

    占用内存：480k
    */