快速幂算法

快速幂算法的代码：

//快速幂算法：
long long fast_power(long long a, long long b, long long c)
{
    long long result = 1;
    a %= c;
    while (b != 0) {
        if (b % 2 == 1) {
            result =( result * a)%c;
            a = (a * a) % c;
            b /= 2;
        }
        else {
            a = (a * a) % c;
            b /= 2;
        }
    }
    return result;
}

快速幂算法中使用了模运算的一个重要性质，即：

(ab)%p = [(a%p)(b % p)]%p

这个性质允许我们在计算过程中保持数值的较小范围，从而避免了大数运算带来的性能问题和溢出问题。

快速幂算法中模运算的应用

在快速幂算法中，我们需要不断地进行乘法操作，并且每一步都对结果取模。这是因为在计算中，如果直接使用大数进行乘法，结果可能会非常大，导致计算效率低下或溢出。因此，我们通过模运算来保持中间结果的适当范围，从而保证计算的正确性和效率。

具体来说：

1. 初始化：

   a %= c;
   

   这里我们将 a 对 c 取模，以避免初始值过大。

2. 在每次计算中：

   • 如果当前幂是奇数：

     result = (result * a) % c;
     

     这里使用了模运算来确保 result * a 不会超出范围，然后对结果取模。

   • 每次平方 a：

     a = (a * a) % c;
     

     这里同样使用了模运算来确保 a * a 不会超出范围，然后对结果取模。

   • 将幂除以 2：

     b /= 2;
     

     这里直接将 b 除以 2，并不涉及模运算，但后续的 b 的奇偶性检查和操作依赖于之前的模运算结果。

解释模运算在算法中的作用

1. 避免溢出：
   使用模运算确保每一步的结果都在合理的范围内，从而避免了整数溢出的问题。例如，a * a 可能会非常大，使用 (a * a) % c 确保结果不会过大。

2. 保持计算的效率：
   模运算可以减少数值的大小，使得乘法和其他运算的计算更高效。在大指数的情况下，快速幂算法通过减少计算量显著提高了效率，但模运算也确保了中间结果的计算不会因数值过大而影响性能。

例子说明

假设我们要计算 (3^13 mod 7)，使用快速幂算法的步骤如下：

• 初始：a = 3, b = 13, c = 7, result = 1
• 迭代：

  • ( b ) 是奇数，所以 result = (result * a) % c = (1 * 3) % 7 = 3

  • 更新 a：a = (a * a) % c = (3 * 3) % 7 = 9 % 7 = 2

  • 更新 b：b = 13 / 2 = 6

  • ( b ) 变为偶数，不更新 result

  • 更新 a：a = (a * a) % c = (2 * 2) % 7 = 4

  • 更新 b：b = 6 / 2 = 3

  • ( b ) 是奇数，所以 result = (result * a) % c = (3 * 4) % 7 = 12 % 7 = 5

  • 更新 a：a = (a * a) % c = (4 * 4) % 7 = 16 % 7 = 2

  • 更新 b：b = 3 / 2 = 1

  • ( b ) 是奇数，所以 result = (result * a) % c = (5 * 2) % 7 = 10 % 7 = 3

  • 更新 a：a = (a * a) % c = (2 * 2) % 7 = 4

  • 更新 b：b = 1 / 2 = 0

最终结果是 result = 3。

总结来说，快速幂算法中通过模运算来确保计算过程中数值不会过大，这对于处理大指数和大数模运算问题至关重要。