leetcode Climbing Stairs

最新推荐文章于 2019-05-04 21:56:13 发布

原创最新推荐文章于 2019-05-04 21:56:13 发布 · 407 阅读

0 ·

CC 4.0 BY-SA版权

leetcode Fighting 专栏收录该内容

133 篇文章

订阅专栏

本文探讨了经典的爬楼梯问题，从错误的理解出发，逐步介绍了递归、动态规划等算法解决方案，并对每种方法进行了详细分析，最终给出了优化后的动态规划实现。

看到此题，首先想到的是递归求解，但是题意理解错了，题中是说需要n 步到达山顶，每一次可以是一步或者两步，而我理解的是n次中每一次可以是一步或者两步

错误的递归代码如下

class Solution {
public:
    int climbStairs(int n) {
        num = 0;
        if(n==0)
            return num;
        climbStairsHelper(n);
        return num;
    }
    
    void climbStairsHelper(int n)
    {
        if(n==0)
        {
            num++;
            return;
        }
        //choose 1 step
        climbStairsHelper(n-1);
        //choose 2 step
        climbStairsHelper(n-1);
    }
    
private:
    int num;
};

正确的递归代码但是超时

class Solution {
public:
    int climbStairs(int n) {
       if(n==0)
        return 0;
       if(n==1)
        return 1;

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

};

一般情况下递归算法超时后，可以利用动态规划来解决，保留中间结果

动态规划的代码如下通过

class Solution {
public:
    int climbStairs(int n) {
       vector<int> result(n+1, 0);
       if(n==0)
        return result[n];
       
       result[0] = 1;
       result[1] = 1;
        
       for(int i = 2; i <= n; ++i)
         result[i] = result[i-1] + result[i-2];
         
       return result[n];
    
    }

};

分析代码注意到，其实每次只用了三个变量

优化后的动态规划代码

class Solution {
public:
    int climbStairs(int n) {
       if(n==0)
        return 0;
       
       int a = 1;
       int b = 1;
       int c = 1;
        
       for(int i = 2; i <= n; ++i)
       {
         c = a + b;         
         a = b;
         b = c;
       }
         
       return c;
    
    }

};