题目：定义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/。对解题思路有任何建议，欢迎在评论中告知。
矩阵算法：
| Time Limit: 1000MS | Memory Limit: 65536K | |
| Total Submissions: 7241 | Accepted: 5131 |
Description
In the Fibonacci integer sequence, F0 = 0, F1 = 1, and Fn = Fn − 1 + Fn − 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 Fn.
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 Fn. If the last four digits of Fn are all zeros, print ‘0’; otherwise, omit any leading zeros (i.e., print Fn mod 10000).
Sample Input
0 9 999999999 1000000000 -1
Sample Output
0 34 626 6875
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
这题完全套用的是 一般的快速幂的做法，只不过改成矩阵乘法后，为了在做矩阵乘法过程中不会影响结果值，
之间要用中间变量，代码写的很难看 （没有想到可以用结构体对二维数组进行封装，可以直接返回结构体类型的数据）,
不过还是 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 }
432
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
