【Leetcode】爬楼梯

问题：

爬n阶楼梯，每次只能走1阶或者2阶，计算有多少种走法。

暴力计算+记忆化递归。

从位置 i 出发，每次走1阶或者2阶台阶，记录从位置 i 出发到目标 n 所有的走法数量，memoA[i] 。记录的数据可以重复使用，避免冗余计算。

时间复杂度：O(n)。每次计算从 i 位置出发到终点 n 的走法，共计算 n 次，即树形递归的大小为n。

空间复杂度：O(n)。使用了长度为 n 的数组。

clock_t start1, end1;

class Solution {
public:
    int climbStairs(int n) {

        int memo[n+] = {};

        start1 = clock();
        int result = climb_stairs(, n, memo);
        end1 = clock();

        cout << "cost time = " << (double)(end1 - start1) / CLOCKS_PER_SEC << endl;

        return result;
    }

    int climb_stairs(int i, int nums, int memoA[]) {

        if (i > nums)
            return ;

        if (i == nums)
            return ;

        if (memoA[i] > )
            return memoA[i];

        memoA[i] = climb_stairs(i+, nums, memoA) + climb_stairs(i+, nums, memoA);        

        return memoA[i];
    }
};

动态规划

动态规划的关键步骤在于构建递归函数。由于第n级阶梯可由第n-1级（跨一步）和第n-2级（跨两步）到达。记 f(n) 为到达第n级阶梯的方案数量，则有递归函数 f(n) = f(n-1)+f(n-2).

1）动态规划第一种实现方法：

时间复杂度：O(2^n)。其运算过程就是一个完全二叉树的展开，共有 2^(n-2)+1 个节点，即递归运算了 2^(n-2)+1 次。

空间复杂度：O(n)。递归深度达到n层。

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

        int sumMethod = climbStairs(n-) + climbStairs(n-);

        return sumMethod;
    }
};

2）动态规划第二种实现方法：

时间复杂度：O(n)

空间复杂度：O(n)

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

        int memo[n+] = {};
        memo[] = ;
        memo[] = ;

        for(int i = ; i <= n; ++i) {
            memo[i] = memo[i-] + memo[i-];
        }

        return memo[n];
    }
};

斐波那契数

将动态规划的第二种实现方法进行修改。第一项为1，第二项为2，斐波那契数的计算公式如下：

fib(n) = fib(n-1)+fib(n-2)。

时间复杂度：O(n)

空间复杂度：O(1)

还存在时间复杂度为 O(log(n)) 的算法，其核心思想为直接找到第n个斐波那契数，而非进行遍历计算。

这就是算法的魅力。从暴力求解开始，逐步优化算法流程，砍掉冗余的计算步骤，尽可能去除遍历步骤。最终达到提升时间复杂度和空间复杂度的目的。