田鸡总是被被要求跳台阶，我想，他一定很累的！

一只田鸡一次可以跳上1级台阶，也可以跳上2级台阶。求该田鸡跳上一个 n 级的台阶总共有若干种跳法？

对于这样的问题，n小大由之，若是n很小，我们可以直观暴力拆解就可以获得谜底，然则若是n很大，那么这个问题就升级了。

一样平常处理问题，我们最直接的思绪，可能就是分治，将大问题拆解为小问题，分而解决。

在此，也不破例。

首先我们知道田鸡一次能跳一级或者两级。

假定最后一跳跳一级，则剩余n-1个台阶，则问题化为解决跳上n-1个台阶的问题。

假定最后一跳跳两级，则剩余n-2个台阶，则问题化为解决跳上n-2个台阶的问题。

以是归总起来，总的可能的跳法为（n-1）个台阶和（n-2）个台阶问题的总和。

我们假定解决方案为f(n)，则f(n) = f(n-1) + f(n-2) ，这里我们假定n是大于2的。

当n = 1 时，田鸡跳一级即可，f(1) = 1。

当n = 2 时，田鸡可以连跳两个一级或者跳一个两级，f(2) = 2。

考察f(n) = f(n-1) + f(n-2) 公式，你们首先想到的是什么？对的，是递归，级联求解：

 public static long jump(int n) {
        if (n < 3) {
            return n;
        }

        return jump(n - 1) + jump(n - 2);
    }

我们以图像化展示一下这个历程：

图中以相同颜色标识了递归历程中会发生重复盘算的节点。

重复是一种算力和资源不必要的虚耗，我们可以对此举行优化：

对于上述的递归运算，我们可以看到，是由后至前盘算的，也即从f(n)->f(1)。也就是我们需要知道向前的每一个位置的方案效果。我们换个偏向，早年至后延续盘算出每个位置的方案，则最后的位置即为我们所要的效果，同时也可以规避重复盘算的问题：

代码实现：

public static long jumpx(int n) {
        if (n < 3) {
            return n;
        }

        //每个位置存储下标（i + 1）个台阶的可能效果f(i + 1)，以是n个台阶即为盘算f(n - 1)
        Long[] arr = new Long[n];
        arr[0] = 1L; //一个台阶
        arr[1] = 2L; //两个台阶
        //从 n = 3 最先循环盘算
        for (int i = 2; i < n; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        return arr[n - 1];
    }

我们通过增添一个长度为n的数组空间占用来换取算法耗时优化，相对于递归算法，耗时上有数量级差异。

耗时减少了，然则空间似乎虚耗了，实在，也没必要存储每一个方案的效果，我们只需要知道【前一个】，【前两个】以及【当前】的几个变量。

革新如下：

public static long jumpy(int n) {
        if (n < 3) {
            return n;
        }

        //第三节台阶方案值f(3) = f(2) + f(1) = 1 + 2 = 3;
        long preTwoCount = 1; //一个台阶
        long preOneCount = 2; //两个台阶
        long stepsCount = 0; //n个台阶
        //从 n = 3 最先循环盘算
        for (int i = 2; i < n; i++) {
            stepsCount = preOneCount + preTwoCount;
            preOneCount = stepsCount;
            preTwoCount = preOneCount;
        }
        return stepsCount;
    }

空间复杂度降为O(1)。

欧博电脑版

欢迎进入欧博电脑版（Allbet Game）：www.aLLbetgame.us，欧博官网是欧博集团的官方网站。欧博官网开放Allbet注册、Allbe代理、Allbet电脑客户端、Allbet手机版下载等业务。