大整数四则运算（vector与数组两种版本实现)
每逢大整数四则运算，都会怯懦，虽是算法竞赛必会的东西，也零散的学过，简单的总结过，但不成体系的东西心里一直没底。
所以今天消耗了大量的卡路里，啃了几套模板之后终于总结成了一套自己的模板
再也不用担心大整数啦
基础
1. 高精度加法
高精度加法等同于算术加法，做单个的加法运算之后存下进位
- A和B都为正整数
- vector中下标为0存的是低位（以下都是）
vector<int> add(vector<int> &A,vector<int> &B){
if(A.size() < B.size()) return add(B,A);//这是为了保证A的位数比B大
vector<int> C;
int t = 0;
for(int i = 0;i < A.size();i++){
t += A[i];
if(i < B.size()) t += B[i];
C.push_back(t % 10);
t /= 10;
}
if(t) C.push_back(t);
//清除前缀0，为了防止000+0等输入情况
while(C.size() > 1 && C.back() == 0)C.pop_back();
return C;
}
2. 高精度减法
减法同加法原理一样，也是计算一位，下面用了t这个变量存下向更高一位借的1
- A和B必须为正整数，结果返回|A-B|
vector<int> sub(vector<int> &A,vector<int> &B){
vector<int> C;
for(int i= 0,t = 0;i<A.size();i++){
t = A[i] - t;
if(i < B.size()) t -= B[i];
C.push_back((t+10)%10);
if(t < 0) t = 1;
else t = 0;
}
//清除前缀0
while(C.size() > 1 && C.back() == 0)C.pop_back();
return C;
}
3. 高精度乘低精度
高精度的每一位与低精度数字进行相乘，因为相乘最大为81，所以结果对10取余得到的数字就是结果在当前位的结果，然后对结果除以10保存更高一位的进位数字
- A存放正整数，b也为正整
vector<int> mul(vector<int> &A,int b){
vector<int> C;
int t = 0;
for(int i = 0;i < A.size() || t; i++){
if(i < A.size()) t += A[i] * b;
C.push_back(t%10);
t /= 10;
}
return C;
}
4. 高精度除以低精度
在计算除法时，会从被除数的最高位算起，每一位的计算结果就是当前余数对除数做除法的结果。然后计算下一位（更小的一位，设第x位）时，要更新余数即 余数*10 + 被除数的x位。
- A 存放正整数，b也为正整数，r为余数
vector<int> div(vector<int> & A,int b,int &r){
vector<int> C;
r = 0;
for(int i = A.size() - 1;i >= 0;i--){
r = r * BASE + A[i];
C.push_back(r/b);
r %= b;
}
reverse(C.begin(),C.end());
while(C.size() > 1 && C.back() == 0)C.pop_back();
return C;
}
什么？乘低精度还不够？除低精度太low？那我们考虑一些不太常见的情况（openjudge百炼2980）
5. 高精度乘高精度
首先说一下乘法计算的算法，从低位向高位乘，在竖式计算中，我们是将乘数第一位与被乘数的每一位相乘，记录结果之后，用第二位相乘，记录结果并且左移一位，以此类推，直到计算完最后一位，再将各项结果相加，得出最后结果。
计算的过程基本上和小学生列竖式做乘法相同。为了编程方便，并不急于处理进位，而是先将所有位上的结果计算之后，再从前往后以此处理进位。
总结一个规律: 即一个数的第i 位和另一个数的第j 位相乘所得的数，一定是要累加到结果的第i+j 位上。这里i, j 都是从数字低位开始从0 开始计数。
ans[i+j] = a[i]*b[j];
另外注意进位时要处理，当前的值加上进位的值再看本位数字是否又有进位；前导清零。
vector<int> mul( vector<int> &A, vector<int> &B) {
int la = A.size(),lb = B.size();
vector<int> C(la+lb+10,0);//提前申请结果所需的空间
for(int i=0;i<la;i++){
for(int j=0;j<lb;j++){
C[i+j] += A[i] * B[j];
}
}
for(int i=0;i<C.size();i++){
if(C[i] >= 10){
C[i + 1] += C[i] / 10;
C[i] %= 10;
}
}
//处理前导0
while(C.size() > 1 && C.back() == 0)C.pop_back();
return C;
}
6. 高精度除以高精度
大数除法是四则运算里面最难的一种。不同于一般的模拟，除法操作不是模仿手工除法，而是利用减法操作来实现的。其基本思想是反复做减法，看从被除数里面最多能减去多少个除数，商就是多少。逐个减显然太慢，要判断一次最多能减少多少个整数(除数)的10的n次方。
以7546除以23为例：
先用7546减去23的100倍，即减去2300，可以减3次，余下646，此时商就是300 (300=100*3)；
然后646减去23的10倍，即减去230，可以减2次，余下186，此时商就是320 (320=300+10*2)；
然后186减去23，可以减8次，余下2，此时商就是328 (328=320+1*8)；
因为2除以23的结果小于1，而我们又不用计算小数点位，所以不必再继续算下去了。
计算结果中没有小数：
vector<int> div(vector<int> A,vector<int> B){
int la = A.size(),lb = B.size();
int dv = la - lb; // 相差位数
vector<int> C(dv+1,0);//提前申请结果所需空间
//将除数扩大，使得除数和被除数位数相等
reverse(B.begin(),B.end());
for(int i=0;i<dv;i++)B.push_back(0);
reverse(B.begin(),B.end());
lb = la;
for(int j=0;j<=dv;j++){
while(!cmp(A,B)){//这里用到一个比较函数，cmp返回的是A是否比B小，此处判断的是A是否大于等于B，该循环当A无法再进行减法时结束
A = sub(A,B);
C[dv-j]++;//答案里相应的那一位数字++
}
B.erase(B.begin());//缩小被除数
}
while(C.size()>1 && C.back() == 0)C.pop_back();
return C;
}
好了，基础部分到此结束，将上面的内容封装好之后，我们就可以比较完美的在比赛中使用了。
综合
- 该结构体是借用紫书上的模板，BASE是数组一位上面可以存数的值。也可以理解为是一个BASE进制数，WIDTH对应的是BASE的宽度
- 因为大整数乘大整数所用计算方法的特殊性，BASE应当设置为10，WIDTH设置为1，相应的重载输出流里面的sprinf函数中也应该控制为1位而不是8位
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct BigInteger{
//BASE为vector数组中一位中最大存储的数字，前面都是以10计算的
//WIDTH为宽度
static const int BASE = 10000;
static const int WIDTH = 4;
vector<int> s;
//正数为1，负数为-1
int flag = 1;
//构造函数
BigInteger(int num = 0){*this = num;}
BigInteger(string str){*this = str;}
BigInteger(const BigInteger& t){
this->flag = t.flag;
this->s = t.s;
}
//赋值函数
BigInteger operator = (int num){
s.clear();
do {
s.push_back(num % BASE);
num /= BASE;
}while(num > 0);
return *this;
}
BigInteger operator = (string &str){
s.clear();
int x,len = (str.length()-1)/WIDTH + 1;
for(int i=0;i<len;i++){
int end = str.length() - i*WIDTH;
int start = max(0,end - WIDTH);
sscanf(str.substr(start,end-start).c_str(),"%d",&x);
s.push_back(x);
}
return *this;
}
//基本比较函数 A < B
bool cmp( vector<int> &A, vector<int> & B){
if(A.size() != B.size())return A.size() < B.size();
for(int i=A.size()-1;i>=0;i--){
if(A[i] != B[i]){
return A[i] < B[i];
}
}
return false;
}
//比较函数如果小于则返回真
bool operator < ( BigInteger & b){
return cmp(s,b.s);
}
bool operator > ( BigInteger& b){
return b < *this;
}
bool operator <= ( BigInteger &b){
return !(b < *this);
}
bool operator >= ( BigInteger &b){
return !(*this < b);
}
bool operator == ( BigInteger &b){
return !(b < *this) && (*this < b);
}
//基本四则运算
vector<int> add(vector<int> &A, vector<int> &B);
vector<int> sub(vector<int> &A, vector<int> &B);
vector<int> mul(vector<int> &A, int b);
vector<int> mul(vector<int> &A, vector<int> &B);
vector<int> div(vector<int> &A, int b);
vector<int> div(vector<int> A, vector<int> B);
//重载运算符
BigInteger operator + (BigInteger &b);
BigInteger operator - (BigInteger &b);
BigInteger operator * (BigInteger &b);
BigInteger operator * (int b);
BigInteger operator / (BigInteger & b);
BigInteger operator / (int b);
};
//重载<<
ostream& operator << (ostream &out,const BigInteger& x) {
if(x.flag == -1)out << '-';
out << x.s.back();
for(int i = x.s.size() - 2; i >= 0;i--){
char buf[20];
sprintf(buf,"%04d",x.s[i]);//08d此处的8应该与WIDTH一致
for(int j=0;j<strlen(buf);j++)out<<buf[j];
}
return out;
}
//重载输入
istream& operator >> (istream & in,BigInteger & x){
string s;
if(!(in>>s))return in;
x = s;
return in;
}
vector<int> BigInteger::add( vector<int> &A, vector<int> &B){
if(A.size() < B.size())return add(B,A);
int t = 0;
vector<int> C;
for(int i=0;i<A.size();i++){
if(i<B.size())t += B[i];
t += A[i];
C.push_back(t%BASE);
t /= BASE;
}
if(t)C.push_back(t);
while(C.size() > 1 && C.back() == 0)C.pop_back();
return C;
}
vector<int> BigInteger::sub( vector<int> &A, vector<int> &B){
vector<int> C;
for(int i=0,t=0;i<A.size();i++){
t = A[i] - t;
if(i<B.size())t -= B[i];
C.push_back((t+BASE)%BASE);
if(t < 0)t = 1;
else t = 0;
}
while(C.size() > 1 && C.back() == 0)C.pop_back();
return C;
}
vector<int> BigInteger::mul(vector<int> &A,int b){
vector<int> C;
int t = 0;
for(int i = 0;i < A.size() || t; i++){
if(i < A.size()) t += A[i] * b;
C.push_back(t%BASE);
t /= BASE;
}
return C;
}
//大数乘大数乘法需要将BASE设置为10，WIDTH设置为1
vector<int> BigInteger::mul( vector<int> &A, vector<int> &B) {
int la = A.size(),lb = B.size();
vector<int> C(la+lb+10,0);
for(int i=0;i<la;i++){
for(int j=0;j<lb;j++){
C[i+j] += A[i] * B[j];
}
}
for(int i=0;i<C.size();i++){
if(C[i] >= BASE){
C[i + 1] += C[i] / BASE;
C[i] %= BASE;
}
}
while(C.size() > 1 && C.back() == 0)C.pop_back();
return C;
}
//大数除以整数
vector<int> BigInteger::div(vector<int> & A,int b){
vector<int> C;
int r = 0;
for(int i = A.size() - 1;i >= 0;i--){
r = r * BASE + A[i];
C.push_back(r/b);
r %= b;
}
reverse(C.begin(),C.end());
while(C.size() > 1 && C.back() == 0)C.pop_back();
return C;
}
//大数除以大数
vector<int> BigInteger::div(vector<int> A,vector<int> B){
int la = A.size(),lb = B.size();
int dv = la - lb; // 相差位数
vector<int> C(dv+1,0);
//将除数扩大，使得除数和被除数位数相等
reverse(B.begin(),B.end());
for(int i=0;i<dv;i++)B.push_back(0);
reverse(B.begin(),B.end());
lb = la;
for(int j=0;j<=dv;j++){
while(!cmp(A,B)){
A = sub(A,B);
C[dv-j]++;
}
B.erase(B.begin());
}
while(C.size()>1 && C.back() == 0)C.pop_back();
return C;
}
BigInteger BigInteger::operator + ( BigInteger & b){
BigInteger c;
c.s.clear();
c.s = add(s,b.s);
return c;
}
BigInteger BigInteger::operator - ( BigInteger & b) {
BigInteger c;
c.s.clear();
if(*this < b){
c.flag = -1;
c.s = sub(b.s,s);
}
else{
c.flag = 1;
c.s = sub(s,b.s);
}
return c;
}
BigInteger BigInteger::operator *(BigInteger & b){
BigInteger c;
c.s = mul(s,b.s);
return c;
}
BigInteger BigInteger::operator *(int b){
BigInteger c;
c.s = mul(s,b);
return c;
}
BigInteger BigInteger::operator /(BigInteger & b){
BigInteger c;
if(*this < b){
return c;
}
else{
c.flag = 1;
c.s = div(s,b.s);
}
return c;
}
BigInteger BigInteger::operator /(int b){
BigInteger c;
BigInteger t = b;
if(*this < t){
c.s.push_back(0);
}
else{
c.flag = 1;
c.s = div(s,b);
}
return c;
}
另附数组实现版本，适合运算次数较多，但数字位数不太长的情况
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
#define dbg(x...) do { cout << "\033[32;1m" << #x <<" -> "; err(x); } while (0)
void err() { cout << "\033[39;0m" << endl; }
template<class T, class... Ts> void err(const T& arg,const Ts&... args) { cout << arg << " "; err(args...); }
const int N = 500 + 5;
class BigInt{
public:
int a[N];
int len;
public:
const int BASE = 10000;
const int WIDTH = 4;
void mem(){memset(a, 0, sizeof a);}
void adjust(){while(len > 1 && a[len-1] == 0) len--;}
public:
BigInt(){len = 1; mem();}
BigInt(const int);
BigInt(const char*);
BigInt(const BigInt&);
public:
friend istream& operator >> (istream&, BigInt&);
friend ostream& operator << (ostream&, BigInt&);
public:
BigInt operator = (const BigInt &) ;
BigInt operator + (const BigInt &) const;
BigInt operator - (const BigInt &) const;
BigInt operator * (const BigInt &) const;
BigInt operator * (const int &) const;
BigInt operator / (const int &) const;
BigInt operator ^ (const int &) const;
public:
int operator % (const int &T) const;
bool operator > (const BigInt &T) const;
bool operator < (const BigInt &T) const;
bool operator <= (const BigInt &T) const;
bool operator >= (const BigInt &T) const;
bool operator == (const BigInt &T) const;
};
BigInt::BigInt(const int b){
int val = b;
mem();
len = 0;
do {
a[len++] = val % BASE;
val /= BASE;
} while(val);
}
BigInt::BigInt(const char *s){
mem(); int l = strlen(s);
int index = 0;
for(int i=l-1;i>=0;i-=WIDTH){
int t = 0;
int k = i - WIDTH + 1;
if(k < 0) k = 0;
for(int j=k;j<=i;j++){
t = t * 10 + s[j] - '0';
}
a[index++] = t;
}
len = index;
adjust();
}
BigInt::BigInt(const BigInt&b){
len = b.len;
memcpy(a, b.a, sizeof a);
}
istream& operator >>(istream &in, BigInt &b){
char s[N];
in >> s;
b = BigInt(s);
return in;
}
ostream& operator <<(ostream &out, BigInt &b){
printf("%d", b.a[b.len-1]);
for(int i=b.len-2;i>=0;i--){
printf("%04d", b.a[i]);
}
return out;
}
BigInt BigInt::operator = (const BigInt &b) {
len = b.len;
memcpy(a, b.a, sizeof a);
return *this;
}
BigInt BigInt::operator + (const BigInt& b)const{
BigInt res;
res.len = max(len, b.len);
int t = 0;
for(int i=0;i<res.len;i++){
if(i < len) t += a[i];
if(i < b.len) t += b.a[i];
res.a[i] = t % BASE;
t /= BASE;
}
if(t) res.a[res.len++] = t;
res.adjust();
return res;
}
BigInt BigInt::operator - (const BigInt& b)const{
BigInt res;
for(int i = 0, t = 0;i < len; i++){
t = a[i] - t;
if(i < b.len) t -= b.a[i];
res.a[i] = (t + BASE) % BASE;
if(t < 0) t = 1;
else t = 0;
}
res.len = len;
res.adjust();
return res;
}
BigInt BigInt::operator * (const BigInt& b)const{
BigInt res;
for(int i=0;i<len;i++){
int up = 0;
for(int j=0;j<b.len;j++){
up = a[i] * b.a[j] + res.a[i+j] + up;
res.a[i+j] = up % BASE;
up = up / BASE;
}
if(up != 0) res.a[i+b.len] = up;
}
res.len = len + b.len;
res.adjust();
return res;
}
BigInt BigInt::operator * (const int &b) const{
int t = 0;
BigInt res;
res.len = len;
for(int i=0;i<len;i++){
t = a[i] * b + t;
res.a[i] = t % BASE;
t /= BASE;
}
if(t) res.a[res.len++] = t;
res.adjust();
return res;
}
BigInt BigInt::operator / (const int &b)const{
BigInt res;
res.len = len;
int i, down = 0;
for(int i=len-1;i>=0;i--){
down = down * BASE + a[i];
res.a[i] = down / b;
down %= b;
}
res.adjust();
return res;
}
BigInt BigInt::operator ^ (const int &n)const{
int i, d = 0;
if(n<0) exit(-1);
if(n == 0) return 1;
if(n == 1) return *this;
BigInt res = *this, t = *this;
for(int b = n-1; b;b>>=1){
if(b & 1) res = res * t;
t = t * t;
}
return res;
}
int BigInt::operator%(const int &b)const{
int i, d = 0;
for(i=len-1;i>=0;i--){
d = ((d * BASE) % b + a[i]) % b;
}
return d;
}
bool BigInt::operator > (const BigInt &T)const{
if(len > T.len) return true;
else if(len < T.len) return false;
int ln = len - 1;
while(a[ln] == T.a[ln] && ln>=0) ln--;
if(ln >= 0 && a[ln] > T.a[ln]) return true;
else return false;
}
bool BigInt::operator < (const BigInt &T)const{
return T > *this;
}
bool BigInt::operator >= (const BigInt &T)const{
return !(T > *this);
}
bool BigInt::operator <= (const BigInt &T)const{
return !(*this > T);
}
bool BigInt::operator == (const BigInt&T)const{
return !(*this > T) && !(T > *this);
}
int n;
BigInt f[110];
int main(){
f[0] = 1;
for(int i=1;i<=100;i++){
f[i] = f[i-1] * (4 * i - 2) / (i + 1);
}
while(~scanf("%d", &n)){
if(n == -1) break;
cout << f[n] << endl;
}
return 0;
}
总结
模板只提供了正整数的运算，对于含有负整数的运算，只需要进行合理的转换即可，见下表
| A | B | + | - | * | / |
|---|---|---|---|---|---|
| + | + | |A|+|B| | |A|-|B| | |A|*|B| | |A|/|B| |
| + | - | |A|-|B| | |A|+|B| | -(|A|*|B|) | -(|A|/|B|) |
| - | + | |B|-|A| | -(|A|+|B|) | -(|A|*|B|) | -(|A|/|B|) |
| - | - | -(|A|+|B|) | |B|-|A| | |A|*|B| | |A|/|B| |
【附：参考资料】
- https://www.cnblogs.com/wuqianling/p/5387099.html
- ACwing算法基础课
- 算法竞赛入门经典
- 红宝书
大整数四则运算（vector与数组两种版本实现)的更多相关文章
- 【转载】pygame安装与两种版本的Python兼容问题
在开始学习游戏编程之前,我们先来安装下pygame和python3.2.5 参考园友: http://www.cnblogs.com/hongten/p/hongten_pygame_install. ...
- Code Kata:大整数比较大小&大整数四则运算---加减法 javascript实现
大整数的四则运算已经是老生常谈的问题了.很多的库也已经包含了各种各样的解决方案. 作为练习,我们从最简单的加减法开始. 加减法的核心思路是用倒序数组来模拟一个大数,然后将两个大数的利用竖式进行运算. ...
- Code Kata:大整数四则运算—除法 javascript实现
除法不可用手工算法来计算,其基本思想是反复做减法,看从被除数里面最多能减去多少个除数,商就是多少. 除法函数: 如果前者绝对值小于后者直接返回零 做减法时,不需要一个一个减,可以以除数*10^n为基数 ...
- Code Kata:大整数四则运算—乘法 javascript实现
上周练习了加减法,今天练习大整数的乘法运算. 采取的方式同样为竖式计算,每一位相乘后相加. 乘法函数: 异符号相乘时结果为负数,0乘任何数都为0 需要调用加法函数 因为输入输出的为字符串,需要去除字符 ...
- 矩阵或多维数组两种常用实现方法 - python
在python中,实现多维数组或矩阵,有两种常用方法: 内置列表方法和numpy 科学计算包方法. 下面以创建10*10矩阵或多维数组为例,并初始化为0,程序如下: # Method 1: list ...
- 手把手教你如何安装Tensorflow（Windows和Linux两种版本）
tensorflow 不支持Python2.7,最好选择下载Python3.5 现在越来越多的人工智能和机器学习以及深度学习,强化学习出现了,然后自己也对这个产生了点兴趣,特别的进行了一点点学习,就通 ...
- Tensorflow从0到1（一）之如何安装Tensorflow（Windows和Linux两种版本）
现在越来越多的人工智能和机器学习以及深度学习,强化学习出现了,然后自己也对这个产生了点兴趣,特别的进行了一点点学习,就通过这篇文章来简单介绍一下,关于如何搭建Tensorflow以及如何进行使用.建议 ...
- OC动态创建的问题变量数组.有数组,在阵列13要素,第一个数据包阵列,每3元素为一组,分成若干组,这些数据包的统一管理。最后，一个数组.(要动态地创建一个数组).两种方法
<span style="font-size:24px;">//////第一种方法 // NSMutableArray *arr = [NSMutable ...
- OC中动态创建可变数组的问题.有一个数组,数组中有13个元素,先将该数组进行分组,每3个元素为一组,分为若干组,最后用一个数组统一管理这些分组.(要动态创建数组).两种方法
<span style="font-size:24px;">//////第一种方法 // NSMutableArray *arr = [NSMutableArray a ...
随机推荐
- Spring Security OAuth2.0认证授权三：使用JWT令牌
Spring Security OAuth2.0系列文章: Spring Security OAuth2.0认证授权一:框架搭建和认证测试 Spring Security OAuth2.0认证授权二: ...
- WebRTC ICE 状态与提名处理
大家都知道奥斯卡有提名,其实在 WebRTC 的 ICE 中也有提名,有常规的提名,也有激进的提名,而且提名的候选人不一定是最优秀的候选人喔,本文就带你一探其中玄妙.文章内容主要描述 RFC 5245 ...
- SpringBoot项目，如何优雅的把接口参数中的空白值替换为null值？
问题发生 我们公司代码生成的时候,查询列表统一都是使用了setEntity() ,查询写法如下: public List<BasReservoirArea> selectList(BasR ...
- 【剑指 Offer】07.重建二叉树
题目描述 输入某二叉树的前序遍历和中序遍历的结果,请重建该二叉树.假设输入的前序遍历和中序遍历的结果中都不含重复的数字. 示例: 前序遍历 preorder = [3,9,20,15,7] 中序遍历 ...
- Centos 打开ssh 密码验证 和 root 登录
# 1 打开系统的密码验证功能: vim /etc/ssh/sshd_config #允许使用密码登录(注释此行 就是允许证书登录) PasswordAuthentication yes # 2 打开 ...
- 【Oracle】查看表空间是否为自动扩展
查看指定的表空间是否为自动扩展 SQL> select file_name,autoextensible,increment_by from dba_data_files where tab ...
- LeetCode965. 单值二叉树
题目 1 class Solution { 2 public: 3 int flag = 0; 4 bool isUnivalTree(TreeNode* root){ 5 isUnivalTree1 ...
- ctfhub技能树—web前置技能—http协议—302跳转
开启靶机 打开环境,查看显示 点击Give me Flag后发生跳转 根据题目提示为HTTP临时重定向 简单记录一下HTTP临时重定向是什么 HTTP重定向:服务器无法处理浏览器发送过来的请求(req ...
- Spring依赖注入的方式、类型、Bean的作用域、自动注入、在Spring配置文件中引入属性文件
1.Spring依赖注入的方式 通过set方法完成依赖注入 通过构造方法完成依赖注入 2.依赖注入的类型 基本数据类型和字符串 使用value属性 如果是指向另一个对象的引入 使用ref属性 User ...
- pytorch——合并分割
分割与合并 import torch import numpy as np #假设a是班级1-4的数据,每个班级里有32个学生,每个学生有8门分数 #假设b是班级5-9的数据,每个班级里有32个学生, ...