Climbing Stairs 爬楼梯 @LeetCode

最新推荐文章于 2024-11-13 21:22:24 发布

原创最新推荐文章于 2024-11-13 21:22:24 发布 · 2.5k 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 同时被 2 个专栏收录

153 篇文章

订阅专栏

LeetCode专栏

148 篇文章

订阅专栏

本文探讨了经典的爬楼梯问题，使用斐波那契数列的递归与动态规划方法来计算达到楼顶的不同方式数量。通过递归加动态规划的方式有效避免了重复计算，提高了算法效率。

题目：

爬楼梯，每次可以爬1个或2个台阶，问有多少种不同的方法到达顶端

思路：

斐波那契，递归

package Level2;

import java.util.Arrays;

/**
 * Climbing Stairs
 * 
 *  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?if
 *
 */
public class S70 {

	public static void main(String[] args) {
		System.out.println(climbStairs(1));
	}
	
	public static int climbStairs(int n) {
		// dp数组，用来保存结果，可以适当开大一些
        int[] dp = new int[n+5];		
        Arrays.fill(dp, -1);
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 2;
        return rec(n, dp);
    }
	
	// 递归+dp
	private static int rec(int n, int[] dp){
		if(dp[n] != -1){
			return dp[n];
		}else{
			dp[n] = rec(n-1, dp) + rec(n-2, dp);
			return dp[n];
		}
	}

}

public class Solution {
    public int climbStairs(int n) {
        if(n == 0){
            return 0;
        }
        if(n == 1){
            return 1;
        }
        if(n == 2){
            return 2;
        }
        int[] ways = new int[n+1];
        ways[0] = 0;
        ways[1] = 1;
        ways[2] = 2;
        for(int i=3; i<=n; i++){
            ways[i] = ways[i-1] + ways[i-2];
        }
        return ways[n];
    }
}