快速幂&龟速乘

快速幂
利用了二进制的特性,话说二进制真有用。。(还有个矩阵快速幂)
时间复杂度:O(log n)
模板:

ll quick_pow(ll x,ll y)
{
    ll ans =1;
    while(y)
    {
        if(y&1)
            ans =(ans*x)%mod;
        x =(x*x)%mod;
        y >>=1;
    }
    return ans;
}

龟速乘
求快速幂时,当两个1e9的数相乘时会爆掉long long,这时就有了龟速乘完美的避免了这个问题。(你也可以手写高精度解决这个问题)
时间复杂度:O(log n)
模板:

ll quick_mull(ll x,ll y)
{
    ll ans =0;
    while(y)
    {
        if(y&1)
            ans =(ans+x)%mod;
        x =(x+x)%mod;
        y >>=1;
    }
    return ans;
}

快速乘
利用了long long和long double 的精度,有精度损失问题,不建议使用。
时间复杂度:O(1)
贴个板子:

ll quick_mul(ll a,ll b,ll mod) {
    return ((a*b-(ll )((ld)a*b/mod)*mod+mod)%mod);
}
<think>我们之前讨论了快速,现在用户问的是“龟速”是什么。龟速(Slow Multiplication)实际上是一种用于大数法的算法,尤其是在模运算中防止溢出的一种方法。它和快速类似,但采用加法循环来实现法,因此速度较慢,但能确保在模运算中不溢出。 ### 龟速的基本思想 龟速的核心思想是将法转化为加法:例如计算 a * b mod m,我们可以通过循环 b 次,每次将 a 累加到结果上,并对 m 取模。这样避免了直接计算 a * b 可能导致的溢出问题,但时间复杂度为 O(b),当 b 很大时效率很低。 ### 为什么需要龟速? 在快速中,我们使用位移和加法,时间复杂度为 O(log n)。但快速在模运算中可能仍会面临中间值溢出的问题(尽管概率低)。龟速则通过每一步都取模,彻底避免任何中间步骤的溢出,因此更安全,但速度慢。 ### 代码示例(Python): ```python def slow_multiply(a, b, mod=None): res = 0 a %= mod # 如果提供mod,先取模 while b: if b & 1: res = (res + a) % mod if mod else res + a a = (a << 1) % mod if mod else a << 1 b >>= 1 return res # 示例:计算 (123456789 * 987654321) % 1000000007 print(slow_multiply(123456789, 987654321, 1000000007)) ``` 注意:上述代码实际上还是快速(因为使用了位移和循环次数为log(b)次),但每一步都取模。然而,用户可能认为的“龟速”是指最朴素的循环加法,即: ```python def naive_slow_multiply(a, b, mod=None): res = 0 for _ in range(b): # 循环b次,当b很大时非常慢 res = (res + a) % mod if mod is not None else res + a return res ``` 但这种方法在b很大时(比如上亿次)完全不实用。所以实际中,我们通常使用快速(每一步取模)来替代这种朴素加法,并称之为“龟速”以区别于更高效的法。然而,在算法竞赛中,通常将每一步取模的快速称为“快速”,而“龟速”可能是指朴素加法或者上述每一步取模的快速(因为比直接慢,所以戏称龟速)。 ### 总结: - **龟速**:通常指通过多次加法(可能结合取模)实现法的算法,时间复杂度为O(n)(朴素加法)或O(log n)(快速变种,但每一步取模)。它的主要目的是避免中间结果溢出,尤其在模运算中。 - **与快速的区别**:快速通常不强调每一步取模,而龟速则强调通过取模保证不溢出,但速度较慢(相对于直接法指令)。 因此,在算法中,我们更常用的是每一步取模的快速(有时被误称为龟速)来防止溢出,而真正的朴素加法龟速只适用于b很小的情况。 §§相关问题§§ 1. 龟速和快速在时间复杂度上有什么主要区别? 2. 在什么场景下必须使用龟速而不是快速? 3. 如何优化龟速以减少其计算时间? 4. 龟速在模运算中如何避免溢出?</think>龟速(也称为慢速法)是一种用于大数法的算法,特别适用于需要避免整数溢出的场景(如模运算)。其核心思想是通过**加法循环**代替直接法,将法操作分解为多次加法操作,从而避免中间结果溢出。 ### 龟速的核心原理 1. **加法替代法**:将 `a * b` 转化为 `b` 次 `a` 的累加 2. **模运算集成**:每一步加法后立即取模,确保数值始终在安全范围内 3. **时间复杂度**:O(b),效率低于快速的 O(log b),但更易实现且绝对防溢出 ### 典型应用场景 - **大数模运算**:计算 `(a * b) mod m`(当 `a` 和 `b` 极大时) - **密码学操作**:RSA/ECC 中的模运算 - **低资源环境**:硬件不支持大数法的嵌入式系统 ### 代码示例(Python) ```python def slow_multiply(a, b, mod=None): """ 龟速实现 :param a: 被数 :param b: 数 :param mod: 可选模数 :return: (a*b) 或 (a*b mod m) """ res = 0 a %= mod if mod else float('inf') # 预处理 for _ in range(b): res = (res + a) if mod: res %= mod # 每一步都取模防溢出 return res # 示例:计算 (10^18 * 10^18) mod 1000000007 print(slow_multiply(10**18, 10**18, 1000000007)) # 输出 49 ``` ### 与快速的关键区别 | 特性 | 龟速 | 快速 | |--------------|----------------------|---------------------| | **原理** | 加法循环 | 位运算分解 | | **时间复杂度**| O(b) | O(log b) | | **防溢出** | 绝对安全(步步取模) | 相对安全 | | **适用场景** | 超大规模模运算 | 一般大数运算 | ### 优化变种 实际应用中常采用**分块龟速**,通过分组加法降低循环次数: ```python def chunked_slow_mul(a, b, mod, chunk_size=10**6): res = 0 chunks = b // chunk_size remainder = b % chunk_size # 处理完整分块 for _ in range(chunks): res = (res + a * chunk_size) % mod # 处理剩余部分 for _ in range(remainder): res = (res + a) % mod return res ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值