题目## 题目
题目主要信息
- 斐波那契数列公式为: F ( n ) = F ( n − 1 ) + F ( n − 2 ) F(n)=F(n-1)+F(n-2) F(n)=F(n−1)+F(n−2)
- 初始化第1项和第2项为1
- 求该数列第n项
举一反三：
学习完本题的思路你可以解决如下题目：
方法一：迭代相加（推荐使用）
知识点：动态规划
动态规划算法的基本思想是：将待求解的问题分解成若干个相互联系的子问题，先求解子问题，然后从这些子问题的解得到原问题的解；对于重复出现的子问题，只在第一次遇到的时候对它进行求解，并把答案保存起来，让以后再次遇到时直接引用答案，不必重新求解。动态规划算法将问题的解决方案视为一系列决策的结果。
思路：
斐波那契数列初始化第1项与第2项都是1，则根据公式第0项为0，可以按照斐波那契公式累加到第 n n n项。
具体做法：
- step 1：低于2项的数列，直接返回n。
- step 2：初始化第0项，与第1项分别为0，1.
- step 3：从第2项开始，逐渐按照公式累加，并更新相加数始终为下一项的前两项。
Java实现代码：
public class Solution {
public int Fibonacci(int n) {
//从0开始，第0项是0，第一项是1
if(n <= 1)
return n;
int res = 0;
int a = 0;
int b = 1;
//因n=2时也为1，初始化的时候把a=0，b=1
for (int i = 2; i <= n; i++){
//第三项开始是前两项的和,然后保留最新的两项，更新数据相加
res = (a + b);
a = b;
b = res;
}
return res;
}
}
C++实现代码：
class Solution {
public:
int Fibonacci(int n) {
//从0开始，第0项是0，第一项是1
if(n <= 1)
return n;
int res = 0;
int a = 0;
int b = 1;
//因n=2时也为1，初始化的时候把a=0，b=1
for (int i = 2; i <= n; i++){
//第三项开始是前两项的和,然后保留最新的两项，更新数据相加
res = (a + b);
a = b;
b = res;
}
return res;
}
};
Python代码实现：
class Solution:
def Fibonacci(self , n: int) -> int:
#从0开始，第0项是0，第一项是1
if n <= 1:
return n
res = 0
a = 0
b = 1
#因n=2时也为1，初始化的时候把a=0，b=1
for i in range(2, n + 1):
#第三项开始是前两项的和,然后保留最新的两项，更新数据相加
res = (a + b)
a = b
b = res
return res
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，其中 n n n为输入的数， n n n次迭代
- 空间复杂度： O ( 1 ) O(1) O(1)，常数级变量，没有其他额外辅助空间
方法二：递归法（扩展思路）
知识点：递归
递归是一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。因此递归过程，最重要的就是查看能不能讲原本的问题分解为更小的子问题，这是使用递归的关键。
思路：
我们也可以根据公式倒推，因为 F ( n ) = F ( n − 1 ) + F ( n − 2 ) F(n)=F(n-1)+F(n-2) F(n)=F(n−1)+F(n−2)，而 F ( n − 1 ) F(n-1) F(n−1)与 F ( n − 2 ) F(n-2) F(n−2)又可以作为子问题继续计算，因此可以使用递归。
- 终止条件： 当递归到数列第1项或是第0项的时候，可以直接返回数字。
- 返回值： 返回这一级子问题的数列值。
- 本级任务： 获取本级数列值：即前两项相加。
具体做法：
- step 1：低于2项的数列，直接返回n。
- step 2：对于当前n，递归调用函数计算两个子问题相加。
Java实现代码：
public class Solution {
public int Fibonacci(int n) {
//从0开始，第0项是0，第一项是1
if (n <= 1)
return n;
else{
//根据公式递归调用函数
return Fibonacci(n - 1) + Fibonacci(n - 2);
}
}
}
C++实现代码：
class Solution {
public:
int Fibonacci(int n) {
//从0开始，第0项是0，第一项是1
if (n <= 1)
return n;
else{
//根据公式递归调用函数
return Fibonacci(n - 1) + Fibonacci(n - 2);
}
return 0;
}
};
Python代码实现：（利用数组存储递归值，优化时间）
class Solution:
def __init__(self):
self.num = [0 for i in range(41)]
def Fibonacci(self , n: int) -> int:
#从0开始，第0项是0，第一项是1
if n <= 1:
self.num[n] = n
return n
if self.num[n - 1] == 0:
self.num[n - 1] = self.Fibonacci(n - 1)
if self.num[n - 2] == 0:
self.num[n - 2] = self.Fibonacci(n - 2)
#根据公式递归调用函数
return self.num[n - 1] + self.num[n - 2]
复杂度分析：
- 时间复杂度： O ( 2 n ) O(2^n) O(2n)，每个递归会调用两个递归，因此呈现2的指数增长（Python版本优化为 O ( n ) O(n) O(n)）
- 空间复杂度： O ( n ) O(n) O(n), 递归栈的最大深度
方法三：动态规划(扩展思路)
知识点：动态规划
动态规划算法的基本思想是：将待求解的问题分解成若干个相互联系的子问题，先求解子问题，然后从这些子问题的解得到原问题的解；对于重复出现的子问题，只在第一次遇到的时候对它进行求解，并把答案保存起来，让以后再次遇到时直接引用答案，不必重新求解。动态规划算法将问题的解决方案视为一系列决策的结果
思路：
既然是数列，我们就把它放入数组中来解决，用数组下标表示斐波那契数列的第几项。
具体做法：
- step 1：创建一个长度为 n + 1 n+1 n+1的数组，因为只有 n + 1 n+1 n+1才能有下标第 n n n项，我们用它记录前 n n n项斐波那契数列。
- step 2：根据公式，初始化第0项和第1项（题目中是第1项和第2项，本质上一样的）。
- step 3：遍历数组，依照公式某一项等于前两项之和，将数组后续元素补齐，即可得到 f i b [ n ] fib[n] fib[n]。
图示：
Java实现代码：
public class Solution {
public int Fibonacci(int n) {
//从0开始，第0项是0，第一项是1
if(n <= 1)
return n;
int[] fib = new int[n + 1];
fib[0] = 0;
fib[1] = 1;
//依次相加
for (int i = 2; i <= n; i++)
fib[i] = fib[i - 1] + fib[i - 2];
return fib[n];
}
}
C++实现代码：
class Solution {
public:
int Fibonacci(int n) {
//从0开始，第0项是0，第一项是1
if (n <= 1)
return n;
int* fib = new int[n + 1];
fib[0] = 0;
fib[1] = 1;
//依次相加
for (int i = 2; i <= n; i++)
fib[i] = fib[i - 1] + fib[i - 2];
return fib[n];
}
};
Python代码实现：
class Solution:
def Fibonacci(self , n: int) -> int:
#从0开始，第0项是0，第一项是1
if n <= 1:
return n
fib = [0 for i in range(n + 1)]
fib[0] = 0
fib[1] = 1
#依次相加
for i in range(2, n + 1):
fib[i] = fib[i - 1] + fib[i - 2]
return fib[n]
复杂度分析：
- 时间复杂度： O ( n ) O(n) O(n)，一个for循环遍历
- 空间复杂度： O ( n ) O(n) O(n)，创建了一个大小为 n + 1 n+1 n+1的动态数组
题目的主要信息：
- 输入一个整数 n ，求1～n这n个整数的十进制表示中1出现的次数
举一反三：
学习完本题的思路你可以解决如下题目：
方法一：按位统计法（推荐使用）
思路：
数字都是由位数组成，某一位上面是1的个数是一定的，因此我们可以根据这个来处理。
假设我们要计算百位上总共有多少1：首先100-199有100个1，而1100-1199又出现了100个1，于是我们知道了每过1000个数字就会出现100个百位上的1，于是我们就有 ⌊ n / 1000 ⌋ ∗ 100 \lfloor n/1000 \rfloor * 100 ⌊n/1000⌋∗100，细分讨论一下就是：
- 当 n % 1000 < 100 n \% 1000 < 100 n%1000<100，百位上不会出现1；
- 当 100 < = n % 1000 < 200 100 <= n \% 1000 < 200 100<=n%1000<200，百位上出现的1有 n % 1000 − 100 + 1 n \% 1000 - 100 + 1 n%1000−100+1次
- 当 n % 1000 > = 200 n \% 1000 >= 200 n%1000>=200，百位上的1一共100次
于是我们就可以得到计算公式每一位的计算公式：
⌊ n / 1 0 i + 1 ⌋ ∗ 1 0 i + m i n ( m a x ( n % 1 0 i + 1 − 1 0 i + 1 , 0 ) , 1 0 k ) \lfloor n / 10^{i+1} \rfloor * 10^i + min(max(n \% 10^{i+1} - 10^i + 1, 0), 10^k) ⌊n/10i+1⌋∗10i+min(max(n%10i+1−10i+1,0),10k)
公式中 1 0 i 10^i 10i就表示某一位，而前半部分是表示完整在循环中的，后半部分表示部分出现需要讨论的。
具体做法：
- step 1：准备一个基础变量，记录位数，从1开始，每轮循环扩大10倍。
- step 2：从1开始，即个位开始，直到基础变量大于n，每次按照公式统计相应位置1的个数。
图示：
Java实现代码：
import java.util.*;
public class Solution {
public int NumberOf1Between1AndN_Solution(int n) {
int res = 0;
//MulBase = 10^i
long MulBase = 1;
//每位数按照公式计算
for(int i = 0; MulBase <= n; i++){
//根据公式添加
res += (n / (MulBase * 10)) * MulBase + Math.min(Math.max(n % (MulBase * 10) - MulBase + 1, (long)0), MulBase);
//扩大一位数
MulBase *= 10;
}
return res;
}
}
C++实现代码：
class Solution {
public:
int NumberOf1Between1AndN_Solution(int n) {
int res = 0;
//MulBase = 10^i
long long MulBase = 1;
//每位数按照公式计算
for(int i = 0; MulBase <= n; i++){
//根据公式添加
res += (n / (MulBase * 10)) * MulBase + min(max(n % (MulBase * 10) - MulBase + 1, (long long)0), MulBase);
//扩大一位数
MulBase *= 10;
}
return res;
}
};
Python实现代码：
class Solution:
def NumberOf1Between1AndN_Solution(self , n: int) -> int:
res = 0
#MulBase = 10^i
MulBase = 1
#每位数按照公式计算
i = 0
while MulBase <= n:
i += 1
#根据公式添加
res += (n // (MulBase * 10)) * MulBase + min(max(n % (MulBase * 10) - MulBase + 1, 0), MulBase)
#扩大一位数
MulBase *= 10
return res
复杂度分析：
- 时间复杂度： O ( l o g 10 n ) O(log_{10}n) O(log10n)，循环次数等于数字 n n n的位数，位数与 n n n呈10的对数关系
- 空间复杂度： O ( 1 ) O(1) O(1)，常数级变量，无额外辅助空间使用
方法二：暴力统计法（扩展思路）
思路：
有人或许会觉得按照位数一次性统计整体想起来有点绕，我们可以试一下这种简单的暴力方法。
我们可以尝试遍历1到n的每个数字，然后对每个数字单独遍历它的每一位，检查是否是1，如果是1则计数。
具体做法：
- step 1：从1遍历到n，查看每一个数字。
- step 2：对于每个数字，用连除法每次判断最后一位数字是否为1，并进行计数。
Java实现代码：
import java.util.*;
public class Solution {
public int NumberOf1Between1AndN_Solution(int n) {
int res = 0;
//遍历1-n
for(int i = 1; i <= n; i++){
//遍历每个数的每一位
for(int j = i; j > 0; j = j / 10){
//遇到数字1计数
if(j % 10 == 1)
res++;
}
}
return res;
}
}
C++实现代码：
class Solution {
public:
int NumberOf1Between1AndN_Solution(int n) {
int res = 0;
//遍历1-n
for(int i = 1; i <= n; i++){
//遍历每个数的每一位
for(int j = i; j > 0; j = j / 10){
//遇到数字1计数
if(j % 10 == 1)
res++;
}
}
return res;
}
};
Python实现代码：
class Solution:
def NumberOf1Between1AndN_Solution(self , n: int) -> int:
res = 0
#遍历1-n
for i in range(1, n + 1):
#遍历每个数的每一位
j = i
while j > 0:
#遇到数字1计数
if j % 10 == 1:
res += 1
j = j // 10
return res
复杂度分析：
- 时间复杂度： O ( n l o g 10 n ) O(nlog_{10}n) O(nlog10n)，外循环一共循环 n n n次，内循环最大循环次数不会超过最大数字 n n n的位数即 l o g 10 n log_{10}n log10n
- 空间复杂度： O ( 1 ) O(1) O(1)，常数级变量，无额外辅助空间使用
扫一扫
909
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
