快速幂和矩阵快速幂

╰+攻爆jí腚メ 2022-06-01 08:10 421阅读 0赞

前言

新年第一篇技术类的文章，应该算是算法方面的文章的。看标题：快速幂和矩阵快速幂，好像挺高大上。其实并不是很难，快速幂就是快速求一个数的幂（一个数的 n 次方）。

快速幂

首先，来看一下幂，我们知道，假设有一个整数 x， 如果我们要求出 x^n （即为 x 的 n 次方）的值，最容易想到的办法就是循环相乘（这里不考虑整数溢出的情况下），于是我们很容易就可以写出下面的代码：

  1. int res = 1;
  2. for (int i = 0; i < n; i++) {
  3.     res *= x;
  4. }

咋一看，嗯，很正常的代码。确实是挺正常的代码，其时间复杂度为 O(n)。其实这个问题的时间复杂度可以降到 O(logn) 。那么问题来了，怎么做到的? 其实，就是通过快速幂的方法。

先来举个例子：假设我们现在要求出 5^9 的值，不用我们刚刚直接循环的方法，换种思维，我们可以这样看：

  1. 5^9 = 5*5^8 = 5*((5^4)^2) = 5*(5^4)*(5^4)
  2. 5^4 = ((5^2)^2) = (5^2)*(5^2)
  3. 5^2 = 5*5

如果当前的指数是偶数，我们把指数拆成两半，得到两个相同的数，然后把这两个相同的数相乘，可以得到原来的数；
如果当前的指数是奇数，我们把指数拆成两半，得到两个相同的数，此时还剩余一个底数，把这两个相同的数和剩余的底数这三个数相乘，可以得到原来的数。

那么如果说我们按照这种思路去计算 5^9 的值的话，我们会发现只需要执行 3 次计算。相比原来的直接用循环的 9 次计算，正好是 log9 的整数部分值。Ok，那么怎么用代码写出来呢？这里先给出代码，再做解释：

  1. /**
  2.  * 计算 x^n 的值，并将结果保存在 res 中
  3.  */
  4. long long res = 1;
  5. // 进行快速幂运算，n 为当前的指数值，n 为 0 的时候运算结束
  6. while (n) {
  7.     // 用位运算的方式判断 n 是否为奇数，速度更快，等价于 n%2 
  8.     if (n & 1) {
  9.         // 如果 n 是奇数，那么需要将 x 存入运算结果中
  10.         res *= x;
  11.     }
  12.     // 更新当前的 x 的值
  13.     x *= x;
  14.     // 用位运算的方式进行 n/2，速度更快，等价于 n/=2
  15.     n >>= 1;
  16. }

首先，我们注意到，不管当前的指数值（n 的值）是奇数还是偶数，一次运算之后 n 都要拆成两半（n /= 2），所以，我们在每次运算的时候都要让当前的 x *= x ，也就是执行 x = x^2，这点相信不难理解。

第二，当 n 为奇数的时候，如果执行 n /= 2，结果会使得 n 损失一个 1。举个例子：假设此时 n = 9，9 / 2 = 4 ，即使我们之后会执行 x *= x，也只是把 n 的一半 (4) 补回来了，还少了个 1 （4+4+1 = 9）。因此此时要把少了的那一个 x 存入结果中，即为执行 res *= x;

第三，只要 n 的初始值是大于 0 的（其余的数需要特殊处理），那么在运算过程中一直执行 n >>= 1，也就是将 n 除以 2 ，n 是一定会等于 1 的，此时执行 res *= x，将最后的结果保存在 res 中，之后退出循环。

最后，整个循环每一次执行 n 都变成原来的一半，当 n 等于 0 的时候结束，时间复杂度为 O(logn)

这里给出一个快速幂的完整代码：

  1. /**
  2.  * Describe：实现快速幂 
  3.  * Author：指点
  4.  * Date：2018/1/24 
  5.  */ 
  6. #include <iostream>
  7. #include <cstdlib>
  8. using namespace std;
  10. // 使用快速幂求出 x^n 的值并返回，不考虑高精度，请控制参数范围
  11. double myPow(double x, int n) {
  12.     // 任何不是 0 的数的 0 次幂为 1 
  13.     if (x && n == 0) {
  14.         return 1;
  15.     } else if (x == 0 && n == 0) {
  16.         exit(1);
  17.     }
  18.     // 如果 n 是负数，那么返回结果要进行处理 
  19.     bool nIsNegative = false;
  20.     if (n < 0) {
  21.         nIsNegative = true;
  22.         n = -n;
  23.     }
  25.     double res = 1;
  26.     while (n) {
  27.         // 用位运算的方式判断 n 是否为奇数，速度更快，等价于 n%2 
  28.         if (n & 1) {
  29.             res *= x;
  30.         }
  31.         x *= x;
  32.         // 用位运算的方式进行 n/2，速度更快，等价于 n/=2
  33.         n >>= 1;
  34.     }
  35.     // n 是负数？1.0/res 否则 res 
  36.     return nIsNegative ? 1.0/res : res;
  37. } 
  39. int main() {
  40.     double x;
  41.     int n;
  43.     while (cin >> x >> n) {
  44.         cout << myPow(x, n) << endl << endl; 
  45.     } 
  47.     return 0;
  48. }

来看看结果：

这里写图片描述

理解了上面的几点，相信快速幂就难不到你了。下面来看看矩阵快速幂：

矩阵快速幂

其实矩阵快速幂的思想是和快速幂一样的，矩阵快速幂是用于快速求出一个矩阵的 n 次方的方法。

首先，我们要知道，两个矩阵能不能相乘是有一定条件的：
假设有两个矩阵 A, B。如果矩阵 A 的列数等于矩阵 B 的行数，那么这两个矩阵才可以进行相乘，否则这两个矩阵是不能相乘的。
对于这里，我们要求的是一个矩阵的 n 次方，那么既然是同一个矩阵，那么只有当其为方阵（行数和列数相同的矩阵）的时候，才可以相乘。矩阵相乘结果也是一个矩阵，具体的规则为：如果矩阵 A 的列数等于矩阵 B 的行数，假设矩阵 C = A*B， 那么矩阵 Ｃ 的行数和矩阵 A 的行数相等，矩阵 C 的列数和矩阵 B 相等。矩阵 C 的第一行第一列元素等于矩阵 A 的第一行的元素和矩阵 B 的第一列的元素依次相乘再求和。矩阵 C 的第一行第二列元素等于矩阵 A 的第一行的元素和矩阵 B 的第二列的元素依次相乘再求和。。。。。。矩阵 C 的第 n 行第 m 列元素等于矩阵 A 的第 n 行的元素和矩阵 B 的第 m 列的元素依次相乘再求和。依次类推。

这里给出一个求出两矩阵相乘的结果的函数：

  1. // 计算矩阵 a(m*s 规模) 和矩阵 b(s*n 规模) 相乘的结果，并将结果返回 
  2. int **matrixMultiply(int **a, int **b, int m, int s, int n) {
  3.     // 初始化储存结果的数组 
  4.     int **result = new int*[m];
  5.     for (int i = 0; i < m; i++) {
  6.         result[i] = new int[n];
  7.         memset(result[i], 0, sizeof(int)*n);
  8.     }
  9.     // 进行矩阵相乘计算 
  10.     for (int i = 0; i < m; i++) {
  11.         for (int j = 0; j < n; j++) {
  12.             for (int k = 0; k < s; k++) {
  13.                 result[i][j] += a[i][k]*b[k][j];
  14.             }
  15.         }
  16.     } 
  17.     return result;
  18. }

这里用的是二级指针作为参数和返回值来表示对应的矩阵。来测试一下这个函数：

  1. /**
  2.  * Describe：实现矩阵相乘
  3.  * Author：指点
  4.  * Date：2018/1/24  
  5.  */
  6. #include <iostream>
  7. #include <cstring>
  8. using namespace  std;
  10. // 计算矩阵 a(m*s 规模) 和矩阵 b(s*n 规模) 相乘的结果，并将结果返回 
  11. int **matrixMultiply(int **a, int **b, int m, int s, int n) {
  12.     // 初始化储存结果的数组 
  13.     int **result = new int*[m];
  14.     for (int i = 0; i < m; i++) {
  15.         result[i] = new int[n];
  16.         memset(result[i], 0, sizeof(int)*n);
  17.     }
  18.     // 进行矩阵相乘计算 
  19.     for (int i = 0; i < m; i++) {
  20.         for (int j = 0; j < n; j++) {
  21.             for (int k = 0; k < s; k++) {
  22.                 result[i][j] += a[i][k]*b[k][j];
  23.             }
  24.         }
  25.     } 
  26.     return result;
  27. }
  29. int main() {
  30.     int m = 2, s = 3, n = 2;
  31.     // 初始化 a 、b 两个矩阵
  32.     int **a = new int*[m];
  33.     for (int i = 0; i < m; i++) {
  34.         a[i] = new int[s];
  35.     } 
  36.     int **b = new int*[s];
  37.     for (int i = 0; i < s; i++) {
  38.         b[i] = new int[n];
  39.     }
  40.     cout << "a 矩阵：" << endl;
  41.     for (int i = 0; i < m; i++) {
  42.         for (int j = 0; j < s; j++) {
  43.             a[i][j] = i + j;
  44.             cout << a[i][j] << " ";
  45.         }
  46.         cout << endl;
  47.     }
  48.     cout << "b 矩阵：" << endl;
  49.     for (int i = 0; i < s; i++) {
  50.         for (int j = 0; j < n; j++) {
  51.             b[i][j] = i + j;
  52.             cout << b[i][j] << " ";
  53.         }
  54.         cout << endl;
  55.     }
  57.     int **res = matrixMultiply(a, b, 2, 3, 2);
  58.     // 结果是一个 2 行 2 列的数组 
  59.     cout << "相乘的结果矩阵：" << endl;
  60.     for (int i = 0; i < 2; i++) {
  61.         for (int j = 0; j < 2; j++) {
  62.             cout << res[i][j] << " ";
  63.         }
  64.         cout << endl;
  65.     }
  67.     // 释放申请的内存空间 
  68.     if (a != NULL) {
  69.         for (int i = 0; i < m; i++) {
  70.             delete[] a[i];
  71.         }
  72.         delete[] a;
  73.         a = NULL;
  74.     }
  75.     if (b != NULL) {
  76.         for (int i = 0; i < s; i++) {
  77.             delete[] b[i];
  78.         }
  79.         delete[] b;
  80.         b = NULL;
  81.     }
  82.     if (res != NULL) {
  83.         for (int i = 0; i < m; i++) {
  84.             delete[] res[i];
  85.         }
  86.         delete[] res;
  87.         res = NULL;
  88.     }
  89.     return 0;
  90. }

来看一下结果：

这里写图片描述

Ok，给定数据测试正确，有了这个函数，我们写矩阵快速幂的代码就简单了，我们把矩阵看成一个数，矩阵乘法的函数我们已经写好了，那么我们仿照快速幂的写法，实现矩阵快速幂：

  1. /**
  2.  * Describe：实现矩阵快速幂 
  3.  * Author：指点
  4.  * Date：2018/1/24  
  5.  */
  6. #include <iostream>
  7. #include <cstring>
  8. using namespace  std;
  10. // 删除数组空间的函数，数组行数：m
  11. void deleteArray(int **a, int m) {
  12.     if (a != NULL) {
  13.         for (int i = 0; i < m; i++) {
  14.             delete[] a[i];
  15.         } 
  16.         delete[] a;
  17.         a = NULL;
  18.     }
  19. }
  21. // 计算矩阵 a(m*s 规模) 和矩阵 b(s*n 规模) 相乘的结果，并将结果返回 
  22. int **matrixMultiply(int **a, int **b, int m, int s, int n) {
  23.     // 初始化储存结果的数组 
  24.     int **result = new int*[m];
  25.     for (int i = 0; i < m; i++) {
  26.         result[i] = new int[n];
  27.         memset(result[i], 0, sizeof(int)*n);
  28.     }
  29.     // 进行矩阵相乘计算 
  30.     for (int i = 0; i < m; i++) {
  31.         for (int j = 0; j < n; j++) {
  32.             for (int k = 0; k < s; k++) {
  33.                 result[i][j] += a[i][k]*b[k][j];
  34.             }
  35.         }
  36.     } 
  37.     return result;
  38. }
  40. // 用快速幂求出矩阵 a(m*m 规模，只有方阵才可以自我相乘) 的 n 次方，并将结果返回 
  41. int **myMatrixPow(int **a, int m, int n) {
  42.     // 初始化保存结果的矩阵 
  43.     int **res = new int*[m];
  44.     for (int i = 0; i < m; i++) {
  45.         res[i] = new int[m];
  46.         memset(res[i], 0, sizeof(int)*m);
  47.         // 保存结果的矩阵初始应该是一个单位矩阵(正向斜对角线值为 1，其余为 0) 
  48.         res[i][i] = 1;
  49.     } 
  50.      // 保存要删除的数组空间的指针 
  51.     int **oldPoint = NULL;
  52.     while (n) {
  53.         if (n & 1) {
  54.             // 保存 res 指针当前的内存地址 
  55.             oldPoint = res; 
  56.             // res 指向储存矩阵相乘结果的数组的地址 
  57.             res = matrixMultiply(res, a, m, m, m); 
  58.             // 删除 res 指针原有的内存空间 
  59.             deleteArray(oldPoint, m); 
  60.         }
  61.         // 保存 a 指针当前的内存地址 
  62.         oldPoint = a;
  63.         // a 指向储存矩阵相乘结果的数组的地址  
  64.         a = matrixMultiply(a, a, m, m, m); 
  65.         // 删除 a 指针原有的内存空间 
  66.         deleteArray(oldPoint, m); 
  68.         n >>= 1; 
  69.     }
  70.     return res;
  71. } 
  73. int main() {
  74.     int m = 2;
  75.     // 初始化 a 方阵 
  76.     int **a = new int*[m];
  77.     for (int i = 0; i < m; i++) {
  78.         a[i] = new int[m];
  79.     } 
  80.     cout << "a 矩阵：" << endl;
  81.     for (int i = 0; i < m; i++) {
  82.         for (int j = 0; j < m; j++) {
  83.             a[i][j] = i + j;
  84.             cout << a[i][j] << " ";
  85.         }
  86.         cout << endl;
  87.     }
  89.     cout << endl;
  90.     for (int i = 0; i < 10; i++) {
  91.         // 计算结果 
  92.         int **res = myMatrixPow(a, m, i);
  93.         cout << "a 矩阵的 " << i << " 次方计算结果：" << endl;
  94.         for (int i = 0; i < 2; i++) {
  95.             for (int j = 0; j < 2; j++) {
  96.                 cout << res[i][j] << " ";
  97.             }
  98.             cout << endl;
  99.         }
  100.         // 释放 res 指针的内存空间 
  101.         deleteArray(res, m);
  102.     }
  103.     // 最后释放 a 指针的内存空间
  104.     deleteArray(a, m);
  106.     return 0;
  107. }

关键函数就是 myMatrixPow ，我想有了快速幂的基础，这个函数也不难理解了。代码里面有较多的指针操作，所以专门写了一个函数 deleteArray 来释放程序运行过程中所申请的堆内存空间，其实不主动释放，等程序结束后让操作系统回收也是可以的，不过个人有点强迫症…..哈哈。看代码不难理解利用矩阵快速幂求方阵的幂的时间复杂度为O(m^3*logn)，m为方阵的行数和列数（方阵相乘的复杂度为 O(m^3)，快速幂的复杂度为 O(logn) ）。
好了， 来看一下结果：

这里写图片描述

如果有兴趣的话，你可以自己验算一下结果的正确性。

应用

那么看了这么多，快速幂有啥子用呢？
首先对于求一个数的 n 次方，可以用 O(logn) 的时间复杂度来求出结果，这肯定是一个用途，那么矩阵快速幂呢？
不知道你还记不记得斐波那契数列的递推公式，斐波那契数列的递推公式可以写成：

  1. 如果 n > 2，那么 f(n) = f(n-1) + f(n-2);
  2. 如果 n = 2 或者 n = 1，那么 f(n) = 1

那么如果现在要求 f(n) 的值呢，根据递推公式我们可以很快的写出下面的代码（不考虑整数溢出的情况）：

  1. typedef long long ll;
  3. ll getFibo(int n) {
  4.     if (n == 1 || n == 2) {
  5.         return 1;
  6.     }
  7.     return getFibo(n-1) + getFibo(n-2);
  8. }

这个代码的时间复杂度大约是 O(2^n)，其执行过程就是一颗二叉树，里面进行了很多的重复运算。
当然也有循环版本的（不考虑整数溢出的情况）：

  1. typedef long long ll;
  3. ll getFibo(int n) {
  4.     ll first = 1, second = 1, res = 0;
  5.     for (int i = 3; i <= n; i++) {
  6.         res = first + second;
  7.         first = second;
  8.         second = res;
  9.     }
  10.     return res;
  11. }

这个代码的时间复杂度为 O(n)，比递归的方法好。
这两种方法都可以求解，但是可以有更高效的方法，就是利用矩阵快速幂。
不过咋一看这怎么和矩阵快速幂联系到一起呢？要用矩阵快速幂，我们得先有矩阵：

假设我们现在有一个一行两列的矩阵：A【f(n-2), f(n-1)】，我们设定一个 2*2 的矩阵 T，使得矩阵 A*T 相乘的结果等于另外一个一行两列的矩阵 C：【f(n-1), f(n)】。
我们根据给定条件和斐波那契的递推公式可以很容易构造出矩阵 T：

0 1
1 1

构造过程就是矩阵 A*T 的计算过程：

【f(n-2)*0 + f(n-1)*1 = f(n-1), f(n-2)*1 + f(n-1)*1 = f(n)】

Ok，那么我们知道 【f(n-2), f(n-1)】* T = 【f(n-1), f(n)】，
那么可以推出：【f(n-3), f(n-2)】* T*T = 【f(n-1), f(n)】，【f(n-4), f(n-3)】* T*T*T = 【f(n-1), f(n)】…….
也就是：【f(1), f(2)】 * T^(n-2) = 【f(n-1), f(n)】，
f(1)=1, f(2)=1, 也就是：【1, 1】*T^(n-2) = 【f(n-1), f(n)】

现在在看一下我们是不是有了 T^(n-2) 这个矩阵求幂的条件，那么我们就可以用矩阵快速幂来求解这道题了：

  1. /**
  2.  * Describe：利用矩阵快速幂求斐波那契数列的第 n 项值
  3.  * Author：指点
  4.  * Date：2018/1/24  
  5.  */
  6. #include <iostream>
  7. #include <cstring>
  8. using namespace std;
  10. typedef long long ll;
  12. // f(1) 和 f(2) 的值 
  13. const ll START[] = {
  14.    1, 1}; 
  15. // 矩阵 T 
  16. ll **T = NULL;
  18. // 删除数组空间的函数，数组行数：m
  19. void deleteArray(ll **a, int m) {
  20.     if (a != NULL) {
  21.         for (int i = 0; i < m; i++) {
  22.             delete[] a[i];
  23.         } 
  24.         delete[] a;
  25.         a = NULL;
  26.     }
  27. }
  29. // 计算矩阵 a(m*s 规模) 和矩阵 b(s*n 规模) 相乘的结果，并将结果返回 
  30. ll **matrixMultiply(ll **a, ll **b, int m, int s, int n) {
  31.     // 初始化储存结果的数组 
  32.     ll **result = new ll*[m];
  33.     for (int i = 0; i < m; i++) {
  34.         result[i] = new ll[n];
  35.         memset(result[i], 0, sizeof(ll)*n);
  36.     }
  37.     // 进行矩阵相乘计算 
  38.     for (int i = 0; i < m; i++) {
  39.         for (int j = 0; j < n; j++) {
  40.             for (int k = 0; k < s; k++) {
  41.                 result[i][j] += a[i][k]*b[k][j];
  42.             }
  43.         }
  44.     } 
  45.     return result;
  46. }
  48. // 求出矩阵 a(m*m 规模，只有方阵才可以自我相乘) 的 n 次方，并将结果返回 
  49. ll **myMatrixPow(ll **a, int m, int n) {
  50.     // 初始化保存结果的矩阵 
  51.     ll **res = new ll*[m];
  52.     for (int i = 0; i < m; i++) {
  53.         res[i] = new ll[m];
  54.         memset(res[i], 0, sizeof(ll)*m);
  55.         // 保存结果的矩阵初始应该是一个单位矩阵(正向斜对角线值为 1，其余为 0) 
  56.         res[i][i] = 1;
  57.     } 
  58.      // 保存要删除的数组空间的指针 
  59.     ll **oldPoint = NULL;
  60.     while (n) {
  61.         if (n & 1) {
  62.             // 保存 res 指针当前的内存地址 
  63.             oldPoint = res; 
  64.             // res 指向储存矩阵相乘结果的数组的地址 
  65.             res = matrixMultiply(res, a, m, m, m); 
  66.             // 删除 res 指针原有的内存空间 
  67.             deleteArray(oldPoint, m); 
  68.         }
  69.         // 保存 a 指针当前的内存地址 
  70.         oldPoint = a;
  71.         // a 指向储存矩阵相乘结果的数组的地址  
  72.         a = matrixMultiply(a, a, m, m, m); 
  73.         // 删除 a 指针原有的内存空间 
  74.         deleteArray(oldPoint, m); 
  76.         n >>= 1; 
  77.     }
  78.     return res;
  79. } 
  81. // 求出斐波那契数列的第 n 项的值，不考虑整数溢出，请控制数字范围 
  82. ll getFibo(int n) {
  83.     if (n == 1 || n == 2) {
  84.         return 1;
  85.     }
  86.     ll res = 0;
  87.     // 求出 T 矩阵的 n-2 次方(T^n-2)的值，并将结果保存在 T 指针中
  88.     T = myMatrixPow(T, 2, n-2); 
  89.     // 求出最后的 f(n) 的值(res += START[i]*T[i][0] 为 f(n-1) 的值，res += START*T[i][1] 为 f(n) 的值)
  90.     for (int i = 0; i < 2; i++) {
  91.         res += START[i]*T[i][1];
  92.     }
  93.     return res;
  94. }
  96. int main() {
  97.     // 初始化矩阵 T，元素值通过计算求得 
  98.     T = new ll*[2];
  99.     T[0] = new ll[2];
  100.     T[1] = new ll[2];
  102.     for (int i = 1; i < 80; i++) {
  103.         /**
  104.          * 矩阵 T 元素值： 
  105.          * 0 1
  106.          * 1 1
  107.          */
  108.         T[0][0] = 0;
  109.         T[0][1] = T[1][0] = T[1][1] = 1;
  110.         cout << "第" << i << "项斐波那契数列的值："; 
  111.         cout << getFibo(i) << endl;
  112.     }
  113.     deleteArray(T, 2);
  115.     return 0;
  116. }

和矩阵快速幂差不多的代码，如果你理解了矩阵快速幂的思想的话，我想这代码也很好理解，这里我们可以看到，用这种方法求斐波那契数列的时间复杂度约为 O(2^3*logn)，也就是求矩阵的幂的时间复杂度。忽略常数，即为O(logn)。
有图有真相，最后来看一下结果：

这里写图片描述

其实类似于斐波那契数列这种利用递推式来求值的问题都可以通过矩阵快速幂来解决，这其中主要的问题就是怎么构造那个矩阵。关于这点，可以参考下这篇文章：
http://www.cnblogs.com/frog112111/archive/2013/05/19/3087648.html

如果说练习题的话，可以试试下面的：
http://poj.org/problem?id=3070
http://lx.lanqiao.cn/problem.page?gpid=T396（）

Ok，如果博客中有什么不正确的地方，请多多指点，如果觉得本文对您有帮助，请不要吝啬您的赞。
谢谢观看。。。

发表评论

表情：
评论列表 （有 0 条评论，421人围观）

还没有评论，来说两句吧...

相关阅读

    相关 矩阵快速幂

    昨天晚上矩阵小王子给我们讲了一下矩阵快速幂，学习了一下，写了一个模板。 1：思想 矩阵快速幂的思想就是跟数的快速幂一样，假如我们要求2^11，次方，我们可以把 11 写成

    Love The Way You LieLove The Way You Lie/ 0 赞/ 347 阅读

    相关 矩阵快速幂

    A为一个方阵，则Tr A表示A的迹（就是主对角线上各项的和），现要求Tr(A^k)%9973。  Input 数据的第一行是一个T，表示有T组数据。  每组数据的

    谁践踏了优雅谁践踏了优雅/ 0 赞/ 354 阅读

    相关 快速幂和矩阵快速幂

    前言 新年第一篇技术类的文章，应该算是算法方面的文章的。看标题：快速幂和矩阵快速幂，好像挺高大上。其实并不是很难，快速幂就是快速求一个数的幂（一个数的 n 次方）。

    ╰+攻爆jí腚メ╰+攻爆jí腚メ/ 0 赞/ 422 阅读

    相关 矩阵快速幂

    通常我们使用的快速幂是以二为底的，这次就遇到了一道以10为底的快速幂题目； 先说下快速幂 long long power(long long a,long long

    桃扇骨桃扇骨/ 0 赞/ 479 阅读