[leetcode]爬楼梯的递归和非递归方法

【Description】

You are climbing a stair case. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

【分析】

利用枚举抽象出一般表达式

当n=0时，f(n)=1

n=1,f(n)=1

n=2,f(n)=2

n=3,fn=3

n=4,fn=5

f(2)=f(1)+f(0)

f(3)=f(2)+f(1)

f(4)=f(3)+f(2)

.......

f(n)=f(n-2)+f(n-1)

从上面分析可以归纳出一般表达式：

进而可以很容易写出递归算法：

class Solution {
public:
    int climbStairs(int n) {
        //f(n)=f(n-2)+f(n-1)
        if (n == 0) {
            return 0;
        }
        
        if (n == 1) {
            return 1;
        }
        
        if (n == 2) {
            return 2;
        }

        return climbStairs(n - 1) + climbStairs(n - 2);
    }
};

但是上面的方法有一个缺点，那就是重复计算很多，导致耗时很长，下面的算法保存了中间结果，如果已经计算过了，那么直接返回中间结果值，如果没有，再进行递归计算，并把结果保存起来。

实现方法二

class Solution {
public:
    int climbStairs(int n) {
        //f(n)=f(n-2)+f(n-1)
        if (n == 0) {
            return 0;
        }
        
        if (n == 1) {
            return 1;
        }
        
        if (n == 2) {
            return 2;
        }
        
        if (res.size() >= (n-2)) {
            return res.at(n - 3);
        }
        
        res.push_back(climbStairs(n - 1) + climbStairs(n - 2));
        return res.back();
        //return climbStairs(n - 1) + climbStairs(n - 2);
    }
    
private:
    vector res;
};

实现方法二虽然避免了重复计算，但是终归还是通过递归实现的，如果通过非递归的方法实现呢？通过上面的分析可以看到，其实交换值得方式就可以迭代得到下一个值，因此，非递归的实现方法如下：

class Solution {
public:
    int climbStairs(int n) {
        //f(n)=f(n-2)+f(n-1)
        if (n <= 1) {
            return 1;
        }
        
        int nCur,nPrev,nPrevP;
        nPrevP = 1;
        nPrev = 1;
        for (int i = 2; i <= n; ++i) {
            nCur = nPrev + nPrevP;
            nPrevP = nPrev;
            nPrev = nCur;
        }
        
        return nCur;
    }
};