3种方法求解斐波那契数列

最新推荐文章于 2024-10-14 20:43:23 发布

yuchiwang

最新推荐文章于 2024-10-14 20:43:23 发布

阅读量3k

点赞数 1

分类专栏：算法

本文链接：https://blog.csdn.net/u013498583/article/details/54670380

版权

算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

题目：定义Fibonacci数列如下：

分析1：看到斐波那契数列几乎所有的程序员在第一时间的反应都是“递归”，没错了，作为和汉诺塔一样的经典递归问题，我们几乎毫不犹豫就可以写出如下的代码：

 1 #include<iostream>
 2 #include<string>
 3 using namespace std;
 4 
 5 long Fibonacci(unsigned int n)
 6 {
 7     if(n == 0)
 8         return 0;
 9     else if(n == 1)
10         return 1;
11     else
12         return Fibonacci(n-1) + Fibonacci(n-2);
13 }
14 
15 int main()
16 {
17     cout<<"Enter An N:"<<endl;
18     unsigned int number=0;
19     cin>>number;
20     cout<<Fibonacci(number)<<endl;
21     return 0;
22 }

然而我们不禁要问：虽然用这道题使得递归变得容易理解，那么这道题用递归是最好的吗？我们用计算f(10)来说明：

从图中可以看出：在计算F(10)要计算F(9)和F(8)，二要计算F(9)，又要计算F(8)，以此类推，要计算很多重复的值，这样就浪费了时间，而计算重复值的数量随着N值而急剧增大，事实上该算法的时间复杂度随着n值呈指数增长。不信，大家可以取N=100看看递归要慢到什么程度。

分析2：既然上面算法的主要缺点是要重复的计算很多不必要的数值，那么我们的想法是不计算那些重复的值，我们考虑对于任意一个N值，我们从第一项开始，不断的累积下去，这样就可以避免重复计算。由于是从第一项逐次求解，所以该算法的时间复杂度为O(n)。代码如下：

 1 #include<iostream>
 2 #include<string>
 3 using namespace std;
 4 
 5 long Fibonacci(unsigned int n)
 6 {
 7     if(n == 0)
 8         return 0;
 9     if(n == 1)
10         return 1;
11     long firstItem = 0;
12     long secondItem = 1;
13     long fib = 0;
14     unsigned int cnt = 1;
15     while(cnt < n)
16     {
17         fib = firstItem + secondItem;
18         firstItem = secondItem;
19         secondItem = fib;
20         ++cnt;
21     }
22     return fib;
23 }
24 
25 int main()
26 {
27     cout<<"Enter A Number:"<<endl;
28     unsigned int number;
29     cin>>number;
30     cout<<Fibonacci(number)<<endl;
31     return 0;
32 }

分析3：最后介绍一种效率最高的算法O(logn)，首先我们有下面的数学公式：

我们可以用数学归纳法证明如下：

Step1: n=2时

Step2：设n=k时，公式成立，则有：

等式两边同乘以[1,1;1,0]矩阵可得：

左=右，这正是n=k+1时的形式，即当n=k+1时等式成立。

由Step1和Step2可知，该数学公式成立。

由此可以知道该问题转化为计算右边矩阵的n-1幂问题。

我们利用分治的算法思想可以考虑如下求解一个数A的幂。

实现这种算法需要定义矩阵，以及矩阵的有关运算，具体代码如下：

 1 #include<iostream>
 2 #include<string>
 3 using namespace std;
 4 
 5 //定义2×2矩阵；
 6 struct Matrix2by2
 7 {
 8     //构造函数
 9     Matrix2by2
10     (
11         long m_00,
12         long m_01,
13         long m_10,
14         long m_11
15     )
16     :m00(m_00),m01(m_01),m10(m_10),m11(m_11)
17     {
18     }
19 
20     //数据成员
21     long m00;
22     long m01;
23     long m10;
24     long m11;
25 };
26 
27 //定义2×2矩阵的乘法运算
28 Matrix2by2 MatrixMultiply(const Matrix2by2& matrix1,const Matrix2by2& matrix2)
29 {
30     Matrix2by2 matrix12(1,1,1,0);
31     matrix12.m00 = matrix1.m00 * matrix2.m00 + matrix1.m01 * matrix2.m10;
32     matrix12.m01 = matrix1.m00 * matrix2.m01 + matrix1.m01 * matrix2.m11;
33     matrix12.m10 = matrix1.m10 * matrix2.m00 + matrix1.m11 * matrix2.m10;
34     matrix12.m11 = matrix1.m10 * matrix2.m01 + matrix1.m11 * matrix2.m11;
35     return matrix12;
36 
37 }
38 
39 
40 //定义2×2矩阵的幂运算
41 Matrix2by2 MatrixPower(unsigned int n)
42 {
43     Matrix2by2 matrix(1,1,1,0);
44     if(n == 1)
45     {
46         matrix = Matrix2by2(1,1,1,0);
47     }
48     else if(n % 2 == 0)
49     {
50         matrix = MatrixPower(n / 2);
51         matrix = MatrixMultiply(matrix, matrix);
52     }
53     else if(n % 2 == 1)
54     {
55         matrix = MatrixPower((n-1) / 2);
56         matrix = MatrixMultiply(matrix, matrix);
57         matrix = MatrixMultiply(matrix, Matrix2by2(1,1,1,0));
58     }
59     return matrix;
60 }
61 //计算Fibnacci的第n项
62 long Fibonacci(unsigned int n)
63 {
64     if(n == 0)
65         return 0;
66     if(n == 1)
67         return 1;
68 
69     Matrix2by2 fibMatrix = MatrixPower(n-1);
70     return fibMatrix.m00;
71     
72 }
73 
74 int main()
75 {
76     cout<<"Enter A Number:"<<endl;
77     unsigned int number;
78     cin>>number;
79     cout<<Fibonacci(number)<<endl;
80     return 0;
81 }

参考文献：

微软、Google等面试题：http://zhedahht.blog.163.com/blog/static/25411174200722991933440/

原文地址：http://www.cnblogs.com/python27/archive/2011/11/25/2261980.html

注：

1）本博客所有的代码环境编译均为win7+VC6。所有代码均经过博主上机调试。

2）博主python27对本博客文章享有版权，网络转载请注明出处http://www.cnblogs.com/python27/。对解题思路有任何建议，欢迎在评论中告知。

矩阵算法：

POJ-3070Fibonacci（矩阵快速幂求Fibonacci数列）

Fibonacci

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 7241		Accepted: 5131

Description

In the Fibonacci integer sequence, F₀ = 0, F₁ = 1, and F_n = F_n_{− 1} + F_n_{− 2} for n ≥ 2. For example, the first ten terms of the Fibonacci sequence are:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …

An alternative formula for the Fibonacci sequence is

Given an integer n, your goal is to compute the last 4 digits of F_n.

Input

The input test file will contain multiple test cases. Each test case consists of a single line containing n (where 0 ≤ n ≤ 1,000,000,000). The end-of-file is denoted by a single line containing the number −1.

Output

For each test case, print the last four digits of F_n. If the last four digits of F_n are all zeros, print ‘0’; otherwise, omit any leading zeros (i.e., print F_n mod 10000).

Sample Input

Sample Output

Hint

As a reminder, matrix multiplication is associative, and the product of two 2 × 2 matrices is given by

Also, note that raising any 2 × 2 matrix to the 0th power gives the identity matrix:

Source

Stanford Local 2006

分析：通过这道题，不仅学会了矩阵的快速幂的做法，同时也提供了求Fibonacci的高效算法

代码一：
这题完全套用的是一般的快速幂的做法，只不过改成矩阵乘法后，为了在做矩阵乘法过程中不会影响结果值，
之间要用中间变量，代码写的很难看（没有想到可以用结构体对二维数组进行封装，可以直接返回结构体类型的数据）,
不过还是 0ms AC。

 1 #include <cstdio>
 2 #include <iostream>
 3 
 4 using namespace std;
 5 
 6 const int MOD = 10000;
 7 
 8 int fast_mod(int n)    // 求 (t^n)%MOD 
 9 {
10     int t[2][2] = {1, 1, 1, 0};
11     int ans[2][2] = {1, 0, 0, 1};  // 初始化为单位矩阵
12     int tmp[2][2];    //自始至终都作为矩阵乘法中的中间变量 
13      
14     while(n)
15     {
16         if(n & 1)  //实现 ans *= t; 其中要先把 ans赋值给 tmp，然后用 ans = tmp * t 
17         {
18             for(int i = 0; i < 2; ++i)
19                 for(int j = 0; j < 2; ++j)
20                     tmp[i][j] = ans[i][j]; 
21             ans[0][0] = ans[1][1] = ans[0][1] = ans[1][0] = 0;  // 注意这里要都赋值成 0 
22             
23             for(int i = 0; i < 2; ++i)    //  矩阵乘法 
24             {
25                 for(int j = 0; j < 2; ++j)
26                 {
27                     for(int k = 0; k < 2; ++k)
28                         ans[i][j] = (ans[i][j] + tmp[i][k] * t[k][j]) % MOD;
29                 }
30             }
31         }
32         
33         //  下边要实现  t *= t 的操作，同样要先将t赋值给中间变量  tmp ，t清零，之后 t = tmp* tmp 
34         for(int i = 0; i < 2; ++i)
35             for(int j = 0; j < 2; ++j)
36                 tmp[i][j] = t[i][j];
37         t[0][0] = t[1][1] = 0;
38         t[0][1] = t[1][0] = 0;
39         for(int i = 0; i < 2; ++i)
40         {
41             for(int j = 0; j < 2; ++j)
42             {
43                 for(int k = 0; k < 2; ++k)
44                     t[i][j] = (t[i][j] + tmp[i][k] * tmp[k][j]) % MOD;
45             }
46         }
47         
48         n >>= 1;
49     }
50     return ans[0][1];
51 }
52 
53 int main()
54 {
55     int n;
56     while(scanf("%d", &n) && n != -1)
57     {    
58         printf("%d\n", fast_mod(n));
59     }
60     return 0;
61 }

代码二：用结构体封装矩阵乘法后，代码看着清晰多了

 1 #include <cstdio>
 2 #include <iostream>
 3 
 4 using namespace std;
 5 
 6 const int MOD = 10000;
 7 
 8 struct matrix
 9 {
10     int m[2][2];
11 }ans, base;
12 
13 matrix multi(matrix a, matrix b)
14 {
15     matrix tmp;
16     for(int i = 0; i < 2; ++i)
17     {
18         for(int j = 0; j < 2; ++j)
19         {
20             tmp.m[i][j] = 0;
21             for(int k = 0; k < 2; ++k)
22                 tmp.m[i][j] = (tmp.m[i][j] + a.m[i][k] * b.m[k][j]) % MOD;
23         }
24     }
25     return tmp;
26 }
27 int fast_mod(int n)  // 求矩阵 base 的  n 次幂 
28 {
29     base.m[0][0] = base.m[0][1] = base.m[1][0] = 1;
30     base.m[1][1] = 0;
31     ans.m[0][0] = ans.m[1][1] = 1;  // ans 初始化为单位矩阵 
32     ans.m[0][1] = ans.m[1][0] = 0;
33     while(n)
34     {
35         if(n & 1)  //实现 ans *= t; 其中要先把 ans赋值给 tmp，然后用 ans = tmp * t 
36         {
37             ans = multi(ans, base);
38         }
39         base = multi(base, base);
40         n >>= 1;
41     }
42     return ans.m[0][1];
43 }
44 
45 int main()
46 {
47     int n;
48     while(scanf("%d", &n) && n != -1)
49     {   
50         printf("%d\n", fast_mod(n));
51     }
52     return 0;
53 }