高精压位（已封装）

最新推荐文章于 2021-12-10 16:40:38 发布
最新推荐文章于 2021-12-10 16:40:38 发布
阅读量276 收藏
点赞数
分类专栏： 自用封装模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/donname/article/details/109086835
版权

自己写的高精压位板子（限于正整数之间的四则预算）

多次使用交题未出现问题，可安心食用(雾),除法不太会，我写的容易TLE和MLE，需要高精除高精，高精模高精不建议使用此模板，不涉及高精除高精和高精模高精时可去掉高精除高精，高精模高精操作及辅助数组pw[]

#include<iostream>
#include<algorithm>
#include<string>
#include<cstring>
#include<vector>
#include<cstdio>

#define int long long
#define iter vector<int>::iterator

using namespace std;

const int base = 100000000;
const int N = 300;

int cnt;//2的最高次方

struct BigInteger {

	vector<int> ans;
	bool sign;

	BigInteger();
	BigInteger(int);

	bool operator ==(const BigInteger&)const;
	bool operator <(const BigInteger&)const;
	bool operator >(const BigInteger&)const;
	bool operator <=(const BigInteger&)const;
	bool operator >=(const BigInteger&)const;
	bool operator !=(const BigInteger&)const;

	BigInteger operator = (const BigInteger&);
	BigInteger operator - (const BigInteger&) const;
	BigInteger operator + (const BigInteger&) const;
	BigInteger operator * (const BigInteger&) const;
	BigInteger operator * (const int&) const;
	BigInteger operator / (const BigInteger&) const;
	BigInteger operator / (const int&) const;
	BigInteger operator %(const BigInteger&)const;
	int operator % (const int&) const;
	BigInteger operator ^ (const int&) const;

	void operator -=(const BigInteger&);
	void operator +=(const BigInteger&);
	void operator *=(const BigInteger&);
	void operator /=(const BigInteger&);
	void operator %=(const BigInteger&);

	void input(string);
	void output();

}pw[N];

void div_ans_mod(BigInteger& x) {
	BigInteger p(2);
	pw[0] = BigInteger(1);
	pw[1] = p;
	while (pw[cnt] <= x) {
		++cnt;
		pw[cnt] = p * pw[cnt - 1];
	}
}

BigInteger::BigInteger() {
	sign = true;
	ans.clear();
}

BigInteger::BigInteger(int n) {
	sign = true;
	while (n) {
		ans.push_back(n % base);
		n /= base;
	}
}

void BigInteger::input(string str) {
	int top = str.length() - 1;
	while (top - 7 >= 0) {
		int temp = (str[top] - '0') + (str[top - 1] - '0') * 10 + (str[top - 2] - '0') * 100 + (str[top - 3] - '0') * 1000
			+ (str[top - 4] - '0') * 10000 + (str[top - 5] - '0') * 100000 + (str[top - 6] - '0') * 1000000 + (str[top - 7] - '0') * 10000000;
		top -= 8;
		ans.push_back(temp);
	}
	if (top >= 0) {
		int temp = 0;
		for (int i = 0; i <= top; i++) {
			temp = temp * 10 + (str[i] - '0');
		}
		ans.push_back(temp);
	}
}

void BigInteger::output() {
	if (sign == false) cout << "-";
	for (int i = ans.size() - 1; i > 0; i--) {
		if (ans[i] == 0) ans.pop_back();
		else break;
	}
	printf("%lld", ans.back());
	ans.pop_back();
	while (!ans.empty()) {
		printf("%08d", ans.back());
		ans.pop_back();
	}
	printf("\n");
}

bool BigInteger:: operator==(const BigInteger& x) const {
	if (ans.size() != x.ans.size()) return false;
	for (int i = ans.size() - 1; i >= 0; i--) {
		int a = ans[i];
		int b = x.ans[i];
		if (a != b) return false;
	}
	return true;
}

bool BigInteger::operator!=(const BigInteger& x)const {
	return !(x == *this);
}

bool BigInteger:: operator<(const BigInteger& x) const {
	if (ans.size() != x.ans.size()) return ans.size() < x.ans.size();
	for (int i = ans.size() - 1; i >= 0; i--) {
		int a = ans[i];
		int b = x.ans[i];
		if (a >= b) return false;
		if (a < b) return true;
	}
	return false;
}

bool BigInteger:: operator>(const BigInteger& x) const {
	if (ans.size() != x.ans.size()) return ans.size() > x.ans.size();
	for (int i = ans.size() - 1; i >= 0; i--) {
		int a = ans[i];
		int b = x.ans[i];
		if (a > b) return true;
		if (a <= b) return false;
	}
	return false;
}

bool BigInteger:: operator<=(const BigInteger& x) const {
	if (ans.size() != x.ans.size()) return ans.size() < x.ans.size();
	for (int i = ans.size() - 1; i >= 0; i--) {
		int a = ans[i];
		int b = x.ans[i];
		if (a > b) return false;
		if (a < b) return true;
	}
	return true;
}

bool BigInteger:: operator>=(const BigInteger& x) const {
	if (ans.size() != x.ans.size()) return ans.size() < x.ans.size();
	for (int i = ans.size() - 1; i >= 0; i--) {
		int a = ans[i];
		int b = x.ans[i];
		if (a > b) return true;
		if (a < b) return false;
	}
	return true;
}

BigInteger BigInteger :: operator +(const BigInteger& x) const {
	int mod = 0;
	BigInteger ret;
	int len = max(ans.size(), x.ans.size());
	for (int i = 0; i < len; i++) {
		mod += (i < ans.size()) ? ans[i] : 0;
		mod += (i < x.ans.size()) ? x.ans[i] : 0;
		ret.ans.push_back(mod % base);
		mod /= base;
	}
	if (mod) ret.ans.push_back(mod);
	while (ret.ans.size() > 1 && ret.ans.back() == 0)ret.ans.pop_back();
	if (ret.ans.empty())ret.ans.push_back(0);
	return ret;
}

BigInteger BigInteger::operator-(const BigInteger& x)const {
	BigInteger ret;
	bool flag = true;
	if (*this < x)flag = false;
	if (*this == x) {
		ret.ans.push_back(0);
		return ret;
	}
	else {
		int len = max(ans.size(), x.ans.size());
		int mod = 0;
		for (int l = 0; l < len; l++) {
			if (flag) {
				mod += (l < ans.size()) ? ans[l] : 0;
				mod -= (l < x.ans.size()) ? x.ans[l] : 0;
			}
			else {
				mod += (l < x.ans.size()) ? x.ans[l] : 0;
				mod -= (l < ans.size()) ? ans[l] : 0;
			}
			ret.ans.push_back((mod + base) % base);
			if (mod < 0) mod = -1;
			else mod = 0;
		}
		ret.sign = flag;
	}
	while (ret.ans.size() > 1 && ret.ans.back() == 0)ret.ans.pop_back();
	if (ret.ans.empty())ret.ans.push_back(0);
	return ret;
}

BigInteger BigInteger::operator=(const BigInteger& x) {
	ans.clear();
	sign = x.sign;
	for (int i = 0; i < x.ans.size(); i++) {
		ans.push_back(x.ans[i]);
	}
	return *this;
}

BigInteger BigInteger:: operator*(const int& x) const {
	BigInteger ret;
	int len = ans.size();
	for (int i = 0; i <= len; i++) {
		ret.ans.push_back(0);
	}
	int mod = 0;
	for (int i = 0; i < ans.size(); i++) {
		mod += ans[i] * x;
		if (mod >= base) {
			ret.ans[i] = mod % base;
			ret.ans[i + 1] = mod / base;
		}
		else {
			ret.ans[i] = mod;
		}
		mod = 0;
	}
	while (ret.ans.size() > 1 && ret.ans.back() == 0)ret.ans.pop_back();
	if (ret.ans.empty())ret.ans.push_back(0);
	return ret;
}

BigInteger BigInteger::operator*(const BigInteger& x)const {
	BigInteger ret;
	int len1 = ans.size();
	int len2 = x.ans.size();
	int len = len1 + len2;
	for (int i = 0; i <= len; i++) {
		ret.ans.push_back(0);
	}
	int mod = 0;
	for (int i = 0; i < ans.size(); i++) {
		for (int j = 0; j < x.ans.size(); j++) {
			mod += x.ans[j] * ans[i];
			mod += ret.ans[i + j];
			if (mod >= base) {
				ret.ans[i + j] = mod % base;
				ret.ans[i + j + 1] += mod / base;
			}
			else {
				ret.ans[i + j] = mod;
			}
			mod = 0;
		}
	}
	if (sign != x.sign) ret.sign = false;
	while (ret.ans.size() > 1 && ret.ans.back() == 0)ret.ans.pop_back();
	if (ret.ans.empty())ret.ans.push_back(0);
	return ret;
}

BigInteger BigInteger::operator/(const int& x) const {
	BigInteger ret;
	int down = 0;
	int p = 0;
	for (int i = ans.size() - 1; i >= 0; i--) {
		down = ans[i] + down * base;
		if (down == 0 && i) {
			ret.ans.insert(ret.ans.begin(), 0);
		}
		else {
			int in = down / x;
			ret.ans.insert(ret.ans.begin(), in);
			down %= x;
		}
	}
	while (ret.ans.size() > 1 && ret.ans.back() == 0)ret.ans.pop_back();
	if (ret.ans.empty())ret.ans.push_back(0);
	return ret;
}

BigInteger BigInteger::operator /(const BigInteger& x) const {
	BigInteger ret;
	int nod = 0;
	BigInteger temp = *this;
	for (int i = cnt; i >= 0; i--) {
		if (pw[i] * x <= temp) {
			BigInteger t = pw[i] * x;
			ret += pw[i];
			temp -= t;
		}
	}
	if (sign != x.sign) ret.sign = false;
	while (ret.ans.size() > 1 && ret.ans.back() == 0)ret.ans.pop_back();
	if (ret.ans.empty())ret.ans.push_back(0);
	return ret;
}

BigInteger BigInteger::operator%(const BigInteger& x) const {
	BigInteger ret;
	BigInteger temp = *this;
	for (int i = cnt; i >= 0; i--) {
		if (pw[i] * x <= temp) {
			temp -= pw[i] * x;
		}
	}
	ret = temp;
	while (ret.ans.size() > 1 && ret.ans.back() == 0)ret.ans.pop_back();
	if (ret.ans.empty())ret.ans.push_back(0);
	return ret;
}

int BigInteger:: operator%(const int& x)const {
	BigInteger ret;
	int down = 0;
	for (int i = ans.size() - 1; i >= 0; i--) {
		down = ans[i] + down * base;
		down %= x;
	}
	return down;
}

BigInteger BigInteger::operator^(const int& n) const {
	BigInteger ret(1);
	BigInteger temp = *this;
	int pow = n;
	while (pow) {
		if (pow & 1) ret = (ret * temp);
		temp = temp * temp;
		pow >>= 1;
	}
	while (ret.ans.size() > 1 && ret.ans.back() == 0)ret.ans.pop_back();
	if (ret.ans.empty())ret.ans.push_back(0);
	return ret;
}

void BigInteger::operator+=(const BigInteger& x) {
	*this = *this + x;
}

void BigInteger::operator-=(const BigInteger& x) {
	*this = *this - x;
}

void BigInteger::operator*=(const BigInteger& x) {
	*this = *this * x;
}

void BigInteger::operator/=(const BigInteger& x) {
	*this = *this / x;
}

void BigInteger::operator%=(const BigInteger& x) {
	*this = *this % x;
}

signed main() {
	
}
donname
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 高精度封装模板
08-27
此模板为已封装模板，包含 高精度的+，-，*，/，不包含小数 by LAZ
高精板子-c++
yufangyirui的博客
11-05 182
运算符重载+压位高精，常数很大。
封装高精度+,-,*,/
qq_45879198的博客
12-10 1008
文章目录前言一、封装高精的+,-,*,/ 前言 将高精的+,-,*,/都用结构体封装了一遍 提示：以下是本篇文章正文内容，下面案例可供参考 一、封装高精的+,-,*,/ #include <bits/stdc++.h> #define maxn 100 //定义数组 using namespace std; struct Bigint{ //封装结构体 int len,a[maxn];//为了兼顾效率与代码复杂度，用len记录位数，a记录每个数位 Bigint(int x=0){
高精度类（压位）C++实现
06-03
高精度压位 #include #include #include using namespace std; const int maxleng=500; class BigInt { private: int leng; int num[maxleng]; public:
[模板]高精度封装运算
蒟蒻柴犬首相的博客
11-10 681
我只是在这备份下……忘记的时候再来看。。#include<bits/stdc++.h> #define maxn 12000 using namespace std; char s1[maxn],s2[maxn]; namespace Bignum { struct bignum { int len,num[maxn]; bignum()
高级电子封装第二版
03-21
高级电子封装原书第二版，Richard K.Ulrich，William D.Brown主编，李虹，张辉，郭志川等译。
一个已封装好的漂亮进度条
10-30
一个已封装好的漂亮进度条
qt自定义标题栏 已封装
08-10
初学者项目需要，自己封装的一个qt自定义标题栏，可以直接调用。环境是vs2013+qt5.6.2，其他环境我也不知道能否使用，谨慎下载。 大部分标题栏的显示效果都放在paintEvent函数中，可以动态更改。大部分效果都写了...
C与C++位运算封装代码.rar
03-21
C与C++位运算封装代码
四位数码管原理及封装
12-21
四位数码管原理图及封装参数，TOP-3461BG型号
C++ （压位）高精度四则运算
07-23
写的比较漂亮的一个高精度四则运算 压位只需改两个const即可~非常方便
高精度计算(三)压位
热门推荐
sSay
08-03 1万+
压位高精
[高精度]高精度的封装
Minecraftwzy的博客
08-05 565
这是我最近学到的一个高精度封装,把高精度运用classclassclass类封装成一个变量IntIntInt。 #include<bits/stdc++.h> using namespace std; class DividedByZeroException {}; class Int { private: vector<char> digits; bool sign; void trim(); public: In
高精度之高精除以高精
wood
04-08 801
Description高精除以高精 Input每组测试数据个栈2行，每行代表一个高精度整数（不超过100位） Output每组测试数据输出占2行，分别输出商和余数。 Sample Input140 5 Sample Output28 0 思路:高精除以高精是用减法模拟除法，对被除数的每一位都减去除数，一直减到当前位置的数字（包含前面的余数）小于除数（由于每一位的数字小于10，所以对于每一位最多进行1
高精度除法+高精度符号运算封装
Luoriliming的博客
07-12 304
转载自https://blog.csdn.net/zufesatoshi/article/details/95549459 40行的高精除，你们敢信？ #include<bits/stdc++.h> using namespace std; const int maxn = 1e6 + 10; int a[maxn], b[maxn], c[maxn], d[maxn]; cha...
板子：压位高精度
少主大人殿下的博客
10-25 559
typedef long long LL; struct bign { static const int WIDTH=4; static const int BASE=10000; int len; int z[1010]; bign() { len=1; memset(z,0,sizeof(z)); } ...
高精度压位
weixin_34268753的博客
06-28 383
唔...很久没讲算法之类的了... 这次讲一个我认为比较黑科技的东东——高精度压位。 普通高精度 先从普通的高精度来讲起。 高精度实际上是将每一位上的数看做一个数放在数组里，再模拟人工计算。 实际数为 123456 (本文最低位(这里就是'6'这个数字) 位数标为1，原因是适应实际运算最高位会改变，而下标不会往负方向减少，即下标没有负的) 这个就是将一个数处理后的样子，之后就可...
【算法专题】高精度之压位
weixin_42638946的博客
11-14 3255
高精度之压位 当数据过大时，此时long long存储不下，因此需要使用vector或者数组存储，然后计算。 一般vector或者数组中每个数据都是一个int，如果每个位置只是存储0~9一位数字的话，比较浪费空间，并且计算也会变慢。因此可以让每个位置存储连续的多位数字，这被称作压位。 这里以压4位为例，也就是说：vector或者数组中每个位置存储四个连续的数字。 1. 基本高精度运算 关于基本高精度计算可以参考：高精度运算 2. 高精度压位运算 压位和不压位的高精度计算存在三点不同点（以下提到的压
半高 msata 封装
最新发布
07-16
半高 mSATA 封装相比于全高 mSATA 封装来说尺寸更小，高度更低。它通常被用于在高度有限的空间中集成SSD存储解决方案。半高 mSATA 封装的尺寸大约是全高封装的一半，通常为30 mm x 26.8 mm x 3.2 mm。这使得它非常...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值