剑指offer(题10 递归和循环：斐波那契数列/跳台阶/变态跳台阶/矩形覆盖) 题解

最新推荐文章于 2023-12-11 15:13:17 发布

法号画工师

最新推荐文章于 2023-12-11 15:13:17 发布

阅读量248

点赞数 1

分类专栏：剑指offer 文章标签：算法数据结构

本文链接：https://blog.youkuaiyun.com/weixin_45453028/article/details/106390348

版权

剑指offer 专栏收录该内容

30 篇文章

订阅专栏

这篇博客探讨了如何使用递归和循环解决斐波那契数列、跳台阶、变态跳台阶和矩形覆盖问题。针对每个问题，作者提供了递归和循环优化的解决方案，并分析了递归的效率问题，指出循环实现能显著提高计算速度。文章以Java编程语言为例，给出了具体的代码实现，并总结了这些问题与斐波那契数列的关系。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

剑指offer-10 递归和循环：斐波那契数列/跳台阶/变态跳台阶/矩形覆盖

微信搜索【程序员画工师】关注更多Java编程技术、数据结构与算法、面试题相关内容。

题目1 斐波那契数列

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。n<=39

常规递归解法

思路：斐波那契数列属于经典的递归问题，可得以下的代码

public class Solution {
    public int Fibonacci(int n) {
        if(n == 0){
            return 0;
        }
        if(n == 1){
            return 1;
        }
        return Fibonacci(n-1) + Fibonacci(n-2);
    }
}

思考

递归的本质是把一个问题分解成两个或者多个小问题，如果多个小问题存在互相重叠的情况，那么就存在重复计算。以f(10)为例：
在这里插入图片描述
从上图中不难发现：在这棵树中有很多节点是重复的，而且重复的节点数会随着n的增大而急剧增加，这意味计算量会随着n的增大而急剧增大。本地测试情况：当n=39时运行时间为：443ms。

事实上，用递归方法计算的时间复杂度是以n的指数的方式递增的。

其实改进的方法并不复杂，只要想办法避免重复计算就可以了，递归的思想是自顶向下的，f(n)的求解基于f(n-1)和f(n-2)，f(n-1)的求解又基于f(n-2)和f(n-3)等等依次类推。

而现在我们可以反过来，自底向上，在已知f(1)= 1，f(2)= 1的情况下求解f(3)，再利用f(3)和f(2)求解f(4)直到求出f(n)。

基于循环实现的优化代码

思路：把递归的方法用循环实现

public class Solution {
    public int Fibonacci(int n) {
        if(n == 0){
            return 0;
        }
        if(n == 1){
            return 1;
        }
        int Fib = 0;
        int FibOne = 0;
        int FibTwo = 1;
        for(int i = 2;i <= n;i++){
            Fib = FibOne + FibTwo;
            FibOne = FibTwo;
            FibTwo = Fib;
        }
        return Fib;
    }
}

本地测试情况：当 n=39时运行时间为：低于1ms，极大的提高了时间效率。这种思路的时间复杂度o(n)。

题目2 跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

思路

青蛙跳n个台阶，总情况设为f(n)，每一次可以跳1个台阶，也可以跳2个台阶，那么共分为两种情况来分析这个问题了。

比如青蛙第一次跳1个台阶，还剩n-1个台阶要跳，就分解为了f(n-1)这个子问题，那么这种情况下共有f(n-1)种可能跳法；如果青蛙第一次跳2个台阶，还剩n-2个台阶要跳，就分解为了f(n-2)这个子问题，那么这种情况下共有f(n-2)种可能跳法，所以所有可能的跳法就是求f(n) = f(n-1) + f(n-2)，注意f(1)和f(2)，f(1) = 1，f(2) = 2。这样就成功转化为斐波那契数列问题了。

上代码

public class Solution {
    public int JumpFloor(int target) {
        if(target == 0){
            return 0;
        }
        if(target == 1){
            return 1;
        }
        if(target == 2){
            return 2;
        }
        int JumpNum = 0;
        int JumpOne = 1;
        int JumpTwo = 2;
        for(int i = 3;i <= target;i++){
            JumpNum = JumpOne + JumpTwo;
            JumpOne = JumpTwo;
            JumpTwo = JumpNum;
        }
        return JumpNum;
    }
}

题目3 变态跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

思路

每个台阶都可以选择跳或者不跳，最后一个台阶必跳。数学归纳法可得每个台阶有两种选择，n个台阶有2的n-1次方种选择。

基于递归的代码

public class Solution {
    public int JumpFloorII(int target) {
        if(target == 0){
            return 0;
        }
        if(target == 1){
            return 1;
        }
        if(target == 2){
            return 2;
        }
        return 2 * JumpFloorII(target - 1);
    }
}

基于循环实现递归的代码

public class Solution {
    public int JumpFloorII(int target) {
        if(target == 0){
            return 0;
        }
        if(target == 1){
            return 1;
        }
        if(target == 2){
            return 2;
        }
        int JumpNum = 2;
        for(int i = 3;i <= target; i++){
            JumpNum = JumpNum * 2;
        }
        return JumpNum;
    }
}

利用Java pow() 方法


public class Solution {
    public int JumpFloorII(int target) {
        if(target == 0){
            return 0;
        }
        if(target == 1){
            return 1;
        }
        if(target == 2){
            return 2;
        }
        return(int)Math.pow(2.0,target - 1.0);
    }
}

题目4 矩形覆盖

我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2

1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

思路

跟上面跳台阶那个题类似。

在这里插入图片描述
假设有8个块，第1块竖着放，后面还剩7块，共f(7)种方法，第1块横着放，后面还剩6块，共f(6)种方法。

即f(8)=f(6)+f(7) 可得f(n)=f(n-1)+f(n-2)这样就成功地转化为斐波那契数列问题了。

上代码

public class Solution {
    public int RectCover(int target) {
        if(target == 0){
            return 0;
        }
        if(target == 1){
            return 1;
        }
        if(target == 2){
            return 2;
        }
        int RectCoverNum = 0;
        int RectCoverOne = 1;
        int RectCoverTwo = 2;
        for(int i = 3;i <= target;i++){
            RectCoverNum = RectCoverOne + RectCoverTwo;
            RectCoverOne = RectCoverTwo;
            RectCoverTwo = RectCoverNum;
        }
        return RectCoverNum;
    }
}