快速幂算法学习笔记

原文链接快速幂算法

什么是快速幂算法

取模运算法则

(a + b) % p = (a % p + b % p) % p (1)
(a - b) % p = (a % p - b % p ) % p (2)
(a * b) % p = (a % p * b % p) % p (3)

(a * b * c) % d=(a%d * b%d * c%d) % d; 因此,我们可以借助这个法则,只需要在循环乘积的每一步都提前进行“取模”运算,而不是等到最后直接对结果“取模”,也能达到同样的效果。

/**
 * 普通的求幂函数
 * @param base 底数
 * @param power  指数
 * @return  求幂结果的最后3位数表示的整数
 */
long long normalPower(long long base,long long power){
    long long result=1;
    for(int i=1;i<=power;i++){
        result=result*base;
        //每一步的结果都进行取模,也能达到效果
        result=result%1000;
    }
    return result%1000;
}

快速幂算法初步入门

快速幂算法能帮我们算出指数非常大的幂,传统的求幂算法之所以时间复杂度非常高(为O(指数n)),就是因为当指数n非常大的时候,需要执行的循环操作次数也非常大。所以我们快速幂算法的核心思想就是每一步都把指数分成两半,而相应的底数做平方运算。这样不仅能把非常大的指数给不断变小,所需要执行的循环次数也变小,而最后表示的结果却一直不会变。让我们先来看一个简单的例子:

310=3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3
//尽量想办法把指数变小,这里的指数为10
310=(3 * 3) * (3 * 3) * (3 * 3) * (3 * 3) * (3 * 3)
310=(3*3)5
310=95
此时指数由10缩减一半变成了5,而底数变成了原来的平方,求310原本需要执行10次循环操作,求95却只需要执行5次循环操作,但是310却等于95,我们用一次(底数做平方操作)的操作减少了原本一半的循环量,特别是在幂特别大的时候效果非常好,例如210000=45000,底数只是做了一个小小的平方操作,而指数就从10000变成了5000,减少了5000次的循环操作。
现在我们的问题是如何把指数5变成原来的一半,5是一个奇数,5的一半是2.5,但是我们知道,指数不能为小数,因此我们不能这么简单粗暴的直接执行5/2,然而,这里还有另一种方法能表示95
95=(94) *(91
//此时我们抽出了一个底数的一次方,这里即为91,这个91我们先单独移出来,剩下的94又能够在执行“缩指数”操作了,把指数缩小一半,底数执行平方操作

95=(812)*(91)

//把指数缩小一半,底数执行平方操作

95=(65611)*(91)

//此时,我们发现指数又变成了一个奇数1,按照上面对指数为奇数的操作方法,应该抽出了一个底数的一次方,这里即为65611,这个65611我们先单独移出来,但是此时指数却变成了0,也就意味着我们无法再进行“缩指数”操作了。

95=(65610)* (91) *(65611)=1 * (91) * (65611)=(91) * (65611)=9 * 6561=59049

我们能够发现,最后的结果是9*6561,而9是怎么产生的?是不是当指数为奇数5时,此时底数为9。那6561又是怎么产生的呢?是不是当指数为奇数1时,此时的底数为6561。所以我们能发现一个规律:最后求出的幂结果实际上就是在变化过程中所有当指数为奇数时底数的乘积。

long long fastPower(long long base, long long power) {
    long long result = 1;
    while (power > 0) {
        if (power % 2 == 0) {
            //如果指数为偶数
            power = power / 2;//把指数缩小为一半
            base = base * base % 1000;//底数变大成原来的平方
        } else {
            //如果指数为奇数
            power = power - 1;//把指数减去1,使其变成一个偶数
            result = result * base % 1000;//此时记得要把指数为奇数时分离出来的底数的一次方收集好
            power = power / 2;//此时指数为偶数,可以继续执行操作
            base = base * base % 1000;
        }
    }
    return result;
}

再压缩

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

终极优化

在C语言中,power%2==1可以用更快的“位运算”来代替,例如:power&1。因为如果power为偶数,则其二进制表示的最后一位一定是0;如果power是奇数,则其二进制表示的最后一位一定是1。将他们分别与1的二进制做“与”运算,得到的就是power二进制最后一位的数字了,是0则为偶数,是1则为奇数。例如5是奇数,则5&1=1;而6是偶数,则6&1=0;因此奇偶数的判断就可以用“位运算”来替换了。
在这里插入图片描述
同样,对于power=power/2来说,也可以用更快的“位运算”进行替代,我们只要把power的二进制表示向右移动1位就能变成原来的一半了。
在这里插入图片描述
最终代码:

long long fastPower(long long base, long long power) {
    long long result = 1;
    while (power > 0) {
        if (power & 1) {//此处等价于if(power%2==1)
            result = result * base % 1000;
        }
        power >>= 1;//此处等价于power=power/2
        base = (base * base) % 1000;
    }
    return result;
}

题目实践

leetcode 50.pow(x,n)

class Solution {
public:
    double myPow(double x, int n) {
        if(!n)return 1;
        if(n == 1 || x == 0)return x;
        long long m = n;
        if(n < 0) {
            x = 1 / x;
            //正向会越界,所以要单独处理
            if(n == INT_MIN) m = 2147483648;
            else m = - n;
        }
        double ans = 1;
        while(m > 0){
            if(m & 1) ans = ans * x;//如果指数为奇数,要把分离出来的底数一次方收集好
            m >>= 1; //指数缩小一半
            x = x * x;//底数变为原来的平方
        }
        return ans;
    }
};

leetcode 372.超级次方

class Solution {
    const int MOD = 1337;

    int pow(int x, int n) {
        int res = 1;
        while (n) {
            if (n & 1) {//奇数收集答案
                res = (long) res * x % MOD;
            }
            //底数变为原来的平方
            x = (long) x * x % MOD;
            //指数减半
            n >>= 1;
        }
        return res;
    }

public:
    int superPow(int a, vector<int> &b) {
        int ans = 1;
        for (int i = b.size() - 1; i >= 0; --i) {
            ans = (long) ans * pow(a, b[i]) % MOD;
            a = pow(a, 10);//数组b往前一位,计算的值就变为10倍
        }
        return ans;
    }
};
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值