70. Climbing Stairs（python+cpp）

题目：

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?
Note: Given n will be a positive integer.
Example 1:

Input: 2 
Output: 2 
Explanation: 
There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps 

Example 2:

Input: 3 
Output: 3 
Explanation: There are three ways to climb to thetop.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

解释：
斐波那契数列。动态规划经典题目。可以用递归做也可以用循环做，递归做会重复计算所以尽量不要递归，循环做的时候，由于之和前两个状态有关，所以可以只用两个标量即可，不一定非要用一个数组保存结果。
循环解法，用数组保存，python代码：

class Solution:
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        #循环解法，用数组
        dp=[0]*(n+1)
        dp[0]=1
        dp[1]=1
        for i in range(2,n+1):
            dp[i]=dp[i-2]+dp[i-1]
        return dp[n]

用两个变量即可，python代码：

class Solution:
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        #循环解法，用两个变量
        if n==0 or n==1:
            return 1
        first,second=1,1
        for i in range(2,n+1):
            first,second=second,first+second
        return second

递归会超时，因为会重复计算比如说，计算(n-1)的又把(n-2)计算了一遍，没有充分利用递归的结果，python代码：

class Solution:
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        #疯狂的递归
        if n==0 or n==1:
            return 1
        return self.climbStairs(n-2)+self.climbStairs(n-1)

c++代码：

class Solution {
public:
    int climbStairs(int n) {
      if (n == 0 || n == 1)
      return 1;
    int pre = 1;
    int current = 1;
    for (int i = 2; i <= n; i++) {
      int temp = current + pre;
      pre = current;
      current = temp;
    }
    return current;
    }
};

总结：
对于递归的问题，用循环（数组保存）有时候会更快，而且如果需要的前面的状态是很少的而且前面的信息在最后不再需要的话，可以只用少量变量保存临时结果。