基础算法——龟速乘

题目描述

(64位整数乘法)求 a 乘 b 对 p 取模的值。

输入格式
第一行输入整数a,第二行输入整数b,第三行输入整数p。

输出格式
输出一个整数,表示 a*b mod p的值。

数据范围
1≤a,b,p≤10181≤a,b,p≤10^{18}1a,b,p1018

输入样例:

3
4
5

输出样例:

2

算法思想

二进制思想。如果直接计算a×ba\times ba×b这会爆 long long ,所以采用类似于快速幂的思想把 b作为二进制形式进行处理,然后如果某位上为1就加上它a×2na\times2^na×2n次方,并且每次计算后取模就可以了。

例如:b=11=(1011)2=23+21+20b=11=(1011)_2=2^3+2^1+2^0b=11=(1011)2=23+21+20,那么a×b=a×(23+21+20)=8a+2a+aa\times b=a\times(2^3+2^1+2^0)=8a +2a+aa×b=a×(23+21+20)=8a+2a+a

时间复杂度

将乘数bbb的每个二进制位取出进行判断,时间复杂度为log(b)log(b)log(b)

代码实现

#include <iostream>

using namespace std;

typedef long long LL;

LL qadd(LL a, LL b, LL p)
{
    LL res = 0;
    while(b)
    {
        if(b & 1) res = (res + a) % p;
        a = (a + a) % p;
        b >>= 1;
    }
    return res;
}

int main()
{
    LL a, b, p;
    
    cin >> a >> b >> p;
    
    cout << qadd(a, b, p) << endl;
    
    return 0;
}
<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
发出的红包

打赏作者

少儿编程乔老师

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值