前言
什么是高精度？
高精度是一种算法，用于计算各种大数的运算。
什么意思呢？
我举个栗子。首先OI界有一句金玉良言：
即使题面出的水，只要数据够变态，难度指数级上升。
对于著名的水题和各种神仙的装弱工具A+B Problem，它的数据范围是什么呢？
(|a|,|b| le 10^9)
嗯，所以我们可以放心大胆的这么写：
#include <iostream>
#include <cstdio>
int main() {
int a,b;
std :: cin >> a >> b;
std :: cout << a + b << std :: endl;
return 0;
}
但是，如果我把数据范围改成这样：
(|a|,|b| le 10^{18})
你就不能用int了，而得用long long：
#include <iostream>
#include <cstdio>
int main() {
long long a,b;
std :: cin >> a >> b;
std :: cout << a + b << std :: endl;
return 0;
}
最后，我要是把数据范围改成这样：
(0 le a,b le 10^{500})
这就是luogu p1601的原题。
你根本就找不到一种数据类型能存这样大的数。
那怎么办呢？自己造一种数据类型？
没错，就是这样。这种算法，就叫做高精度。
面对这样大的数，蟹蟹唯一想到的办法，就是用数组存储每一个位数。
但这样，肯定不能直接加减乘除运算，我们得自定义。
怎么自定义呢？
想想我们小时候求加减乘除的方法。没错，列竖式。
同样的，这里我们也用两个需要进行运算的数进行竖式模拟运算。这种方法虽然笨，但真的没有什么别的方法了。
怎么来写高精度呢？具体的竖式应该如何去操作呢？
请接着看。
说明一下，现在noip很少考到高精度了，但是我们为了保险，还是学习一下高精度。学总比不学强嘛。
再说明：本教程中的高精度只涉及到非负整数。负数和浮点数本教程中不考虑。
正式开始（最初版本）
准备工作
首先我们需要准备好程序构架。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cassert>
const int maxn = 4005;//运算时最多的位数，也就是说这个值取决于数据范围中运算过程中数值可能的最大位数。
int main() {
}
然后定义一个结构体。这是一种高阶玩法，到头来我们可以直接用ubigint定义数，来进行高精度的运算，到时候直接加加减减就ok。
struct ubigint() {
}
赋值运算符
首先我们来看一些基本的赋值：
int s[maxn], len;
//一些基础的东西
ubigint() { memset(s, 0, sizeof(s)); }
ubigint(int num) { *this = num; }
ubigint(char *num) { *this = num; }
ubigint operator = (int num) {
char c[maxn];
sprintf(c, "%d", num);
*this = c;
return *this;
}
ubigint operator = (const char *num) {
len = strlen(num);
for(int i = 0; i < len; i++)
s[i] = num[len - i - 1] - '0';//请注意这里是倒过来赋值的，也就是说得到的数组其实直接输出，数是反着的。为什么呢？一般我们列竖式都是从后往前的，所以我们把数组进行倒序处理，这样我们在程序中就可以正序遍历了。
return *this;
}
这些都是最基本的定义赋值之类的东西，我不再赘述。
关系运算符
接下来我们来重载一些关系运算符：
//关系运算符
bool operator < (const ubigint &b) const {
if(len != b.len) return len < b.len;//比位数
for(int i = len - 1; i >= 0; i--)//诸位比较
if(s[i] != b.s[i])
return s[i] < b.s[i];
return false;
}
bool operator > (const ubigint &b) const {return b < *this; }
bool operator <= (const ubigint &b) const {return !(b < *this);}
bool operator >= (const ubigint &b) const {return !(*this < b);}
bool operator == (const ubigint &b) const {return !(b < *this) && !(b > *this);}
bool operator != (const ubigint &b) const {return b < *this || *this < b;}
我解释一下小于号。二年级数学中就有两个数比较大小的方法，先比位数，后从高位到低位诸位比较。
位数就是两个数组的长度，如果len < b.len证明小于号判断成立，如果len > b.len说明小于号判断不成立。
如果位数相等，从高位到低位诸位比较，如果当前数字不一样，则对当前的数字的大小关系来判断这两个数的大小关系。
如果诸位比较完成，说明两个数相等。不过这个时候是不满足小于的，所以返回false。
然后其他的就是各种套用小于号，因为我懒得在写一遍了qaq（不要打蟹蟹呀嘤嘤嘤）
算术运算符
加法
首先先来康加法。
首先小学我们是咋算加法的呢？对了，列竖式。
我们可以从最后一位（再次提醒，请注意本教程中数组存储是倒着的，所以程序中是从第一个字符开始遍历）开始无脑加法，然后把得到的结果放在结果的对应位置。
吗？
你在想什么啊，进位我们还得考虑。
于是，我们就可以相加，如果没进位直接放，如果进位了把得到的结果%10放到结果的那个位置，然后那个位置的前面那个位置加上1（表示进位）。
但是我们显然还漏掉了一种情况，当两个加数的位数不相同。其实这个问题根本不算什么问题，只需要特判好了。
这样就不难得到代码了：
ubigint operator + (const ubigint &b) const {
ubigint res;
res.len = 0;
for(int i = 0, x = 0; x || i < len || i < b.len; i++, x /= 10) {
if(i < len) x += s[i];
if(i < b.len) x += b.s[i];
res.s[res.len++] = x % 10;
}
return res;
}
减法
然后是减法。
减法其实和加法差不多，也是按位相减，如果不够，借1.
顺便说明一下，这里的减法不支持被减数小于减数的情况，也就是结果必须大于0.
ubigint operator - (const ubigint &b) const {
assert(*this >= b);
ubigint res;
res.len = 0;
int x;
for(int i = 0, g = 0; i < len; i++) {
x = s[i] - g;
if(i < b.len) x -= b.s[i];
if(x >= 0) g = 0;
else {
x += 10;
g = 1;
}
res.s[res.len++] = x;
}
res.clear_zero();//注意到这里了没有？
return res;
}
如果你是一个细心的人，会发现上面多了一个clear_zero()。
这是什么？
一般在高精度运算中，可能会出现结果是正确的，但是结果之前有好几个0.这种0叫做前导0，高精度运算中常常不能避免，所以我们需要定义一个clear_zero()函数去掉这些多余的前导0.
怎么清呢？我们只需要定义这样的代码：
void clear_zero() {
while(len > 1 && !s[len - 1]) len--;
}
你可能会问了，为什么是len > 1，而不是len > 0呢？
前导0不是遇到不是0的情况才停的，你想啊，如果这个数是0，那这个0可不算是前导0.所以我们不清个位，个位都有前导0只能说明这个数是0，需要特殊对待。
乘法
乘法这点就比较难了，蟹蟹陪你耐心分析。（其实也不是很难辣，放松心态呀qaq）
小学我们是怎么学的？每一位按位相乘，相乘的结果再进行相加。
但存储相乘的结果又是一笔开销，我们不如思维跳跃一下，把每一位相乘的结果直接对应到res数组里，岂不美滋滋？
这里我们有一个定律，第一个数从后往前第i位数 和 第二个数从后往前第j位数 相乘 的结果 最后 会相加到 结果的 从后往前第i+j位上。
如果你不懂，不如先列几个竖式，感受感受下？这里一定要弄懂哦。
但是进位也是个麻烦事。每一位的数在枚举i，j的时候随时都会变，随时进位总觉得不好。我们还是都累积完了，再一一进位吧，这样比较好。（个人习惯辣）
于是就有了如下的代码：
ubigint operator * (const ubigint &b) const {
ubigint res;
res.len = len + b.len;
for(int i = 0; i < len; i++)
for(int j = 0; j < b.len; j++)
res.s[i + j] += s[i] * b.s[j];
for(int i = 0; i < res.len - 1; i++) {
res.s[i + 1] += res.s[i] / 10;
res.s[i] %= 10;
}
res.clear_zero();
return res;
}
除法
其实除法就是乘法的逆运算，和乘法也差不多，就像加法和减法一样。不过除法在试除这个方面是有技巧的，我们可以二分试除。
ubigint operator / (const ubigint &b) const {
assert(b > 0);
ubigint res = *this,m;
for(int i = len - 1; i >= 0; --i) {
m = m * 10 + s[i];
res.s[i] = midsearch(b, m);
m = m - b * res.s[i];
}
res.clear_zero();
return res;
}
midsearch函数：
int midsearch(const ubigint &b, const ubigint &m) const {
int L = 0, R = 9, mid;
while(1) {
mid = (L + R) >> 1;
if(b * mid <= m) {
if(b * (mid + 1) > m) return mid;
else L = mid;
}
else R = mid;
}
}
模法
除法都完了，但是别忘了，我们还有魔法。我不会告诉你这其实是%法的，%%% tql orz
取模运算其实特别简单，把上述代码中，最后return m;就可以了。
ubigint operator % (const ubigint &b) const {
assert(b > 0);
ubigint res = *this;
ubigint m;
for(int i = len - 1; i >= 0; i--) {
m = m * 10 + s[i];
res.s[i] = midsearch(b,m);
m = m - b * res.s[i];
}
m.clear_zero();
return m;
}
扩展赋值运算符
我们还可以通过以上的五则运算，扩展出+= -= *= /= %= 。 这就很简单辣。
ubigint& operator += (const ubigint &b) {*this = *this + b; return *this;}
ubigint& operator -= (const ubigint &b) {*this = *this - b; return *this;}
ubigint& operator *= (const ubigint &b) {*this = *this * b; return *this;}
ubigint& operator /= (const ubigint &b) {*this = *this / b; return *this;}
ubigint& operator %= (const ubigint &b) {*this = *this % b; return *this;}
输入输出流
最后的最后，我们搞定输入输出流吧。
std :: istream& operator >>(std :: istream &in, ubigint &x) {
std :: string s;
in >> s;
x = s.c_str();
return in;
}
std :: ostream& operator <<(std :: ostream &out,ubigint x) {
out << x.to_str();
return out;
}
哦对了差点忘记说，我们为了输出ubigint这个类型，还需要定义一个to_str函数，把ubigint类型转成std :: string型。很简单辣。
std :: string to_str() {
std :: string res = "";
for(int i = 0; i < len; i++) res = (char)(s[i] + '0') + res;
return res;
}
至此我们的ubigint就定义完了，拍张合照！
总体代码
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cassert>
const int maxn = 30005;
struct ubigint {
int s[maxn], len;
//一些基础的东西
ubigint() { memset(s, 0, sizeof(s)); }
ubigint(int num) { *this = num; }
ubigint(char *num) { *this = num; }
ubigint operator = (int num) {
char c[maxn];
sprintf(c, "%d", num);
*this = c;
return *this;
}
ubigint operator = (const char *num) {
len = strlen(num);
for(int i = 0; i < len; i++)
s[i] = num[len - i - 1] - '0';
return *this;
}
int midsearch(const ubigint &b, const ubigint &m) const {
int L = 0, R = 9, mid;
while(1) {
mid = (L + R) >> 1;
if(b * mid <= m) {
if(b * (mid + 1) > m) return mid;
else L = mid;
}
else R = mid;
}
}
std :: string to_str() {
std :: string res = "";
for(int i = 0; i < len; i++) res = (char)(s[i] + '0') + res;
return res;
}
void clear_zero() {
while(len > 1 && !s[len - 1]) len--;
}
//关系运算符
bool operator < (const ubigint &b) const {
if(len != b.len) return len < b.len;
for(int i = len - 1; i >= 0; i--)
if(s[i] != b.s[i])
return s[i] < b.s[i];
return false;
}
bool operator > (const ubigint &b) const {return b < *this; }
bool operator <= (const ubigint &b) const {return !(b < *this);}
bool operator >= (const ubigint &b) const {return !(*this < b);}
bool operator == (const ubigint &b) const {return !(b < *this) && !(b > *this);}
bool operator != (const ubigint &b) const {return b < *this || *this < b;}
ubigint operator + (const ubigint &b) const {
ubigint res;
res.len = 0;
for(int i = 0, x = 0; x || i < len || i < b.len; i++, x /= 10) {
if(i < len) x += s[i];
if(i < b.len) x += b.s[i];
res.s[res.len++] = x % 10;
}
return res;
}
ubigint operator - (const ubigint &b) const {
assert(*this >= b);
ubigint res;
res.len = 0;
int x;
for(int i = 0, g = 0; i < len; i++) {
x = s[i] - g;
if(i < b.len) x -= b.s[i];
if(x >= 0) g = 0;
else {
x += 10;
g = 1;
}
res.s[res.len++] = x;
}
res.clear_zero();
return res;
}
ubigint operator * (const ubigint &b) const {
ubigint res;
res.len = len + b.len;
for(int i = 0; i < len; i++)
for(int j = 0; j < b.len; j++)
res.s[i + j] += s[i] * b.s[j];
for(int i = 0; i < res.len - 1; i++) {
res.s[i + 1] += res.s[i] / 10;
res.s[i] %= 10;
}
res.clear_zero();
return res;
}
ubigint operator / (const ubigint &b) const {
assert(b > 0);
ubigint res = *this,m;
for(int i = len - 1; i >= 0; i--) {
m = m * 10 + s[i];
res.s[i] = midsearch(b, m);
m = m - b * res.s[i];
}
res.clear_zero();
return res;
}
ubigint operator % (const ubigint &b) const {
assert(b > 0);
ubigint res = *this;
ubigint m;
for(int i = len - 1; i >= 0; i--) {
m = m * 10 + s[i];
res.s[i] = midsearch(b,m);
m = m - b * res.s[i];
}
m.clear_zero();
return m;
}
ubigint& operator += (const ubigint &b) {*this = *this + b; return *this;}
ubigint& operator -= (const ubigint &b) {*this = *this - b; return *this;}
ubigint& operator *= (const ubigint &b) {*this = *this * b; return *this;}
ubigint& operator /= (const ubigint &b) {*this = *this / b; return *this;}
ubigint& operator %= (const ubigint &b) {*this = *this % b; return *this;}
};
std :: istream& operator >>(std :: istream &in, ubigint &x) {
std :: string s;
in >> s;
x = s.c_str();
return in;
}
std :: ostream& operator <<(std :: ostream &out,ubigint x) {
out << x.to_str();
return out;
}
int main() {
}
压位优化
其实这样的高精度我们还能继续优化。来看下面这个例子：
显然我们在ubigint类中，是一位一位加的。但是我们为什么不能这样？？
之前算四遍，现在算两遍。我们可以想想，能不能直接算一遍呢？
行吧，这就是直接算了。
但是我们为什么不能这样直接算一遍呢？这其实就是高精度存在的意义，根本不存在一种数据方式来算这么大的加法。比如以下就是一个例子：
这可不能直接算。但是我们有刚刚的方法，可以尽量的分割这两个数：
这样算的话，就变成了两位两位的算，算的次数减少了，就会有优化。
我们还可以压4位：
算的方法就更少啦。
我们不妨思考一个问题，我们这样分数，分得的每一个区域允许的最大位数是多少？
如果是int型，显然是9位。因为int的范围最大是2147483647，此时9位相加相减，不会爆炸。所以我们最好这样：
这种方法，就叫做压位。使用压位的高精，就叫做压位高精。
平常我们所说的压x位，其实就是把数分成若干部分，使得每一个部分最大是x位数。（为什么是最大呢，因为有可能没分完。）
有好奇心强的小伙伴可能会问了，压位看起来算的次数减少，可每一个位置内置的加法算法不是也增多了吗？这样岂不是拆东墙补西墙？
我谔谔，C++内置的加法算法怎么说也是经过层层优化的，增加位数并不会浪费多长的时间，至少不像我们写的高精度，要不然C++也走不到这样高的巅峰。我们有更高的靠山，就尽量去靠。
代码：
/*
* @Author: crab-in-the-northeast
* @Date: 2020-03-19 23:07:41
* @Last Modified by: crab-in-the-northeast
* @Last Modified time: 2020-03-19 01:07:24
*/
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cassert>
#include <cstring>
#include <string>
int max(int a,int b) {
return a > b ? a : b;
}
static const int base = 1000000000;
static const int width = 9;
struct ubigint {
typedef long long ll;
ll s[8005] = {0};
int len = 1;
ubigint(){}
ubigint(const ubigint& x) {
for(int i = 0; i < x.len; i++)
this -> s[i] = x.s[i];
this -> len = x.len;
}
ubigint(const int& x) {
int tmp = x;
this -> len = 0;
do{
this -> s[this -> len++] = tmp % base;
tmp /= base;
}while(tmp);
}
ubigint operator = (const std :: string& str) {
std :: string tmp = str;
while(tmp.length() > width) {
this -> s[this -> len - 1] = atoi(tmp.substr(tmp.length() - width).c_str());
tmp.erase(tmp.length() - width);
this -> len++;
}
this -> s[this -> len - 1] = atoi(tmp.c_str());
return *this;
}
void clear_zero() {
while(this -> len > 1 && !(this -> s[this -> len - 1])) this -> len--;
}
ubigint operator = (const ubigint& x) {
this -> len = x.len;
for(register int i = 0; i < this -> len; i++)
this -> s[i] = x.s[i];
return *this;
}
bool operator < (const ubigint& b) const {
if(this -> len != b.len) return this -> len < b.len;
for(register int i = this -> len - 1; i >= 0; i--)
if(this -> s[i] != b.s[i])
return this -> s[i] < b.s[i];
return false;
}
bool operator > (const ubigint& b) const {
return b < *this;
}
bool operator <= (const ubigint& b) const {
return !(b < *this);
}
bool operator >= (const ubigint& b) const {
return !(*this < b);
}
bool operator != (const ubigint& b) const {
return *this < b || b < *this;
}
bool operator == (const ubigint& b) const {
return !(b < *this) && !(*this < b);
}
ubigint operator + (const ubigint& b) const {
ubigint res;
res.len = max(this -> len, b.len);
for(register int i = 0, last = 0; i < res.len; i++) {
res.s[i] = this -> s[i] + b.s[i] + last;
last = res.s[i] / base;
res.s[i] %= base;
if(i == res.len - 1 && last) res.len++;
}
res.clear_zero();
return res;
}
ubigint operator - (const ubigint& b) const {
assert(*this >= b);
ubigint res = *this;
for(register int i = 0, last = 0; i < this -> len; i++) {
res.s[i] -= b.s[i] + last;
if(res.s[i] < 0) {
res.s[i] += base;
last = 1;
}else last = 0;
}
res.clear_zero();
return res;
}
ubigint operator * (const ubigint& b) const {
if(*this == 0 || b == 0) return ubigint(0);
//if(*this == 1) return b;
//if(b == 1) return *this;
ubigint res;
res.len = this -> len + b.len + 1;
for(register int i = 0; i < this -> len; i++) {
for(register int j = 0; j < b.len; j++) {
res.s[i + j] += this -> s[i] * b.s[j];
res.s[i + j + 1] += res.s[i + j] / base;
res.s[i + j] %= base;
}
}
res.clear_zero();
return res;
}
ubigint operator / (const ubigint& b) const {
if(b > *this) return 0;
//if(b == *this) return 1;
ubigint res = 0, div = b, mod = *this;
while(div * ubigint(base) <= *this) div *= ubigint(base);
for(;;) {
int l = 1, r = base, mid;
if(mod >= div) {
while(r > l + 1) {
int mid = l + r >> 1;
if(div * ubigint(mid) > mod) r = mid;
else l = mid;
}
mod -= div * ubigint(l);
res.s[res.len - 1] += l;
}
if(div == b) break;
res.len++;
for(register int i = 1; i < div.len; i++)
div.s[i - 1] = div.s[i];
div.s[div.len - 1] = 0;
div.len--;
}
std :: reverse(res.s, res.s + res.len);
res.clear_zero();
return res;
}
ubigint operator % (const ubigint& b) const {
return *this - (*this / b * b);
}
ubigint operator += (const ubigint& b) {*this = *this + b; return *this;}
ubigint operator -= (const ubigint& b) {*this = *this - b; return *this;}
ubigint operator *= (const ubigint& b) {*this = *this * b; return *this;}
ubigint operator /= (const ubigint& b) {*this = *this / b; return *this;}
ubigint operator %= (const ubigint& b) {*this = *this % b; return *this;}
friend std :: istream& operator >> (std :: istream& in, ubigint& b) {
std :: string str;
in >> str;
b = str;
return in;
}
friend std :: ostream& operator << (std :: ostream& out, ubigint b) {
out << b.s[b.len - 1];
for(register int i = b.len - 2; i >= 0; i--) {
int div = base / 10;
while(b.s[i] < div) {
std :: cout << 0;
div /= 10;
}
if(b.s[i]) out << b.s[i];
}
return out;
}
};
int main() {
ubigint a,b;
std :: cin >> a >> b;
std :: cout << a + b << std :: endl;
if(a >= b) std :: cout << a - b << std :: endl;
else std :: cout << '-' << b - a << std :: endl;
std :: cout << a * b << std :: endl;
std :: cout << a / b << std :: endl;
std :: cout << a % b << std :: endl;
return 0;
}
这是静态数组版本的，我们还可以用动态数组vector来重构代码。不过这样时间需要的就长啦（写这个的时候懒得写this ->了qvq）
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cassert>
#include <vector>
int max(int a,int b) {
return a > b ? a : b;
}
struct ubigint {
typedef unsigned long long ull;
static const int base = 100000000;
static const int width = 8;
std :: vector<int> s;
ubigint& clear_zero() {
while(!s.back() && s.size() > 1) s.pop_back();
return *this;
}
ubigint(ull num = 0) {*this = num;}
ubigint(std :: string str) {*this = str;}
ubigint& operator = (ull num) {
s.clear();
do {
s.push_back(num % base);
num /= base;
}while(num);
return *this;
}
ubigint& operator = (const std :: string& str) {
s.clear();
int x;
int len = (str.length() - 1) / width + 1;
for(int i = 0; i < len; i++) {
int endidx = str.length() - i * width;
int startidx = max(0, endidx - width);
int x;
sscanf(str.substr(startidx, endidx - startidx).c_str(), "%d", &x);
s.push_back(x);
}
return (*this).clear_zero();
}
bool operator < (const ubigint& b) const {
if(s.size() != b.s.size()) return s.size() < b.s.size();
for(int i = s.size() - 1; i >= 0; i--)
if(s[i] != b.s[i])
return s[i] < b.s[i];
return false;
}
bool operator > (const ubigint& b) const {return b < *this; }
bool operator <= (const ubigint& b) const {return !(b < *this);}
bool operator >= (const ubigint& b) const {return !(*this < b);}
bool operator == (const ubigint& b) const {return !(b < *this) && !(b > *this);}
bool operator != (const ubigint& b) const {return b < *this || *this < b;}
ubigint operator + (const ubigint& b) const {
ubigint res;
res.s.clear();
for(int i = 0, x = 0; x || i < s.size() || i < b.s.size(); i++, x /= base) {
if(i < s.size()) x += s[i];
if(i < b.s.size()) x += b.s[i];
res.s.push_back(x % base);
}
return res.clear_zero();
}
ubigint operator - (const ubigint& b) const {
assert(*this >= b);
ubigint res;
res.s.clear();
for(int i = 0, last = 0;last || i < s.size() || i < b.s.size();i++) {
int x = s[i] + last;
if(i < b.s.size()) x -= b.s[i];
if(x < 0) {
last = -1;
x += base;
}else last = 0;
res.s.push_back(x);
}
return res.clear_zero();
}
ubigint operator * (const ubigint& b) const {
std :: vector<ull> tmp(s.size() + b.s.size(),0);
ubigint res;
res.s.clear();
for(int i = 0; i < s.size(); i++)
for(int j = 0; j < b.s.size(); j++)
tmp[i + j] += ull(s[i]) * b.s[j];
ull last = 0;
for(int i = 0; last || i < tmp.size(); i++) {
ull x = tmp[i] + last;
res.s.push_back(x % base);
last = x / base;
}
return res.clear_zero();
}
int midsearch(const ubigint& b, const ubigint& m) const {
int l = 0, r = base - 1;
while(1) {
int mid = l + r >> 1;
if(b * mid <= m && b * (mid + 1) > m) return mid;
if(b * mid <= m) l = mid;
else r = mid;
}
}
ubigint operator / (const ubigint& b) const {
assert(b > 0);
ubigint res = *this, mod;
for(int i = s.size() - 1; i >= 0; i--) {
mod = mod * base + s[i];
res.s[i] = midsearch(b, mod);
mod -= b * res.s[i];
}
return res.clear_zero();
}
ubigint operator % (const ubigint& b) const {
assert(b > 0);
ubigint res = *this, mod;
for(int i = s.size() - 1; i >= 0; i--) {
mod = mod * base + s[i];
res.s[i] = midsearch(b, mod);
mod -= b * res.s[i];
}
return mod.clear_zero();
}
ubigint& operator += (const ubigint& b) {*this = *this + b; return *this;}
ubigint& operator -= (const ubigint& b) {*this = *this - b; return *this;}
ubigint& operator *= (const ubigint& b) {*this = *this * b; return *this;}
ubigint& operator /= (const ubigint& b) {*this = *this / b; return *this;}
ubigint& operator %= (const ubigint& b) {*this = *this % b; return *this;}
friend std :: istream& operator >> (std :: istream& in, ubigint& x) {
std :: string str;
if(!(in >> str)) return in;
x = str;
return in;
}
friend std :: ostream& operator << (std :: ostream& out, ubigint x) {
out << x.s.back();
for(int i = x.s.size() - 2; i >= 0; i--) {
char buf[20];
sprintf(buf, "%08d", x.s[i]);
for(int j = 0; j < strlen(buf); j++)
out << buf[j];
}
return out;
}
};
ubigint a,b;
int main() {
std :: cin >> a >> b;
std :: cout << a + b << std :: endl;
if(a >= b) std :: cout << a - b << std :: endl;
else std :: cout << "-" << b - a << std :: endl;
std :: cout << a * b << std :: endl;
std :: cout << a / b << std :: endl;
std :: cout << a % b << std :: endl;
return 0;
}
当然这样的高精度还存在一些不足，比如不支持负数，乘法没有FFT优化等。但是考虑到竞赛中不会出现这么duliu的高精度，本文不作处理。
小试牛刀
最后我们来小试几道牛刀吧。
luogu p1601（高精A + B）：
int main() {
ubigint a, b;
std :: cin >> a >> b;
std :: cout << a + b << std :: endl;
return 0;
}
luogu p2142（高精A - B）：
这道题需要负数诶！不过没关系，我们有一个小伎俩：
int main() {
ubigint a,b;
std :: cin >> a >> b;
if(a < b) std :: cout << "-" << b - a << std :: endl;
else std :: cout << a - b<< std :: endl;
return 0;
}
是不是既简单又方便的偷懒方式呢~
luogu p1303（高精A * B）：
int main() {
ubigint a, b;
std :: cin >> a >> b;
std :: cout << a * b << std :: endl;
return 0;
}
luogu p1480 & luogu p2005（高精A / B）：
后面的那个是前面的那个的升级版。双倍经验美滋滋
int main() {
ubigint a,b;
std :: cin >> a >> b;
std :: cout << a / b << std :: endl;
return 0;
}
luogu p1932（高精合集）：
int main() {
ubigint a,b;
std :: cin >> a >> b;
std :: cout << a + b << std :: endl;
if(a >= b) std :: cout << a - b << std :: endl;
else std :: cout << '-' << b - a << std :: endl;
std :: cout << a * b << std :: endl;
std :: cout << a / b << std :: endl;
std :: cout << a % b << std :: endl;
return 0;
}
因为原题中的减法涉及到了负数，所以减法做了这样的处理qvq（别打我啊qvq）
而且注意，亲测本题如果用动态数组版本是无法AC的，结果是80TLE，必须得吸氧才能AC。所以这道题请使用静态数组版本。
luogu p1009（阶乘之和）：
int main() {
int n;
ubigint ans;
std :: cin >> n;
for(int i = 1; i <= n; i++) {
ubigint mul = 1;
for(int j = 2; j <= i; j++)
mul *= j;
ans += mul;
}
std :: cout << ans << std :: endl;
return 0;
}
luogu p1591（阶乘数码，一个数的阶乘中某个数码出现了几次）：
直接按照题意模拟，没啥好说的吧qaq。
int main() {
int T;
std :: cin >> T;
while(T--) {
int n, num, ans = 0;
std :: cin >> n >> num;
ubigint res = 1;
for(int i = 2; i <= n; i++)
res *= i;
ull tmp = res.s.back();
while(tmp) {
if(tmp % 10 == num) ans++;
tmp /= 10;
}
for(int i = res.s.size() - 2; i >= 0; i--) {
char buf[20];
sprintf(buf, "%08d", res.s[i]);
for(int j = 0; j < strlen(buf); j++)
if(buf[j] - '0' == num) ans++;
}
std :: cout << ans << std :: endl;
}
}
luogu p1255（数楼梯）：
此题的主要思路是递推，套上了高精度的外衣而已。但是这个过于简单就归于高精模板里吧。
const int maxn = 5005;
int n;
ubigint a[maxn] = {0, 1, 2};
int main() {
std :: cin >> n;
if(n <= 2) {
std :: cout << a[n] << std :: endl;
return 0;
}
for(int i = 3; i <= n; i++)
a[i] = a[i - 1] + a[i - 2];
std :: cout << a[n] << std :: endl;
return 0;
}
qvq别忘了点个赞再走呀qvq！