这是我参与更文挑战的第1天，活动详情查看： 更文挑战

原题

爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

**注意：**给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1.  1 阶 + 1 阶 + 1 阶
2.  1 阶 + 2 阶
3.  2 阶 + 1 阶

---

重拳出击

爬楼梯嘛，传说中的经典动态规划题目，简单难度，适合重拳出击。

先确定一下边界条件

• n < 1时候，res = 0；
• n = 1时候，res = 1;

当n > 1时候，需要推导一下状态转移方程，这也是最重要的一步；

状态

台阶一共有n阶。假设现在已经在终点。那么从前一个台阶走上来，根据题目 可以爬 1 或 2 个台阶 会有有两种走法(状态)：

1. 走一个楼梯
2. 走两个楼梯

那么显然啊，n 个阶梯的走法就是 n-1 个楼梯的走法加上 n-2个阶梯走法的和；

假设 dp[n] 为 n 阶楼梯的走法，那么根据上头方案能够得出:

这下，状态转移方程就出现了；

• n < 1时候，dp[0] = 0
• n = 1时候，dp[1] = 1
• n > 1时候，dp[n]=dp[n-1]+dp[n-2]

这就可以按照方程写代码：

    public static int climbStairs(int n) {
        if(n == 0) return 0;
        if(n == 1) return 1;
        if(n == 2) return 2;
        //状态
        int[] dp=new int[n];
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 2;
        //迭代
        for (int i = 3; i < n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n-1];
    }

然后，发现这写出来好像就是个斐波那契数列。

这个代码虽然结果是对的，但是占用空间的会比较高，因为dp数组中的元素有很多的重复计算。比如 :

 dp[20] = dp[19] + dp[18]
 dp[19] = dp[18] + dp[17]
 dp[18] = dp[16] + dp[17]

所以，得进行空间优化，比较容易能发现，这玩意dp[n]只需要用到当前空间的前面两个空间就够了，所有可以，创建两个变量一直替换相加即可

用dp0替换n-2的走法，用dp1替换 n-1的走法。

    public int climbStairs(int n) {
        int dp0=0,dp1=1,res=0;
        for(int i = 1; i <= n; i++) {
            res = dp0 + dp1;
            dp0 = dp1;
            dp1 = res;
        }
        return res;
    }

这么一下来，就算是比较合适的解法了。