每逢大整数四则运算,都会怯懦,虽是算法竞赛必会的东西,也零散的学过,简单的总结过,但不成体系的东西心里一直没底。

所以今天消耗了大量的卡路里,啃了几套模板之后终于总结成了一套自己的模板

再也不用担心大整数啦

基础

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|

【附:参考资料】

  1. https://www.cnblogs.com/wuqianling/p/5387099.html
  2. ACwing算法基础课
  3. 算法竞赛入门经典
  4. 红宝书

大整数四则运算(vector与数组两种版本实现)的更多相关文章

  1. 【转载】pygame安装与两种版本的Python兼容问题

    在开始学习游戏编程之前,我们先来安装下pygame和python3.2.5 参考园友: http://www.cnblogs.com/hongten/p/hongten_pygame_install. ...

  2. Code Kata:大整数比较大小&大整数四则运算---加减法 javascript实现

    大整数的四则运算已经是老生常谈的问题了.很多的库也已经包含了各种各样的解决方案. 作为练习,我们从最简单的加减法开始. 加减法的核心思路是用倒序数组来模拟一个大数,然后将两个大数的利用竖式进行运算. ...

  3. Code Kata:大整数四则运算—除法 javascript实现

    除法不可用手工算法来计算,其基本思想是反复做减法,看从被除数里面最多能减去多少个除数,商就是多少. 除法函数: 如果前者绝对值小于后者直接返回零 做减法时,不需要一个一个减,可以以除数*10^n为基数 ...

  4. Code Kata:大整数四则运算—乘法 javascript实现

    上周练习了加减法,今天练习大整数的乘法运算. 采取的方式同样为竖式计算,每一位相乘后相加. 乘法函数: 异符号相乘时结果为负数,0乘任何数都为0 需要调用加法函数 因为输入输出的为字符串,需要去除字符 ...

  5. 矩阵或多维数组两种常用实现方法 - python

    在python中,实现多维数组或矩阵,有两种常用方法: 内置列表方法和numpy 科学计算包方法. 下面以创建10*10矩阵或多维数组为例,并初始化为0,程序如下: # Method 1: list ...

  6. 手把手教你如何安装Tensorflow(Windows和Linux两种版本)

    tensorflow 不支持Python2.7,最好选择下载Python3.5 现在越来越多的人工智能和机器学习以及深度学习,强化学习出现了,然后自己也对这个产生了点兴趣,特别的进行了一点点学习,就通 ...

  7. Tensorflow从0到1(一)之如何安装Tensorflow(Windows和Linux两种版本)

    现在越来越多的人工智能和机器学习以及深度学习,强化学习出现了,然后自己也对这个产生了点兴趣,特别的进行了一点点学习,就通过这篇文章来简单介绍一下,关于如何搭建Tensorflow以及如何进行使用.建议 ...

  8. OC动态创建的问题变量数组.有数组,在阵列13要素,第一个数据包阵列,每3元素为一组,分成若干组,这些数据包的统一管理。最后,一个数组.(要动态地创建一个数组).两种方法

    <span style="font-size:24px;">//////第一种方法 //        NSMutableArray *arr = [NSMutable ...

  9. OC中动态创建可变数组的问题.有一个数组,数组中有13个元素,先将该数组进行分组,每3个元素为一组,分为若干组,最后用一个数组统一管理这些分组.(要动态创建数组).两种方法

    <span style="font-size:24px;">//////第一种方法 // NSMutableArray *arr = [NSMutableArray a ...

随机推荐

  1. Linux服务器初始化调优及安全加固

    一,开启iptables 仅开放必要的SSH端口和监控端口 示例:SSH tcp 22snmpd udp 161nrpe tcp 5666本人公网IP全端口开放 二,除非特别熟悉selinux配置,否 ...

  2. [C#] 老古董的 Microsoft Chart Controls 也可以进行数据预测

    我要先声明,这篇文章介绍到的内容虽说不是不能用,但玩乐成分居多,大家看看就好,不要太认真. 1. Microsoft Chart Controls 中的 FinancialFormula 在上一篇文章 ...

  3. js 数组的方法总结

    1.Array.map() 此方法是将数组中的每个元素调用一个提供的函数,结果作为一个新的数组返回,并没有改变原来的数组 let arr = [1, 2, 3, 4, 5]     let newAr ...

  4. linux下的文件类型

    在Linux中一切设备皆文件,首先来看一下Linux下的文件都有哪些分类,也就是文件类型 文件类型:普通文件(包括shell脚本,文档,音频,视频).目录文件.设备文件(又细分为字符设备文件和块设备文 ...

  5. top有用的开关控制命令

    [原创]本文为原创博文,转发请注明出处:https://www.cnblogs.com/dingbj/p/top_command.html 今天偶然用到top命令,在动态刷新的界面上输入h顺便看了下帮 ...

  6. oracle move表空间(分区表,索引)

    1.修改分区表分区表空间 SELECT 'ALTER TABLE ' || table_owner || '.' || TABLE_NAME || ' MOVE PARTITION ' || PART ...

  7. 源代码增强的一点说明(souce code enhance )

    souce code enhance 分为显式和隐式两种. 下面以显式创建为例子: 1.在ABAP编辑器中, 打开想要编辑的程序,切换到可编辑模式 2.在源代码中的指定位置右键,弹出菜单,选择 Enh ...

  8. 三节锂电池充电管理芯片,IC电路图如何设计

    关于三节锂电池供电的产品,在三节锂电池上,需要三个电路系统: 1,三节锂电池保护电路, 2,三节锂电池充电电路, 3,三节锂电池输出电路. 1.三节锂电池保护电路,芯片电路图 控制三节锂电池池的充电电 ...

  9. Mysql简要概述

    Mysql学习笔记 Mysql简介: ​ Mysql是一个轻量级关系型数据库管理系统,由瑞典Mysql AB公司开发,目前属于Oracle公司.目前Mysql被广泛地应用在Internet上的中小型网 ...

  10. 阿里云VOD(三)

    一.视频播放器 参考文档:https://help.aliyun.com/document_detail/125570.html?spm=a2c4g.11186623.6.1083.1c53448bl ...