不是吧，不是吧，这年头还有人不知道算法的重要性？我进字节年薪45w+全靠大佬这份笔记！

最新推荐文章于 2025-11-24 16:03:12 发布
原创 最新推荐文章于 2025-11-24 16:03:12 发布 · 1.2k 阅读 · 73 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #网络互联 #程序员 #android #学习面试

本指南提供了一套全面的LeetCode刷题方案，包括算法框架、数据结构总结及经典题目解析。不仅涵盖算法实现代码，更有详细的解题思路与思考框架，助力技术面试。

前不久，GitHub 上出现了一个手把手带你刷 LeetCode 的项目。该项目此前在 GitHub 开源后，连续多次霸榜 GitHub Trending 首页，用了两个月 Star 数便破 50k， 受欢迎程度由此可见一斑：

还在为面试算法问题发愁吗？书中给算法与数据结构总结出了一套框架模板，还有整整一个章节教你如何套模板做题，这是用套路解决算法问题的文章：

有别于其他 LeetCode 刷题仓库，该项目里面不止提供了题解代码，还有算法的具体解答思路与思考框架。

内容前后共分为以下3份PDF，内容不可谓不详尽：

由于篇幅原因，为了避免影响到大家的阅读体验，在此只以截图展示部分内容，详细完整版的看文末有免费的获取方式！

第一份：经典算法大全


12.AlgorithmGossip:双色、三色河内塔

15.AlgorithmGossip:Eratosthenes筛选求质数

36.排序法-改良的选择排序

39.AlgorithmGossip:快速排序法（三）

51.AlgorithmGossip:2(2N+1)魔方阵

第二份：算法的乐趣


程序员与算法

算法设计的基础

算法设计的常用思想

阿拉伯数字与中文数字

第三份：LeetCode算法收割机


第2章 线性表

第4章 栈和队列

第6章 排序

第10章 深度优先搜索

Android大厂面试题精选

387+755+791=1953页的3份高质量《大厂面试宝典》合集

由于篇幅原因，为了避免影响到大家的阅读体验，在此只以截图展示部分内容，有需要的朋友赶紧评论666，只有点赞+关注，然后查看我的【GitHub】就能获取这3份算法与数据结构笔记以及1953页PDF的面试题解析文档哦！

最后

对于⾃⼰来说，写题解也是⼀种提⾼。把⼀道深奥的题⽬讲给⼀点都没有头绪的⼈，并能让他完全听懂，很能锻炼⼈的表达能⼒。在讲解中很可能还会遇到听者的⼀些提问，这些问题可能是⾃⼰的知识漏洞，强迫⾃⼰去弥补。

⽤更多的时间去做更多的题。现在不知道算不算是“出来混的，总是要还的”。

Android725
关注
Spring Boot进阶(108)：这年头不会还有谁没碰过minio的吧？这可太...
**My Coding Family**
12-31 1391
想象一下，你正在开发一个新项目，老板突然拍着桌子跟你说：“咱这个项目得支持海量文件存储，用户随时上传随时下载，成本要低，性能要高，安全也不能落下！”你抓了抓头发，盯着屏幕陷入沉思，传统文件系统？太笨重。云存储？预算超标。就在你一筹莫展时，MinIO横空出世，仿佛一道曙光，照亮了你前行的路。MinIO，这款开源的对象存储系统，以其高性能、易扩展、S3兼容性等优点，迅速成为开发者圈中的“香饽饽”。如果你用Spring Boot开发项目，想要高效管理文件存储，那么接下来的内容会让你大呼过瘾。
Spring Boot进阶(107)：这年头谁还手写逻辑删除，一个注解@TableLogic搞定！
**My Coding Family**
12-31 1937
🏆本文收录于「滚雪球学SpringBoot」专栏，手把手带你零基础入门Spring Boot，从入门到就业，助你早日登顶实现财富自由🚀；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！
去年秋招，我学长拿了7个Offer，他是怎么做到的？
程序员吴师兄的博客
07-01 1726
去年，学校有位学长参加秋招的时候，拿到了字节跳动、快手、阿里、美团……等等 7 家大厂的 Offer，在此之前，学长一直“默默无闻”，基本可以说是在秋招一战成名，成为众多学弟学妹羡慕的对...
是刁难？还是装B？字节面试每轮必问的算法题到底意义何在？
star_nwe的博客
12-18 2160
最近在脉脉上看到有一个Android工程师吐槽：自己明明有着BAT的5年工作经验，却没想到在应聘Hulu时，败在了算法题上。 明明有多年大厂工作经验，为什么还要在找工作跳槽时，面对算法的考题？ 这个话题，已经引发了不少人的关注，其中有人强烈支持，有人裂墙反对。 反 方：谁在工作中会用到面试里这么复杂的算法？ 能解算法题并不意味着个人就有能力在工作中解决问题。 举个例子，小时候学奥数学得牛逼的人，有些题目比这些题更难啊，他们会做题吗？会啊！但并不意味着那些奥数能手就能解决实际问题吧！生活中这种例子见的还
年薪80万的程序员被嘲比不上15万的二本教书的，你咋看？知乎网友：我站着看
l947282038的博客
09-04 1047
程序员是一个吃青春饭的行业，等年龄大了，身体受损严重，也跟不上巨大的工作强度，不能称作一个好工作的首选。而亲戚的孩子在正经大学当老师，工作清闲、任务少不说，不需要付出任何的体力劳动，身体上的负担和心理上的负担都少很多。如果薪资给的较多，这份工作还相对可以，如果工资给的很少，那自然不太让人满意，也就称不上是一份理想的好工作。比如程序员，加班是常有的事情，工作到凌晨两三点也很正常。一个沉默寡言的人不适合做一份完全需要与人沟通才能带来业绩的工作，而一个总是说个不停的活泼的人也不适合做一份长时间不与人交往的工作。
6轮面试阿里Android开发offer，薪资却从21k降到17k，在逗我？
huahaiyi的博客
10-05 332
一小伙工作快3年了，拿到了阿里云Android开发岗位P6的offer，算HR面一起，加起来有6轮面试了，将近3个月的时间，1轮同级 + 1轮Android用人部门leader + 1轮Android 组leader + 1轮项目CTO + 1轮HR + 1轮HRBP。
谁在带队小鹏机器人：IRON背后的四位关键人物
量子位
11-10 66
刘先明指出，传统VLA最大的问题在于它用离散的语言来连接图像，这一过程有大量的信息会丢失，最终使得训练数据获取成本升高，不能大规模训练。而他们所提出的第二代VLA，则旨在去除语言这一中间层，让视觉与语义的直接对齐，这让自监督训练成为可能，因此更容易Scaling。具体而言，团队这次依然是从人类的生物构造上获得的灵感，从脊柱、到肌肉群、再到腹腔、甚至最外层的皮肤，这一切都是仿人类设计的。事实上，就在八个月前，IRON还远远没有像发布会上一样的超拟态猫女步伐，这一能力，几乎是在3月份的某天，一夜涌现出来的。
python的工具包有哪些,python工具库有哪些
2401_85975385的博客
07-15 941
如果对Python感兴趣的话，可以试试我的学习方法以及相关的神经网络优快云Python所有方向的学习路线Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。二、Python必备开发工具。
CCIG 2024：合合信息文档解析技术突破与应用前景
2301_79125642的博客
05-31 1026
要转c＃，试用期6个月签三年，目前只告诉了试用期工资，感觉公司缺人hr希望尽快实习，本人是双非本，下。#牛客福利打卡# #如何写好一份简历# 感觉要崩溃了，完全找不到暑假实习，我想去试一下工作的感觉哇，3月开始投递，经历过好几场笔试爆0，面试支支吾吾，脑袋成为浆糊，一面秒挂，被面试官质疑，最后快6月了。实习大半个月，打了n个杂，复杂点的搞了个国产环境适配、数据迁移，一直部署部署部署，还没接开发需求，感。#牛客福利打卡# #我的实习求职记录# 实习到底怎么找啊，投了很多了，回复了寥寥无几，可能是简历不。
题解 | #查找入职员工时间排名倒数第三的员工所有信息#
华鑫的专栏
07-22 674
上了二十多年学，然后就工作，一个人在离家很远的地方，初来乍到谁都不认识，leader带我介绍了一圈，请问一下，非目标院校硕士，几个月前做过一次笔试题，但只有200多分，然后hr帮我投了之后就没后续了，难受了兄弟们，还在集训，刚确认带教老师，问需要学点什么，让我了解下前端相关的知识，学一下Java s。目前准备开始投递秋招正式批，求职岗位是电视运营，本人是双非院校学生，目标是中厂，能进大厂是最好的，想。6月初就投的简历，现在还没有约面试，简历一直显示评估中，想问下大家的投递情况咋样呀？
写给想转行学IT的朋友们的话
qkh1234567的博客
04-27 2184
最近有很多朋友咨询我关于想转行学IT的问题，我想结合自身的经历和思考和各位聊几句，本文带有比较强的主观色彩，因此文中观点仅供参考，如有不当之处，敬请海涵。笔者19年本科毕业于一所中流211，毕业之后一直在做Java开发，我并没有进大厂，也没有年薪百万，就是芸芸众生中普通的那一个。现在回顾当时入行的经历，基本是摸着石头过河，因此在有了一些经验之后，就想给和我当时一样处境的朋友一点建议，希望能对你有所启发。
什么！这年头还有人在用白鹭？—— egret面试题
upgrade_bro的博客
06-05 2046
H5前端。
我真不信，这年头还有人能懂SpringBoot的ClassLoader加载机制
wdj_yyds的博客
04-08 1426
SpringBoot的ClassLoader加载机制 在Spring Boot的嵌入式Web容器原理一节中，我们已经介绍了Spring Boot对Tomcat容器的加载过程，本节我们进一步讲解SpringBoot的ClassLoader加载机制。 熟悉Tomcat工作原理的人应该知道，Tomcat内部实现了自定义的类加载器，打破了Java的双亲委派机制，下面我们先看看什么是双亲委派机制。 双亲委派机制 双亲委派机制是指Java的类加载器收到一个类加载请求时，该类加载器首先会把请求委派给父类加
图解移动机器人中的运动规划(Motion Planning)，附几十种规划算法
热门推荐
FRIGIDWINTER的博客
02-01 4万+
运动规划是移动机器人的核心理论和工程技术之一，本文作为教程先导，解析了运动规划的两大组件——路径规划和轨迹规划。欢迎感兴趣的同学订阅专栏！
数据结构：双向循环链表
最新发布
闲余知道
11-24 258
数据结构：双向循环链表
高阶数据结构 --- 单调栈
2403_88695928的博客
11-23 252
本文介绍了算法竞赛中常用的单调栈数据结构。内容涵盖单调栈的基本概念（包括单调递增栈和单调递减栈）、主要作用以及相关算法题示例。通过三个典型题目（单调栈模板题、发射站问题、柱状图最大矩形面积问题）展示了单调栈的实际应用。文章以简明扼要的方式呈现了单调栈的核心知识点和应用场景。
数据结构：栈
2401_87199143的博客
11-22 647
目前，我们对链表剖析已经有一定的程度了，终于伴随着我对栈的学习，我们将开启新的篇章。我将一点点介绍栈，并举出一道例题帮助理解栈的使用。
【数据结构】：排序（一）
2402_87037360的博客
11-23 985
本文介绍了常见的排序算法分类及具体实现方法，主要包括插入排序（直接插入排序、希尔排序）、选择排序（堆排序、直接选择排序）和交换排序（冒泡排序，快速排序）。文章详细讲解了每种算法的基本思想、代码实现和优化方法，并通过示例代码和运行结果进行验证。文章内容清晰实用，适合编程学习者参考实践。
算法训练-数据结构
weixin_55800388的博客
11-22 383
本文介绍了五种算法问题的解决方案：1) 数组循环左移通过三次翻转实现；2) 双指针法在有序数组中寻找第K大数；3) 股票买卖问题通过记录最小价格和最大利润求解；4) 双指针法计算容器最大储水量；5) 最小堆方法寻找包含k个列表元素的最小区间。这些算法涵盖了数组操作、双指针技巧和堆数据结构应用，展示了不同场景下的高效解决方案。
scala2、若有一头小母牛，从出生起第四个年头开始每年都生一头母牛，按次规律，第 n 年时有多少头母牛？
04-30
<think>嗯，用户想用Scala写一个递归函数来计算第n年的母牛数量，根据特定的规则。首先，我需要仔细理解用户提供的引用内容中的递归规则。 根据引用[1]，母牛的数量分为幼崽和成年两部分。递推公式是Yn幼=Y(n-1)幼-Y(n-5)成+Yn成，而Yn成=Y(n-1)成+Y(n-5)成。不过后来又推导出Yn幼=Y(n-1)幼+Y(n-1)成。这可能有点复杂，需要理清每个变量的含义。在Java代码中，g(n)代表成年母牛的数量，f(n)代表幼崽的数量。比如，g(n)在年份小于5时返回初始的bigCow，而超过5年后，g(n)=g(n-1)+g(n-5)。这可能意味着成年牛每年会增加前五年的数量？ 然后引用[2]提到另一种递推公式，f(n)=f(n-3)+f(n-1)当n>3时。这看起来像是一个不同的繁殖规则，母牛在第三年后开始生产。这里可能存在两个不同的模型，需要确定用户到底需要哪一个。 用户现在的问题是关于Scala实现，所以需要结合引用中的不同模型。用户提供的Java代码中的递推关系可能更接近他们想要的。比如，g(n)成年牛的数量递归调用g(n-1)+g(n-5)，这可能代表每头成年牛在第五年开始生产？或者可能每年有新的成年牛加入，而生产幼崽的规则不同。 在Java的示例中，第n年的成年牛数量g(n)在year>=5时是g(n-1)加上g(n-5)，这可能意味着每年新增的成年牛来自五年前的幼崽。幼崽的数量f(n)则是前一年的幼崽加上前一年的成年牛数量，这可能表示每头成年牛每年生一头幼崽。比如，Yn幼=Y(n-1)幼 + Y(n-1)成，而成年牛数量Yn成=Y(n-1)成 + Y(n-5)成中的Y(n-5)成可能是指五年前的幼崽现在成年了？ 不过这可能比较复杂，需要确认正确的递推关系。或者，是否应该参考引用[2]中的模型，其中f(n)=f(n-1)+f(n-3)，这可能更简单。用户现在的问题可能与引用[1]中的Java代码相关，所以需要根据该代码来构建Scala的递归函数。 所以，关键点在于，成年牛的数量g(n) = g(n-1) + g(n-5)（当n>=5时），而幼崽的数量f(n) = f(n-1) + g(n-1)。总数量是两者之和。因此，用户可能希望Scala代码能实现类似的递归结构。 但Scala中递归需要注意栈溢出的问题，特别是当n较大时，比如用户示例中的year=30，这可能导致深度递归。不过用户可能先关注逻辑正确性，暂不考虑尾递归优化。 因此，可能的Scala代码结构是定义两个递归函数，g和f，分别对应成年和幼崽的数量，然后总和相加。例如： def g(n: Int): Int = if n < 5 then initialBigCow else g(n-1) + g(n-5) 但需要确定初始条件。根据Java代码中的测试用例，初始时smallCow是0，bigCow是1。所以当n<5时，g(n)返回bigCow的值，即1。当n=5时，返回bigCow + smallCow=1+0=1？或者Java代码中的g(5)返回bigCow+smallCow？可能这里的初始条件是，第一年有1头成年牛，而幼崽初始是0。之后每年，幼崽的数量是前一年的幼崽加上前一年的成年牛数量，因为每头成年牛每年生一头幼崽。而成年牛的数量是前一年的成年牛加上五年前变成成年的牛？ 或者可能，幼崽在第五年变成成年牛。例如，每头幼崽需要五年才能成年，所以每年新增的成年牛是五年前的幼崽数量。而幼崽数量每年由前一年的成年牛数量决定，因为每头成年牛每年生一头幼崽。 这种情况下，递推关系可能为： 成年牛数g(n) = g(n-1) + f(n-5)（假设幼崽经过五年成为成年牛） 而幼崽数f(n) = f(n-1) + g(n-1) - f(n-5)，因为五年前的幼崽现在成年了，所以要从幼崽中减去这部分，并加到成年牛中。 这可能更接近Java代码中的逻辑。例如，在Java的g函数中，当year>=5时，g(year) = g(year-1) + g(year-5)。这可能表示成年牛每年增加的是五年前的成年牛数量？或者是否可能是五年前出生的幼崽现在成年了？ 可能这里的模型是，每头成年牛每年生一头幼崽，而幼崽需要五年才能成为成年牛。因此，成年牛的数量是前一年的成年牛数量加上五年前出生的幼崽数量（这些幼崽现在成年了）。而幼崽的数量是前一年的幼崽数量加上前一年成年牛生的数量（即前一年成年牛的数量），再减去五年前的幼崽数量（因为它们现在成年了，不再是幼崽）。 所以： f(n) = f(n-1) + g(n-1) - f(n-5) 而g(n) = g(n-1) + f(n-5) 这可能更符合递推关系。但根据Java代码中的g函数，当year>=5时，g(year)=g(year-1) + g(year-5)。这可能表示成年牛的数量等于前一年的成年牛数量加上五年前成为成年牛的数量？或者是否是五年前的幼崽现在成为成年牛的数量？ 这里可能存在理解上的困难。需要仔细分析Java代码中的g函数： 在Java的CowHouse类中，初始构造函数的参数是smallCow（幼崽数）和bigCow（成年数）。测试用例中是初始化为0幼崽和1成年牛。对于g函数： public int g(int year) { if(year<5) return bigCow; else if(year==5) return bigCow + smallCow; else return g(year-1) + g(year-5); } 当year<5时，g返回bigCow的初始值1。当year=5时，返回bigCow + smallCow，即1+0=1。这可能有问题，因为如果初始时smallCow是0，那么year=5时，g(5)=1。之后，当year>5时，g(year) = g(year-1)+g(year-5)。例如，year=6时，g(6)=g(5)+g(1)=1+1=2。这可能意味着，成年牛的数量在每年增加前五年的成年牛数量？这可能与繁殖规则有关。 可能这里的模型是，成年牛每年会生成新的成年牛，比如每头成年牛在五年后会产生一个新的成年牛？这似乎不太合理。或者，可能是每头牛在第五年才会开始生产，或者每五年产生一头成年牛？ 或者，可能这里的模型是母牛每五年生一头成年牛？这可能需要更详细的规则说明。但根据引用[2]中的另一个模型，f(n)=f(n-1)+f(n-3)当n>3时，这可能对应母牛在第三年开始生产，每年生一头。用户提供的Java代码中的模型可能不同，比如母牛在第五年开始生产。 可能需要结合用户提供的Java代码的输出来验证。例如，在测试用例中，当初始时smallCow=0，bigCow=1，year=30时，程序计算出的母牛数、幼崽数和总数是多少？ 根据Java代码中的g函数，当year>=5时，g(n)=g(n-1)+g(n-5)。例如，计算g(5)=1，g(6)=g(5)+g(1)=1+1=2，g(7)=g(6)+g(2)=2+1=3，g(8)=g(7)+g(3)=3+1=4，g(9)=g(8)+g(4)=4+1=5，g(10)=g(9)+g(5)=5+1=6，依此类推。这样，g(n)的增长类似于斐波那契数列，但步长是5年。 而f函数在Java中是f(n)=f(n-1)+g(n-1)。例如，f(0)=0，f(1)=f(0)+g(0)=0+1=1，f(2)=f(1)+g(1)=1+1=2，f(3)=2+1=3，f(4)=3+1=4，f(5)=4+1=5，但根据测试用例中的初始条件，当year=5时，g(5)=1（因为bigCow+smallCow=1+0=1），所以f(5)=f(4)+g(4)=4+1=5。此时幼崽数是5，成年牛数是1，总数是6。然而根据引用[2]中的示例，可能不同。 现在用户的问题是，如何将这样的逻辑转换为Scala的递归函数，计算第n年的母牛总数。因此，关键是根据Java代码中的递归关系，用Scala实现对应的函数。 Scala中，可以定义两个递归函数，g和f，分别对应成年和幼崽的数量。然后，总数量是g(n) + f(n)。需要注意初始条件，例如当n<5时，g(n)=1（初始bigCow=1），而f(0)=0，其他年份的f(n)由递推公式得出。 但Java代码中的初始条件可能有问题？比如，当year=5时，g(5)=bigCow + smallCow=1+0=1，而smallCow在初始时是0。这可能意味着，第五年的时候，原本的幼崽（如果有的话）变成了成年牛，但初始时smallCow是0，所以这里可能只是将初始的bigCow加上smallCow，但smallCow是0，所以结果还是1。 因此，Scala中的实现需要复制Java代码中的逻辑。例如： def g(n: Int): Int = if n < 5 then 1 else if n == 5 then 1 else g(n-1) + g(n-5) 但根据Java代码，当n==5时返回的是bigCow + smallCow，即初始时smallCow是0，所以这里等于1。而当n>5时，递归调用g(n-1)+g(n-5)。这可能是一个问题，因为当n=5时，返回的是1，而n=6时，g(6)=g(5)+g(1)=1+1=2，n=10时，g(10)=g(9)+g(5)=5+1=6，依此类推。这可能导致g(n)的增长模式是每五年叠加一次。 而f(n)在Java中是： public int f(int year) { if(year ==0) return smallCow; // 0 else return f(year-1) + g(year-1); } 所以，当year=1时，f(1)=f(0)+g(0)=0+1=1。year=2时，f(2)=f(1)+g(1)=1+1=2，依此类推。因此，f(n)的递推式是累加前n-1年的g值。 综上，Scala代码可以这样写： object CowCounter { // 成年牛数量 def g(n: Int): Int = if n < 5 then 1 else g(n - 1) + g(n - 5) // 幼崽数量 def f(n: Int): Int = if n == 0 then 0 else f(n - 1) + g(n - 1) // 总数 def total(n: Int): Int = g(n) + f(n) } 但这样在n较大时（如30），递归性能会很差，因为存在大量的重复计算。不过用户可能先关注正确性，暂时不考虑优化。 测试一下n=5的情况： g(5) =1 f(5)=f(4)+g(4) f(4)=f(3)+g(3) f(3)=f(2)+g(2) f(2)=f(1)+g(1)=1 +1=2 f(3)=2 +1=3 f(4)=3 +1=4 f(5)=4 +1=5 所以总数量是1+5=6，与Java代码中的情况是否一致？ 当n=5时，Java中的g(5)=1，f(5)=5，总数是6。可能正确。 但用户提供的引用[2]中的模型不同，可能是一个不同的繁殖规则。用户需要确认具体使用哪种模型。但根据用户提供的Java代码，应该按照该逻辑来实现。 现在用户的问题是如何用Scala递归函数实现，所以代码结构应该如上。但需要注意Scala的语法，例如使用if表达式，函数定义等。 因此，最终回答应该包括Scala代码的实现，解释递推关系，并可能提到性能问题，例如对于较大的n值，建议使用尾递归优化或记忆化来提升效率。不过用户当前问题可能只需要基础实现。</think>根据递推公式$Y_n^{成}=Y_{n-1}^{成}+Y_{n-5}^{成}$和$Y_n^{幼}=Y_{n-1}^{幼}+Y_{n-1}^{成}$，使用Scala实现递归函数的步骤如下： ### 递归函数实现 ```scala object CowCounter { // 成年牛数量（对应g函数） def adultCows(n: Int): Int = if n < 5 then 1 // 前四年保持初始值 else adultCows(n-1) + adultCows(n-5) // 递推公式 // 幼崽数量（对应f函数） def calves(n: Int): Int = if n == 0 then 0 // 初始幼崽数为0 else calves(n-1) + adultCows(n-1) // 每年新增幼崽数为前一年成年牛数量 // 总牛数 def totalCows(n: Int): Int = adultCows(n) + calves(n) } ``` ### 递推公式解释 1. **成年牛增长**：当$n \geq 5$时，$Y_n^{成}=Y_{n-1}^{成}+Y_{n-5}^{成}$，表示新增的成年牛来自五年前出生的幼崽[^1] 2. **幼崽增长**：$Y_n^{幼}=Y_{n-1}^{幼}+Y_{n-1}^{成}$，表示每年所有成年牛都会产一只幼崽[^1] ### 示例计算 计算第5年： $$adultCows(5)=adultCows(4)+adultCows(0)=1+1=2$$ $$calves(5)=calves(4)+adultCows(4)=4+1=5$$ $$totalCows(5)=2+5=7$$ ### 性能优化建议 对于较大年份（如$n>30$），建议改用带记忆化的递归或动态规划。原始递归时间复杂度为$O(2^n)$，使用记忆化后可优化至$O(n)$[^3]。 ```scala // 带记忆化优化的版本 import scala.collection.mutable object MemoizedCowCounter { private val adultCache = mutable.Map[Int, Int]() private val calvesCache = mutable.Map[Int, Int]() def adultCows(n: Int): Int = adultCache.getOrElseUpdate(n, if n < 5 then 1 else adultCows(n-1) + adultCows(n-5) ) def calves(n: Int): Int = calvesCache.getOrElseUpdate(n, if n == 0 then 0 else calves(n-1) + adultCows(n-1) ) } ```
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值