算法学习：快速幂

原创于 2025-08-19 14:14:08 发布 · 1.3k 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #快速幂

深入理解快速幂算法：原理、实现与优化（C++版）

一、快速幂算法概述

快速幂（Fast Exponentiation），又称二进制取幂（Exponentiation by Squaring），是一种高效计算大数幂运算的算法。传统幂运算的时间复杂度为O(n)，而快速幂算法通过分治策略将其优化至O(log n)，在处理大指数时优势尤为明显。

1.1 为什么需要快速幂？

考虑计算3^100：

传统方法：进行99次乘法（3×3×…×3）
快速幂：仅需约log₂100 ≈ 7次乘法

当指数达到1e9量级时，传统方法完全不可行，而快速幂仍能高效计算。

二、快速幂数学原理

2.1 基本原理

快速幂基于以下数学性质：

平方性质：a^b = (a^(b/2))2 （当b为偶数）
奇偶分解：a^b = a × a^(b-1) （当b为奇数）

2.2 二进制视角

以3^13为例：
13的二进制表示为1101，因此：
3^13 = 3^(8+4+1) = 3^8 × 3^4 × 3^1

通过预处理3的2^k次幂（31, 3^2, 3^4, 3^8），只需将对应位为1的部分相乘即可。

三、快速幂C++实现

3.1 递归实现

long long fastPow(long long base, long long power) {
    if (power == 0) return 1;
    long long half = fastPow(base, power / 2);
    if (power % 2 == 0) {
        return half * half;
    } else {
        return half * half * base;
    }
}

时间复杂度分析：T(n) = T(n/2) + O(1) ⇒ O(log n)

3.2 迭代实现（推荐）

long long fastPow(long long base, long long power) {
    long long result = 1;
    while (power > 0) {
        if (power % 2 == 1) {  // 或 power & 1
            result *= base;
        }
        base *= base;
        power /= 2;  // 或 power >>= 1
    }
    return result;
}

优化技巧：

用位运算代替除法/取模：power & 1判断奇偶，power >>= 1代替除法
初始结果设为1（a^0=1）
每次循环将base平方，根据power的二进制位决定是否乘入结果

四、快速幂的模运算应用

在密码学和大数计算中，常需要计算(a^b) mod m。直接计算可能溢出，结合快速幂可高效解决：

4.1 模幂运算实现

long long modPow(long long base, long long power, long long mod) {
    base %= mod;  // 先取模防止初始base过大
    long long result = 1;
    while (power > 0) {
        if (power & 1) {
            result = (result * base) % mod;
        }
        base = (base * base) % mod;
        power >>= 1;
    }
    return result;
}

特性：

(a × b) mod m = [(a mod m) × (b mod m)] mod m
每次乘法后立即取模，避免溢出
时间复杂度仍为O(log n)

五、快速幂的典型应用场景

5.1 大数模逆元计算

费马小定理指出：若p为质数，a与p互质，则a^(p-1) ≡ 1 mod p ⇒ a^(-1) ≡ a^(p-2) mod p

long long modInverse(long long a, long long p) {
    return modPow(a, p-2, p);
}

5.2 矩阵快速幂

快速幂思想可推广到矩阵运算，用于高效计算递推关系（如斐波那契数列）：

vector<vector<long long>> matrixPow(vector<vector<long long>>& mat, int power) {
    int n = mat.size();
    vector<vector<long long>> result(n, vector<long long>(n, 0));
    // 初始化为单位矩阵
    for (int i = 0; i < n; ++i) result[i][i] = 1;
    
    while (power > 0) {
        if (power & 1) {
            result = matrixMultiply(result, mat);
        }
        mat = matrixMultiply(mat, mat);
        power >>= 1;
    }
    return result;
}

5.3 组合数计算

Lucas定理结合快速幂可高效计算大组合数模质数：

const int P = 1e9+7;
vector<long long> fact(1e6+1, 1);  // 预计算阶乘

void initFact() {
    for (int i = 1; i <= 1e6; ++i) 
        fact[i] = fact[i-1] * i % P;
}

long long comb(int n, int k) {
    if (k > n) return 0;
    return fact[n] * modInverse(fact[k], P) % P * modInverse(fact[n-k], P) % P;
}

六、快速幂的边界处理与优化

6.1 边界情况处理

零指数：a^0 = 1（所有实现都应处理）
负指数：a^(-b) = 1/(a^b)（需浮点数或模逆元）
零的零次方：数学上未定义，编程中通常视为1
大数溢出：使用更大的数据类型（如__int128）或及时取模

6.2 性能优化技巧

循环展开：对特定指数范围手动展开循环
Montgomery乘法：优化模运算性能
并行计算：对大指数分解并行计算
查表法：对常用指数预计算结果

七、快速幂算法扩展

7.1 快速乘（防止溢出）

当模数接近数据类型上限时，乘法可能溢出，可用快速乘代替：

long long fastMul(long long a, long long b, long long mod) {
    long long res = 0;
    while (b > 0) {
        if (b & 1) res = (res + a) % mod;
        a = (a + a) % mod;
        b >>= 1;
    }
    return res;
}

7.2 多进制快速幂

除二进制分解外，还可采用更高进制（如三进制）分解：

long long ternaryPow(long long base, long long power) {
    long long res = 1;
    while (power > 0) {
        int rem = power % 3;
        if (rem == 1) res *= base;
        else if (rem == 2) res *= base * base;
        base *= base * base;
        power /= 3;
    }
    return res;
}

八、实战练习建议

基础题目：
- 计算3^1000000007的最后四位数字
- 实现斐波那契数列O(log n)解法
进阶挑战：
- 解决「超级次方」（LeetCode 372）
- 实现Miller-Rabin素性测试
竞赛应用：
- 大组合数取模计算
- 线性递推关系快速求解

九、总结与展望

快速幂算法展示了如何通过数学洞察将O(n)优化为O(log n)。掌握它不仅有助于解决具体问题，更能培养分治思维和二进制视角。现代密码学（如RSA）、图形学中的变换矩阵计算等领域都依赖快速幂的高效实现。

未来发展方向：

量子计算中的模幂优化
分布式环境下的快速幂算法
特定硬件（GPU/FPGA）上的并行实现

附录：完整测试代码

#include <iostream>
#include <vector>
using namespace std;

// 快速幂迭代实现
long long fastPow(long long base, long long power) {
    long long res = 1;
    while (power) {
        if (power & 1) res *= base;
        base *= base;
        power >>= 1;
    }
    return res;
}

// 带模数的快速幂
long long modPow(long long base, long long power, long long mod) {
    base %= mod;
    long long res = 1;
    while (power) {
        if (power & 1) res = res * base % mod;
        base = base * base % mod;
        power >>= 1;
    }
    return res;
}

int main() {
    cout << "2^10 = " << fastPow(2, 10) << endl;  // 1024
    cout << "3^13 mod 100 = " << modPow(3, 13, 100) << endl;  // 23
    return 0;
}

十、例题

这是一道板子题，注意取模就行了。

代码

#include<bits/stdc++.h>
using namespace std;
long long a,b,p;
long long pow(){
    long long res=1;
    a=a%p;
    while(b>0){
        if(b&1)res=res*a%p;
        a=a*a%p;
        b>>=1;
    }
    return res;
}
int main(){
    cin>>a>>b>>p;
    cout<<a<<'^'<<b<<" mod "<<p<<'='<<pow();
    return 0;
}