动态规划 跳台阶问题的三种解法

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 the tNop.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step


这个题很显然是用动态规划的做法，人在跳最后一步时，有两种可能，人可能跳一个台阶，也可能跳两个台阶，如果说n个台阶的走法是F(n),那么F(n) = F(n-1) + F(n-2),当n=1时，F(n) = 1,当n = 2时，F(n) = 2;

public int climbStairs1(int n) {
		if (n <= 0)
			return -1;
		else if (n == 1)
			return 1;
		else if (n == 2)
			return 2;
		else
			return climbStairs1(n - 1) + climbStairs1(n - 2);
	}

这种解法时间复杂度很糟糕，在编译器中，每次递归计算的值都没有被保存下来，不建议采用。为了每次递归计算的值保存下来，我们创建一个空间大小为n的数组dp[]，空间和时间复杂度都是O(n)。

public int climbStairs2(int n) {
        if (n <= 0)
            return -1;
        else if (n == 1)
            return 1;
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++)
            dp[i] = dp[i - 1] + dp[i - 2];
        return dp[n];
    }

在计算的过程中我们发现，dp[]数组满足斐波那契数列关系，可以利用这一特点只定义三个变量，由此来节省空间复杂度，使得空间复杂度优化到O(n).

public int climbStairs3(int n) {
        if (n == 1)
            return 1;
        int first = 1;
        int second = 2;
        for (int i = 3; i <= n; i++) {
            int third = first + second;
            first = second;
            second = third;
        }
        return second;
    }