矩阵快速幂模板

问题：求解一个N*N矩阵的 M次幂。

核心：构造矩阵。

思想：利用二进制优化时间复杂度。

应用：优化递归公式！！！

举例：求解第N个斐波那契数。

  

代码实现：

[cpp] view plain copy

1. #include <cstdio>  
2. #include <cstring>  
3. #include <algorithm>  
4. #define MAXN 100  
5. #define LL long long  
6. #define MOD 10000  
7. using namespace std;  
8. struct Matrix  
9. {  
10.     LL a[MAXN][MAXN];  
11.     int r, c;//行数 列数  
12. };  
13. Matrix ori, res;//初始矩阵 和 结果矩阵  
14. void init(int n)//初始化矩阵  
15. {  
16.     memset(res.a, 0, sizeof(res.a));  
17.     res.r = res.c = n;  
18.     for(int i = 1; i <= n; i++)//构造单位矩阵  
19.         res.a[i][i] = 1;  
20.     ori.r = ori.c = n;  
21.     //输入初始矩阵  
22.     for(int i = 1; i <= n; i++)  
23.     {  
24.         for(int j = 1; j <= n; j++)  
25.             scanf("%lld", &ori.a[i][j]);  
26.     }  
27. }  
28. Matrix multi(Matrix x, Matrix y)  
29. {  
30.     Matrix z;  
31.     memset(z.a, 0, sizeof(z.a));  
32.     z.r = x.r, z.c = y.c;//新矩阵行数等于x矩阵的行数 列数等于y矩阵的列数  
33.     for(int i = 1; i <= x.r; i++)//x矩阵的行数  
34.     {  
35.         for(int k = 1; k <= x.c; k++)//矩阵x的列数等于矩阵y的行数 即x.c = y.r  
36.         {  
37.             if(x.a[i][k] == 0) continue;//x矩阵的第i行第k列的数为0不用计算  优化  
38.             for(int j = 1; j<= y.c; j++)//y矩阵的列数  
39.                 z.a[i][j] += x.a[i][k] * y.a[k][j];  
40.         }  
41.     }  
42.     return z;  
43. }  
44. void Matrix_mod(int n, int m)  
45. {  
46.     while(m)//M次幂  二进制优化  
47.     {  
48.         if(m & 1)  
49.             res = multi(ori, res);  
50.         ori = multi(ori, ori);  
51.         m >>= 1;  
52.     }  
53.     //得到最后的矩阵  
54.     for(int i = 1; i <= n; i++)  
55.     {  
56.         for(int j = 1; j <= n; j++)  
57.             printf("%lld ", res.a[i][j]);  
58.         printf("\n");  
59.     }  
60. }  
61. int main()  
62. {  
63.     int N, M;  
64.     while(scanf("%d%d", &N, &M) != EOF)  
65.     {  
66.         init(N);//初始化单位矩阵  输入原矩阵  
67.         Matrix_mod(N, M);//矩阵快速幂  
68.     }  
69.     return 0;  
70. }  

输入：

[cpp] view plain copy

1. 2 9  
2. 1 1  
3. 1 0  
4. 2 8  
5. 1 1  
6. 1 0  

输出：

[cpp] view plain copy

1. 55 34  
2. 34 21  
3. 34 21  
4. 21 13