大数幂运算
幂运算(Exponentitation)称指数运算,公式如下
c
=
m
e
c=m^e
c=me
当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
。
fft
函数: 这个函数接收一个复数向量a
和一个布尔值invert
。它实现了快速傅里叶变换(FFT)或其逆变换(IFFT),取决于invert
的值。FFT 是一种高效的多项式乘法算法,它将输入的多项式从系数表示转换为点值表示,或者反过来。multiply
函数(整数向量版本): 这个函数接收两个整数向量a
和b
,它们表示两个多项式的系数。函数的目标是计算这两个多项式的乘积并返回结果。乘积的计算过程是通过 FFT 和 IFFT 完成的。首先,将a
和b
扩展到合适的大小,并转换为复数向量fa
和fb
。然后,对fa
和fb
进行 FFT 变换,得到它们的点值表示。接着,将fa
和fb
的每一点相乘,得到乘积的点值表示。最后,对乘积进行 IFFT 变换,得到乘积的系数表示。multiply
函数(字符串版本): 这个函数接收两个字符串num1
和num2
,它们表示两个大数。函数的目标是计算这两个大数的乘积并返回结果。乘积的计算过程是通过将num1
和num2
转换为整数向量,然后调用multiply
函数(整数向量版本)计算乘积,最后将乘积转换回字符串。power
函数: 这个函数接收一个字符串base
和一个长整数exponent
,它们分别表示底数和指数。函数的目标是计算base
的exponent
次方并返回结果。幂运算的计算过程是通过快速幂的方式完成的。首先,创建一个字符串result
并初始化为 “1”。然后,当exponent
大于 0 时,进入循环。在循环中,如果exponent
是奇数,则将result
与base
的乘积赋值给result
;然后,将base
与自身的乘积赋值给base
,并将exponent
除以 2。最后,返回result
。
这个算法的时间复杂度是
O
(
n
l
o
g
n
l
o
g
m
)
O(nlognlogm)
O(nlognlogm)
其中n是大数位数,m是指数。空间复杂度是
O
(
n
)
O(n)
O(n)
这个算法可以处理非常大的数和非常大的指数,但是如果数或指数过大,可能会导致计算时间过长。因此,在实际应用中,我们需要根据具体情况来选择合适的乘法算法。这个算法的优点是它可以处理非常大的数和非常大的指数,而且它的时间复杂度相对较低。然而,它的缺点是它需要处理复数和傅里叶变换,这使得它的实现比较复杂。此外,由于它使用了浮点数,所以它可能会受到浮点数精度问题的影响。
此外,在C语言中也有一个库叫做GMPLib,即gmp.h头文件。里面的函数可以操作任意精度的数值,而且速度非常得快。其中一个名叫mpz_powm()
的函数,就可以实现快速幂运算。