大数幂运算

大数幂运算

幂运算(Exponentitation)称指数运算，公式如下
$$c=m^e$$
当m或者e的数值不大时，可以通过重复乘法运算来获得c。当m和e都是一个大数时，比如说512位长，尽管有了计算机效率也不高，如何快速进行大数幂运算呢？

下面是使用字符串进行大数的快速幂运算的算法

整个算法如下：

#include <iostream>
#include <vector>
#include <complex>
#include <algorithm>
#include <cmath>
#include <string>

using namespace std;

typedef complex<double> cd;

void fft(vector<cd> &a, bool invert) {
    int n = a.size();
    if (n == 1) return;

    vector<cd> a0(n / 2), a1(n / 2);
    for (int i = 0, j = 0; i < n; i += 2, ++j) {
        a0[j] = a[i];
        a1[j] = a[i + 1];
    }
    fft(a0, invert);
    fft(a1, invert);

    double ang = 2 * M_PI / n * (invert ? -1 : 1);
    cd w(1), wn(cos(ang), sin(ang));
    for (int i = 0; i < n / 2; ++i) {
        a[i] = a0[i] + w * a1[i];
        a[i + n / 2] = a0[i] - w * a1[i];
        if (invert) {
            a[i] /= 2;
            a[i + n / 2] /= 2;
        }
        w *= wn;
    }
}

vector<int> multiply(const vector<int> &a, const vector<int> &b) {
    vector<cd> fa(a.begin(), a.end()), fb(b.begin(), b.end());
    int n = 1;
    while (n < max(a.size(), b.size())) n <<= 1;
    n <<= 1;
    fa.resize(n);
    fb.resize(n);

    fft(fa, false);
    fft(fb, false);
    for (int i = 0; i < n; ++i) {
        fa[i] *= fb[i];
    }
    fft(fa, true);

    vector<int> result(n);
    for (int i = 0; i < n; ++i) {
        result[i] = round(fa[i].real());
    }
    return result;
}

string multiply(const string &num1, const string &num2) {
    int len1 = num1.size();
    int len2 = num2.size();

    vector<int> a(len1), b(len2);
    for (int i = 0; i < len1; ++i) a[i] = num1[len1 - i - 1] - '0';
    for (int i = 0; i < len2; ++i) b[i] = num2[len2 - i - 1] - '0';

    vector<int> result = multiply(a, b);

    int carry = 0;
    string ans;
    for (int i = 0; i < result.size(); ++i) {
        result[i] += carry;
        carry = result[i] / 10;
        result[i] %= 10;
        ans += (result[i] + '0');
    }

    while (ans.size() > 1 && ans.back() == '0') ans.pop_back();
    reverse(ans.begin(), ans.end());
    return ans;
}


string power(string base, long long exponent) {
    string result = "1";
    while (exponent > 0) {
        if (exponent % 2 == 1) {
            result = multiply(result, base);
        }
        base = multiply(base, base);
        exponent /= 2;
    }
    return result;
}

int main() {
    string base = "2";
    long long exponent = 2000000;
    string result = power(base, exponent);
    cout << result << endl;
    return 0;
}

它包含三个函数：fft，multiply 和 power。

1. fft 函数： 这个函数接收一个复数向量 a 和一个布尔值 invert。它实现了快速傅里叶变换（FFT）或其逆变换（IFFT），取决于 invert 的值。FFT 是一种高效的多项式乘法算法，它将输入的多项式从系数表示转换为点值表示，或者反过来。
2. multiply 函数（整数向量版本）： 这个函数接收两个整数向量 a 和 b，它们表示两个多项式的系数。函数的目标是计算这两个多项式的乘积并返回结果。乘积的计算过程是通过 FFT 和 IFFT 完成的。首先，将 a 和 b 扩展到合适的大小，并转换为复数向量 fa 和 fb。然后，对 fa 和 fb 进行 FFT 变换，得到它们的点值表示。接着，将 fa 和 fb 的每一点相乘，得到乘积的点值表示。最后，对乘积进行 IFFT 变换，得到乘积的系数表示。
3. multiply 函数（字符串版本）： 这个函数接收两个字符串 num1 和 num2，它们表示两个大数。函数的目标是计算这两个大数的乘积并返回结果。乘积的计算过程是通过将 num1 和 num2 转换为整数向量，然后调用 multiply 函数（整数向量版本）计算乘积，最后将乘积转换回字符串。
4. power 函数： 这个函数接收一个字符串 base 和一个长整数 exponent，它们分别表示底数和指数。函数的目标是计算 base 的 exponent 次方并返回结果。幂运算的计算过程是通过快速幂的方式完成的。首先，创建一个字符串 result 并初始化为 “1”。然后，当 exponent 大于 0 时，进入循环。在循环中，如果 exponent 是奇数，则将 result 与 base 的乘积赋值给 result；然后，将 base 与自身的乘积赋值给 base，并将 exponent 除以 2。最后，返回 result。

这个算法的时间复杂度是
$$O(nlognlogm)$$
其中n是大数位数，m是指数。空间复杂度是
$$O(n)$$
​ 这个算法可以处理非常大的数和非常大的指数，但是如果数或指数过大，可能会导致计算时间过长。因此，在实际应用中，我们需要根据具体情况来选择合适的乘法算法。这个算法的优点是它可以处理非常大的数和非常大的指数，而且它的时间复杂度相对较低。然而，它的缺点是它需要处理复数和傅里叶变换，这使得它的实现比较复杂。此外，由于它使用了浮点数，所以它可能会受到浮点数精度问题的影响。

此外，在C语言中也有一个库叫做GMPLib，即gmp.h头文件。里面的函数可以操作任意精度的数值，而且速度非常得快。其中一个名叫mpz_powm()的函数，就可以实现快速幂运算。