LeetCode 70. Climbing Stairs [Easy]

发表于 更新于 分类于 ， 阅读次数：

题目来源：https://leetcode.com/problems/climbing-stairs

题目难度：Easy

题目

You are climbing a staircase. It takes n steps to reach the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Example 1:

1
2
3
4
5
Input: n = 2
Output: 2
Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps

Example 2:

1
2
3
4
5
6
Input: n = 3
Output: 3
Explanation: There are three ways to climb to the top.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

思路

如果 n == 0，那么方式为 0 种。

如果 n == 1，那么方式为 1 种。

如果 n == 2，那么方式为 2 种，一种是走两次 1 步，使用序列表示就是 [1, 1]，还有一种就是直接走 2 步，使用序列表示就是 [2]。

如果 n == 3，那么有 3 种，[1, 1, 1]、[1, 2]、[2, 1]。

实际上就是要求，找到所有和为 n 的序列，且序列中只能出现 1 和 2。只要两个序列不相同，那么就可以看作是两种不同的方式。

对于 n > 2 的情况，我们可以把问题分为，走到 n-1 和 走到 n-2 时分别有多少种方式？即，序列的最后一步我们已经确定了，[?, 1] 和 [?, 2]，我们把走到 n-1 和走到 n-2 的方式数加起来，就是走到 n 的总方式。

解答1[Java]：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Solution {
    public int climbStairs(int n) {
        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];
    }
}

思路

动态规划。

解答2[Java]：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Solution {
    public int climbStairs(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 third;
    }
}

思路

斐波那契数。

比上一个算法优化的地方在于空间复杂度由 $O(n)$ 变为 $O(1)$。