力扣50号算法题Pow(x, n)。快速幂的递归与位运算实现及扩展题372. 超级次方

关注

原创最新推荐文章于 2026-05-16 09:02:03 发布 537 阅读 AI 写同款· GEO 优化 ›

二分快速幂算法精讲：从原理到实战，攻克力扣50/372/1808题幂运算是算法与编程中的基础操作，其核心在于高效计算a的b次方。传统循环乘法的时间复杂度为O(n)，当指数b极大时性能堪忧。基于分治思想与二进制分解原理的快速幂算法，能将复杂度优化至O(log n)，通过将指数不断二分或按二进制位处理，大幅减少乘法次数。这一优化在需要处理大数幂运算或模幂运算的场景中极具技术价值，例如计算哈希、加密解密、组合数学以及解决各类数学建模问题。本文以力扣经典题目为应用场景，深入解析快速幂的递归与迭代实现，并探讨其在处理指数为负数、大数数组表示及复杂数学推导中的实际应用，帮助读者掌握这阅读详情

问题：力扣50. Pow(x, n)

题目就是力扣： 50. Pow(x, n)： https://leetcode-cn.com/problems/powx-n/

解法一：直接暴力for循环：

就是通过for 循环 O(n) 时间复杂度，不断的进行累加，会出现超时。

// 暴力破解，O(n) 迭代
func myPow(x float64, n int) float64 {
    // 如果指数小于 0，那么将底数变为对应的
    if n < 0 {
        x = 1 / x
        n = -n
    }
    var rst float64 = 1 
    for ;n > 0; n-- {
        rst *= x
    }
    return rst 
}

解法二：递归实现快速幂：

先来分析一波：上面的暴力破解， O(n) 的时间复杂度，就是每次都是乘x，那么可以将问题进行拆解：
例如：
- 3 ^ 16 == 3 ^ 8 * 3 ^ 8
- 3 ^ 8 == 3 ^ 4 * 3 ^ 4
- 3 ^ 4 == 3 ^ 2 * 3 ^ 2
- 3 ^ 2 == 3 * 3
- 类似二分查找一样的，每次将问题范围缩小一半。那么时间复杂度就是 O（log n）, n 表示指数，上面的 16。
- 我们使用递归实现这一过程，很像归并排序！再递的时候，不断缩小范围，再归的过程，再去计算两两乘积，最后得到最终结果。
```
func quickPow(x float64, n int) float64 {
    // 递归终止条件
    if n == 0 {
        return 1.0
    }
    // 分解 
    mid := n / 2
    // 递的过程，不断的缩小范围 16 - 8 - 4 - 2 - 1
    y := quickPow(x, mid)
    // 归的过程，就是 不断乘积
    return y * y
}
```
还需要考虑一个关键点是：当前的值可能是奇数，例如
- 3 ^ 19 == 3 ^ 9 * 3 ^ 9 * 3
- 所以，上面的 y * y 应该进行判断，如果是偶数，就 y * y，如果是奇数，就需要 y * y * x 才是正确的！

上最终代码：

// 暴力破解，O(n) 迭代
func myPow(x float64, n int) float64 {
    // 1. 快速幂计算
    var quickPow func(float64, int) float64
    quickPow = func(x float64, n int) float64 {
        // 两个递归终止条件, 必须有下面一个 0 的判断 才能对
        // if n == 1 {
        //     return x 
        // }
        if n == 0 {
            return 1.0
        }
        // 分解 
        mid := n / 2
        // 递归
        y := quickPow(x, mid)
        // 可能是 奇数，3 ^ 19 == 3 ^ 9 * 3 ^ 9 * 3
        if n % 2 == 0 {
            return y * y
        } else {
            return y * y * x
        }
    }
    
    // 2. 如果指数小于 0，那么将底数变为对应的
    if n < 0 {
        x = 1 / x
        n = -n
    }
    
    // 3. 调用快速幂进行计算
    return quickPow(x, n)
}

解法三：位运算优化实现

x ^ 15 , 对于指数进行分解, 拆为2进制表示

15 = 1111 。那么要知道二进制从低到高每位的表示为 1, 2, 4, 8.
将当前的结果就转换为了: x ^ (2^1) * x ^ (2^2) * x ^ (2^4) * x ^ (2^8)
并且每一位上是有规律的。将上面的四个部分表示为 y1 * y2 * y3 * y4
- 那么，根据指数 1 ,2 ,4， 8的关系。两数相乘等于指数相加
- y2 = y1 * y1
- y3 = y2 * y2
- y4 = y3 * y3
那么我们将指数，化为 2进制形式，按照上面的规律求得 y1 到 y4，再将他们累乘，就是最后的结果了。
下面计算 x ^ 15 次方，可以写成这样：

// 定义结果
rst := 1.0
// 15 = 1111
// 循环， 取 n代表指数， 取它的每一位。利用右移运算符。
// 当n 还大于0，就右移一位。等于取每一位
for n != 0 {
	// 第一位 为 1， y1 = x ^ 1 ， 等于 x 
    rst *= x
    // 到了下一位 因为 1 2 4 8， 所以下一位，等于当前 y1 * y1 == x * x
    x *= x
    // 右移一位
    n >>= 1 
}
// 循环这个过程， y2 = y1 * y1 。。。
// 然后 rst 累乘每一步的结果。 每一步的结果，又是上一步 相乘。 
// x^2 * x^2 == x ^ (2 + 2) == x ^ 4 , 对应2进制每一位 1 2 4 8
return rst

由上面的结果，还有一定的 bug！，因为我们选择的是 x ^ 15
- 15 = 二进制 1111 ，所以每一步二进制计算的结果 “y” 累乘起来就是最终结果。
- 但是如果是 x^ 9 呢？ 9 == 1001(二进制). 也就是说
- x ^ 9 == (x ^ 8) * (x ^ 0) * (x ^ 0) * (x ^ 1)
- x ^ 0 == 1, 也就是说，x ^ 9 == (x ^ 8) * 1 * 1 * (x ^ 1)
- 所以，我们要进行判断，当，当前二进制位为 0的时候，rst 结果不能乘以当前的 y, 而应该跳过。因为乘 1 等于自身。但是 y2 == y1 * y1 不变。即使当前的二进制位为 0， rst 不累乘，但是还要计算下一次的 y

最终的代码：

因为是在 int32 范围内，所以最多取 32位，时间复杂度是 O(32),空间复杂度是O(1)。

// 位运算最优解,  快速幂 + 迭代
// 因为计算结果在 int32 范围内， 所以 
// 空间复杂度为 O（1）， 时间复杂度为 O(32)
func myPow(x float64, n int) float64 {
    // 1. 如果指数小于 0，那么将底数变为对应的
    if n < 0 {
        x = 1 / x
        n = -n
    }
    rst := 1.0
    for n != 0 {
    	// 当前二进制位等于 1才累加到结果集
        if n & 1 == 1 {
            rst *= x
        }
        // 下一轮的 y 值，等于当前 y 值相乘
        x *= x
        n >>= 1 
    }
    return rst 
}

问题：力扣 372. 超级次方

有了上面快速幂的基础，我们可以看下面这道题，可以使用快速幂解答。

这道题求得就是 a^b 对 1337 取模。先需要求得 a 的 b次方，再进行 1337 取模。且 b 是个很大的数，超过32位。

// 按照理论: https://leetcode-cn.com/problems/super-pow/solution/gong-shui-san-xie-di-gui-kuai-su-mi-ying-yx1j/ 
// 这个大佬的讲解，只要将最后的数字转换为 
const mod = 1337

func pow(x, n int) int {
    res := 1
    for ; n > 0; n /= 2 {
        if n&1 > 0 {
            res = res * x % mod
        }
        x = x * x % mod
    }
    return res
}

func superPow(a int, b []int) int {
    ans := 1
    for i := len(b)-1; i >= 0; i-- {
        ans = ans * pow(a, b[i]) % mod
        a = pow(a, 10)
    }
    return ans
}