70. 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶
示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

提示：

1 <= n <= 45

解决方法及思路：

//暴力法1
class Solution {
public:
    int climbStairs(int n) {
        int i,j;
        int num=0;
        for(i=0;i<=n/2;i++)
            for(j=0;j<=n;j++)
                if(2*i+j==n){
                    //这种方法中，有i步是走2节台阶的，有j步是走1节台阶，将他们组合
                    int choices=1;
                    for(int x=0;x<i;x++)
                        choices*=i+j-x;
                    for(int x=0;x<i;x++)
                        choices/=i-x;
                    num+=choices;
                }
        return num;
    }
};

注释部分，将i个走2节台阶和j个走1节台阶的，组合思路：

总共有i+j步，其中i个是走2节台阶的，那么从i+j步中选出i个就可以了。

结果：会超出内存。因为在进行阶乘计算的时候，分子在一定范围内会相当大。

//暴力法2
class Solution {
public:
    int climbStairs(int n) {
        int i,j;
        int num=0;
        if(n%2==0)
            i=n/2;
        else
            i=n/2+1;
        for(;i<=n;i++){
            j=n-i;
            int choices=1;
            for(int x=0;x<j;x++)
                choices*=i-x;
            for(int x=0;x<j;x++)
                choices/=j-x;
            num+=choices;
        }
        return num;
    }
};

思路：假设一共要走i步，那么i必定大于等于n的一半，因此确定i的取值范围，那么这i步中，有j步是走两步的，那么每个2步比1步是多1步的，则i+j=n，即从i个选项中选出j（n-i）个选项走两步，剩下的都是走一步。

结果：也会超出内存。

当采用暴力方法进行愣计算后发现，走35步时，内存绝对支撑不了计算。因此从递归角度出发，最后一步一定是从倒数第二阶或者倒数第一阶踩上来的。 

//递归法
class Solution {
public:
    int climbStairs(int n) {
        int result;
        if(n==1)
            result=1;
        else if(n==2)
            result=2;
        else
            result=climbStairs(n-1)+climbStairs(n-2);//斐波那契数列
        return result;*/
    }
};

思路：将最后两步的方法数相加即可，需设置好初始值。

结果：时间允许的情况下肯定能得出答案，不过会做很多重复计算。因此当n足够大时，会超出时间限制。

 但是从上面的递归法可以看出，将n从1到45排开的话，符合斐波那契数列的特性。

//直接用斐波那契数列构成数组
class Solution {
public:
    int climbStairs(int n) {
        int result[n];
        int i;
        if(n==1)
            return 1;
        else if(n==2)
            return 2;
        else{
            result[0]=1;
            result[1]=2;
            for(i=2;i<n;i++)
                result[i]=result[i-2]+result[i-1];
        }
        return result[i-1];
    }
};

因此可以直接用斐波那契数列构成一个数组，不会造成递归调用函数，可以大大节省时间。

思路：定义一个长度为n的数组，第i个元素即为i个台阶的步数方法值，计算出第n个元素的值，即为所得。

结果：成功。