Java实现走楼梯算法《每日随机一题》

• 设跳n个台阶有f(n)种方法，

• 爬1个：1种

• 爬2个：2种

• 爬n个：面临两种选择：

• （1） 第一次爬1个，此时剩余n-1个台阶，有f(n-1)种方法

• （2） 第一次爬2个，此时剩余n-2个台阶，有f(n-2)种方法

• 所以f(n) = f(n-1) + f(n-2)

下面是三种实现方式

public class ClimbStairs {
    /**
     * 递归实现是我能想到最简单的方式，但是时间老是超出限制
     * 时间复杂度 2^n
     *
     * @param n
     * @return
     */
    public static int climbStairsDiGui(int n) {
        if (n >= 0 && n <= 2) {
            return n;
        } else {
            return climbStairsDiGui(n - 1) + climbStairsDiGui(n - 2);
        }
    }


    /**
     * 直接把表达式换成for循环，其实就是递归的for循环版本
     * 动态规划：时间复杂度n
     *
     * @param n
     * @return
     */
    public static int climbStairsDongTai(int n) {
        if (n >= 0 && n <= 2) {
            return n;
        }
        int left = 1;
        int right = 2;
        int total = 0;
        for (int i = 3; i <= n; i++) {
            total = right + left;
            left = right;
            right = total;
        }
        return total;
    }


    /***
     * 也许上面第二个你看不出来是动态规划，那我们换一种动态规划的实现方式
     * @param n
     * @return
     */
    public static int climbStairsDongTaiShuzu(int n) {
        if (n >= 0 && n <= 2) {
            return n;
        }
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 2;
        //dp[i]是第N层楼梯有多少方案
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];

        }
        return dp[n];
    }

    public static void main(String[] args) {
        System.out.println(climbStairsDiGui(44));
        System.out.println(climbStairsDongTai(44));
        System.out.println(climbStairsDongTaiShuzu(44));
    }
}