【位运算】快速幂取模

 

取模运算的规则如下：

1、(a + b) % p = (a % p + b % p) % p 。

2、(a - b) % p = (a % p - b % p) % p 。

3、(a * b) % p = (a % p * b % p) % p 。

4、a ^ b % p = ((a % p)^b) % p 。

 

static long fastPow(int a,int b,int p){
        int r = 1%p;
        while (b!=0) {
            if ((b & 1)!=0) {
                r = (r*a)%p;
            }
            a= (a*a)%p;
            b >>= 1;
        }
        return r;
    }

　　还有一种递归的写法

//递归方式的快速幂
    public double power(double x, int n) {
        if (n == 0) {
            return 1;
        }
        double r = power(x, n / 2);
        
        //n&1判断n最低为是否为1，为1则n为奇数，为0则n为偶数（其实就是n%2）
        //指数n为奇数，则需要多乘一个底数。因为上行代码计算n/2时，若n为奇数，精度丢失向下取整（相当于少乘一个x）
        if ((n & 1) == 1) {
            return r * r * x;
        } else {
            return r * r;
        }
    }

　　

50. Pow(x, n)

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。

 

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：

输入：x = 2.10000, n = 3
输出：9.26100
示例 3：

输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25

来源：力扣（LeetCode）

class Solution {
    public double quickMul(double x, long N) {
        if (N == 0) {
            return 1.0;
        }
        double y = quickMul(x, N / 2);
        return N % 2 == 0 ? y * y : y * y * x;
    }

    public double myPow(double x, int n) {
        long N = n;
        return N >= 0 ? quickMul(x, N) : 1.0 / quickMul(x, -N);
    }
}

　　

 

 

 

 

 

 

class Solution {
    double quickMul(double x, long N) {
        double ans = 1.0;
        // 贡献的初始值为 x
        double x_contribute = x;
        // 在对 N 进行二进制拆分的同时计算答案
        while (N > 0) {
            if (N % 2 == 1) {
                // 如果 N 二进制表示的最低位为 1，那么需要计入贡献
                ans *= x_contribute;
            }
            // 将贡献不断地平方
            x_contribute *= x_contribute;
            // 舍弃 N 二进制表示的最低位，这样我们每次只要判断最低位即可
            N /= 2;
        }
        return ans;
    }

    public double myPow(double x, int n) {
        long N = n;
        return N >= 0 ? quickMul(x, N) : 1.0 / quickMul(x, -N);
    }
}