高精度模板

最新推荐文章于 2023-09-30 11:15:33 发布
最新推荐文章于 2023-09-30 11:15:33 发布
阅读量135 收藏
点赞数
分类专栏： 模板 文章标签： 算法 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C2022lihan/article/details/110882098
版权

1.压位（比较简单）

const int up = 10;
const int M = 1000;
struct High {
    int c[up + 5];
    void out () {
        int poi = up;
        while (poi >= 1 && c[poi] == 0) poi--;
        write (c[poi--]);
        while (poi >= 1) printf ("%03d", c[poi--]);
    }
    High () {
        memset (c, 0, sizeof c);
    }
    High (int x) {
        int poi = 1;
        while (x) {
            c[poi++] = x % M;
            x /= M;
        }
        while (poi <= up)
            c[poi++] = 0;
    }
};
bool operator < (High x, High y) {
    for (int i = up; i >= 1; i--) {
        if (x.c[i] < y.c[i]) return 1;
        if (x.c[i] > y.c[i]) return 0;
    }
    return 0;
}
bool operator > (High x, High y) {
    for (int i = up; i >= 1; i--) {
        if (x.c[i] > y.c[i]) return 1;
        if (x.c[i] < y.c[i]) return 0;
    }
    return 0;
}
bool operator == (High x, High y) {
    for (int i = up; i >= 1; i--)
        if (x.c[i] != y.c[i]) return 0;
    return 1;
}
High operator + (High x, High y) {
    High res;
    for (int i = 1; i <= up; i++) {
        res.c[i] += x.c[i] + y.c[i];
        res.c[i + 1] += res.c[i] / M;
        res.c[i] %= M;
    }
    return res;
}
High operator * (High x, High y) {
    High res;
    for (int i = 1; i <= up; i++) {
        for (int j = 1; j <= up && i + j - 1 <= up; j++) {
            res.c[i + j - 1] += x.c[i] * y.c[j];
            res.c[i + j] += res.c[i + j - 1] / M;
            res.c[i + j - 1] %= M;
        }
    }
    return res;
}
High operator - (High x, High y) {
    High res;
    for (int i = 1; i <= up; i++) {
        res.c[i] = x.c[i] - y.c[i];
        if (res.c[i] < 0) {
            res.c[i] += M;
            res.c[i + 1] -= 1;
        }
    }
    return res;
}

2.普通(全)

template <typename T> T Max (T x, T y) { return x > y ? x : y; }
template <typename T> T Min (T x, T y) { return x < y ? x : y; }
template <typename T> T Abs (T x) { return x > 0 ? x : -x; }
struct high_precision {
	vector <int> c;
	
	high_precision () {
		c.clear ();
	}
	void colour (int len) {
		while (c.size () < len) c.push_back (0);
	}
	void operator = (const string x) {
		c.resize (x.size ());
		for (int i = 0; i < x.size (); i++) {
			c[x.size () - i - 1] = x[i] - '0';
		}
	}
	void operator = (int tem) {
		string x; x.clear ();
		while (tem) {
			x += tem % 10 + '0';
			tem /= 10;
		}
		reverse (x.begin (), x.end ());
		c.resize (x.size ());
		for (int i = 0; i < x.size (); i++) {
			c[x.size () - i - 1] = x[i] - '0';
		}
	}
	
	void operator = (LL tem) {
		string x; x.clear ();
		while (tem) {
			x += tem % 10 + '0';
			tem /= 10;
		}
		reverse (x.begin (), x.end ());
		c.resize (x.size ());
		for (int i = 0; i < x.size (); i++) {
			c[x.size () - i - 1] = x[i] - '0';
		}
	}
	void inout () {
		if (c.size () == 0)  {
			putchar ('0');
		}
		else {
			if (c[c.size () - 1] < 0) {
				putchar ('-');
				for (int i = c.size () - 1; i >= 0; i--) {
					printf ("%d", Abs (c[i]));
				}
			}
			else {
				for (int i = c.size () - 1; i >= 0; i--) {
					printf ("%d", c[i]);
				}
			}
		}
	}
};
template <typename T>
high_precision Change (T x) {
	string tem; tem.clear ();
	high_precision ans;
	while (x) {
		tem += x % 10 + '0';
		x /= 10;
	}
	reverse (tem.begin (), tem.end ()); 
	ans = tem;
	return ans;
}
bool operator < (high_precision x, high_precision y) {
	int lenx = x.c.size (), leny = y.c.size ();
	if (x.c[lenx - 1] < 0 && y.c[leny - 1] < 0) {
		if (lenx != leny) return lenx > leny;
		else {
			for (int i = lenx - 1; i >= 0; i--) {
				if (x.c[i] != y.c[i]) {
					return x.c[i] < y.c[i];
				}
			}
			return 0;
		}
	}
	else if (x.c[lenx - 1] < 0 && y.c[leny - 1] > 0) {
		return 1;
	}
	else if (x.c[lenx - 1] > 0 && y.c[leny - 1] < 0) {
		return 0;
	}
	else {
		if (lenx != leny) return lenx < leny;
		else {
			for (int i = lenx - 1; i >= 0; i--) {
				if (x.c[i] != y.c[i]) {
					return x.c[i] < y.c[i];
				}
			}
			return 0;
		}
	}
}
bool operator > (high_precision x, high_precision y) {
	return y < x;
}
bool operator == (high_precision x, high_precision y) {
	if (x.c.size () != y.c.size ()) return 0;
	for (int i = x.c.size () - 1; i >= 0; i--) {
		if (x.c[i] != y.c[i]) return 0;
	}
	return 1;
}
bool operator >= (high_precision x, high_precision y) {
	if (x > y) return 1;
	else if (x == y) return 1;
	else return 0;
}
bool operator <= (high_precision x, high_precision y) {
	if (x < y) return 1;
	else if (x == y) return 1;
	else return 0;
}
high_precision operator * (high_precision x, high_precision y) {
	high_precision ans;
	ans.colour (x.c.size () + y.c.size ());
	for (int i = 0; i < x.c.size (); i++) {
		for (int j = 0; j < y.c.size (); j++) {
			ans.c[i + j] += x.c[i] * y.c[j];
			ans.c[i + j + 1] += ans.c[i + j] / 10;
			ans.c[i + j] %= 10;
		}
	}
	while (ans.c.size () >= 1 && ans.c[ans.c.size () - 1] == 0) ans.c.pop_back ();
	return ans;
}
template <typename T>
high_precision operator * (high_precision a, T y) {
	return a * Change (y);
}
high_precision operator + (high_precision x, high_precision y) {
	high_precision ans;
	int len = Max (x.c.size (), y.c.size ());
	ans.colour (len + 1);
	x.colour (len);
	y.colour(len);
	
	for (int i = 0; i < len; i++) {
		ans.c[i] += x.c[i] + y.c[i];
		ans.c[i + 1] += ans.c[i] / 10;
		ans.c[i] %= 10;
	}
	
	while (ans.c.size () >= 1 && ans.c[ans.c.size () - 1] == 0) ans.c.pop_back ();
	
	return ans;
}
template <typename T>
high_precision operator + (high_precision a, T y) {
	return a + Change (y);
}
high_precision operator - (high_precision x, high_precision y) {
	high_precision ans;
	
	int len = Max (x.c.size (), y.c.size ()) + 3;
	x.colour (len); y.colour (len); ans.colour (len);
	
	bool check = 0;
	if (x < y) swap (x, y), check = 1;
	
	int flag = 0;
	for (int i = 0; i < ans.c.size (); i++) {
		ans.c[i] = x.c[i] - y.c[i] + flag;
		if (ans.c[i] < 0) {
			ans.c[i] += 10;
			flag = -1;
		}
		else {
			flag = 0;
		}
	}
	
	if (check) {
		for (int i = 0; i < ans.c.size (); i++) {
			ans.c[i] = -ans.c[i];
		}
	}
	
	while (ans.c.size () >= 1 && ans.c[ans.c.size () - 1] == 0) ans.c.pop_back ();
	
	return ans; 
}
template <typename T>
high_precision operator - (high_precision a, T y) {
	return a - Change (y);
}
high_precision operator / (high_precision x, high_precision y) {
	high_precision ans, flag;
	ans.colour (x.c.size ());
	for (int i = x.c.size () - 1; i >= 0; i--) {
		flag.c.insert (flag.c.begin (), x.c[i]);
		int Index;
		for (int j = 1; j <= 10; j++) {
			high_precision res;
			res = y * j;
			Index = j;
			if (res > flag) break;
		}
		high_precision res;
		res = y * (Index - 1);
		flag = flag - res;
		ans.c[i] = Index - 1;
	}
	
	while (ans.c.size () >= 1 && ans.c[ans.c.size () - 1] == 0) ans.c.pop_back ();
	
	return ans;
}
template <typename T>
high_precision operator / (high_precision x, T y) {
	return x / Change (y);
}
high_precision operator % (high_precision x, high_precision y) {
	high_precision res = x / y;
	return x - res * y;
}
template <typename T>
high_precision operator % (high_precision a, T y) {
	return a % Change (y);
}

3.压位

template <typename T> T Max (T x, T y) { return x > y ? x : y; }
template <typename T> T Min (T x, T y) { return x < y ? x : y; }
template <typename T> T Abs (T x) { return x > 0 ? x : -x; }
const int Mod = 10000;
struct high_precision {
	vector <int> c;
	
	high_precision () {
		c.clear ();
	}
	void colour (int len) {
		while (c.size () < len) c.push_back (0);
	}
	void operator = (const string x) {
		c.resize (x.length ());
		for (int i = 0, j = 0; i < x.length (); i += 4, j++) {
			for (int k = 0; k < 4; k++) {
				c[j] = c[j] * 10 + x[k + j];
			}
		}
	}
	void operator = (int tem) {
		vector <int> x; x.clear ();
		while (tem) {
			x.push_back (tem % Mod);
			tem /= Mod;
		}
		reverse (x.begin (), x.end ());
		c.resize (x.size ());
		for (int i = 0; i < x.size (); i++) {
			c[x.size () - i - 1] = x[i];
		}
	}
	void operator = (LL tem) {
		string x; x.clear ();
		while (tem) {
			x += tem % Mod + '0';
			tem /= Mod;
		}
		reverse (x.begin (), x.end ());
		c.resize (x.size ());
		for (int i = 0; i < x.size (); i++) {
			c[x.size () - i - 1] = x[i] - '0';
		}
	}
	void inout () {
		if (c.size () == 0)  {
			putchar ('0');
		}
		else {
			if (c[c.size () - 1] < 0) {
				putchar ('-');
				for (int i = c.size () - 1; i >= 0; i--) {
					if (i != c.size () - 1) printf ("%04d", Abs (c[i]));
					else printf ("%d", Abs (c[i]));
				}
			}
			else {
				for (int i = c.size () - 1; i >= 0; i--) {
					if (i != c.size () - 1) printf ("%04d", Abs (c[i]));
					else printf ("%d", Abs (c[i]));
				}
			}
		}
	}
};
template <typename T>
high_precision Change (T x) {
	string tem; tem.clear ();
	high_precision ans;
	while (x) {
		tem += x % Mod + '0';
		x /= Mod;
	}
	reverse (tem.begin (), tem.end ()); 
	ans = tem;
	return ans;
}
bool operator < (high_precision x, high_precision y) {
	int lenx = x.c.size (), leny = y.c.size ();
	if (x.c[lenx - 1] < 0 && y.c[leny - 1] < 0) {
		if (lenx != leny) return lenx > leny;
		else {
			for (int i = lenx - 1; i >= 0; i--) {
				if (x.c[i] != y.c[i]) {
					return x.c[i] < y.c[i];
				}
			}
			return 0;
		}
	}
	else if (x.c[lenx - 1] < 0 && y.c[leny - 1] > 0) {
		return 1;
	}
	else if (x.c[lenx - 1] > 0 && y.c[leny - 1] < 0) {
		return 0;
	}
	else {
		if (lenx != leny) return lenx < leny;
		else {
			for (int i = lenx - 1; i >= 0; i--) {
				if (x.c[i] != y.c[i]) {
					return x.c[i] < y.c[i];
				}
			}
			return 0;
		}
	}
}
bool operator > (high_precision x, high_precision y) {
	return y < x;
}
bool operator == (high_precision x, high_precision y) {
	if (x.c.size () != y.c.size ()) return 0;
	for (int i = x.c.size () - 1; i >= 0; i--) {
		if (x.c[i] != y.c[i]) return 0;
	}
	return 1;
}
bool operator >= (high_precision x, high_precision y) {
	if (x > y) return 1;
	else if (x == y) return 1;
	else return 0;
}
bool operator <= (high_precision x, high_precision y) {
	if (x < y) return 1;
	else if (x == y) return 1;
	else return 0;
}
high_precision operator * (high_precision x, high_precision y) {
//	printf ("x: "); x.inout (); printf ("\ny: "); y.inout (); printf ("\n");
	
	high_precision ans;
	ans.colour (x.c.size () + y.c.size ());
	for (int i = 0; i < x.c.size (); i++) {
		for (int j = 0; j < y.c.size (); j++) {
			ans.c[i + j] += x.c[i] * y.c[j];
			ans.c[i + j + 1] += ans.c[i + j] / Mod;
			ans.c[i + j] %= Mod;
		}
	}
	while (ans.c.size () >= 1 && ans.c[ans.c.size () - 1] == 0) ans.c.pop_back ();
//	printf ("ans: "); ans.inout (); printf ("\n");
	return ans;
}
template <typename T>
high_precision operator * (high_precision a, T y) {
	return a * Change (y);
}
high_precision operator + (high_precision x, high_precision y) {
	high_precision ans;
	int len = Max (x.c.size (), y.c.size ());
	ans.colour (len + 1);
	x.colour (len);
	y.colour(len);
	
	for (int i = 0; i < len; i++) {
		ans.c[i] += x.c[i] + y.c[i];
		ans.c[i + 1] += ans.c[i] / Mod;
		ans.c[i] %= Mod;
	}
	
	while (ans.c.size () >= 1 && ans.c[ans.c.size () - 1] == 0) ans.c.pop_back ();
	
	return ans;
}
template <typename T>
high_precision operator + (high_precision a, T y) {
	return a + Change (y);
}
high_precision operator - (high_precision x, high_precision y) {
	high_precision ans;
	
	int len = Max (x.c.size (), y.c.size ()) + 3;
	x.colour (len); y.colour (len); ans.colour (len);
	
	bool check = 0;
	if (x < y) swap (x, y), check = 1;
	
	int flag = 0;
	for (int i = 0; i < ans.c.size (); i++) {
		ans.c[i] = x.c[i] - y.c[i] + flag;
		if (ans.c[i] < 0) {
			ans.c[i] += Mod;
			flag = -1;
		}
		else {
			flag = 0;
		}
	}
	
	if (check) {
		for (int i = 0; i < ans.c.size (); i++) {
			ans.c[i] = -ans.c[i];
		}
	}
	
	while (ans.c.size () >= 1 && ans.c[ans.c.size () - 1] == 0) ans.c.pop_back ();
	
	return ans; 
}
template <typename T>
high_precision operator - (high_precision a, T y) {
	return a - Change (y);
}
high_precision operator / (high_precision x, high_precision y) {
	high_precision ans, flag;
	ans.colour (x.c.size ());
	for (int i = x.c.size () - 1; i >= 0; i--) {
		flag.c.insert (flag.c.begin (), x.c[i]);
		int Index;
		for (int j = 1; j < Mod; j++) {
			high_precision res;
			res = y * j;
			Index = j;
			if (res > flag) break;
		}
		high_precision res;
		res = y * (Index - 1);
		flag = flag - res;
		ans.c[i] = Index - 1;
	}
	
	while (ans.c.size () >= 1 && ans.c[ans.c.size () - 1] == 0) ans.c.pop_back ();
	
	return ans;
}
template <typename T>
high_precision operator / (high_precision x, T y) {
	return x / Change (y);
}
high_precision operator % (high_precision x, high_precision y) {
	high_precision res = x / y;
	return x - res * y;
}
template <typename T>
high_precision operator % (high_precision a, T y) {
	return a % Change (y);
}
IDSY QAQ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
高精度运算模板C语言
海盗船
02-26 3029
#include #include #include #include #define maxx 100 using namespace std; //高精度加法： void add(char *s1,char *s2) { int n,m,i,j,a[maxx+10]={0},b[maxx+10]={0}; int l1=strlen(s1); int l2=strlen(s2); fo
C++高精度运算模板
热门推荐
代号4101的专栏
04-06 2万+
用C++实现大数类
高精度模板总结
正在学算法的小朋友的博客
05-27 711
简要： 以下是我对高精度模板的总结，只有乘法和加法用了底层原理，底层原理是用c++来实现的，其余的采用的是stl方法，都是用Java来实现的。 高精度加法1： import java.util.*; import java.math.*; public class Main { public static void main(String[] args){ String t1; String t2; Scanner scan = new S
C++高精度模板
悲伤无声地涌出来
08-29 4655
以下转自高精度算法——百度百科 真的太强了，必须吹爆！！ #include&lt;iostream&gt; #include&lt;sstream&gt; #include&lt;algorithm&gt; #include&lt;cstring&gt; #include&lt;iomanip&gt; #include&lt;vector&gt; #include&lt;cmath&gt;
高精度模板——C++实现
xiji333的博客
10-17 1440
文章目录综述朴素想法压位模板 综述 最近闲来无事写了一个比较简单的高精度模板……想来之前没有总结过这一块的知识，就写一篇博客来简单记录一下吧。关于高精度模板的资料其实挺多的，有某个方法不是很理解的话可以再搜搜资料或者自己手动模拟一下。这个模板的效率肯定不是最好的，可能还会有隐藏的bug，仅给大家提供一种实现高精度的思路。 朴素想法 我们先从最简单的开始，如果让你实现一个正数的高精度加法，你会怎么做？大部分人的做法肯定是用数组或者链表来模拟这个过程，以数组为例，从低位到高位依次存储数字的每一位，那么加法无非就
高精度模板合集与优化（全）
qq_34771124的博客
11-21 915
高精度模板合集（无注释版） 我把所有的高精度模板总结了一下，收录在这里，希望对大家有帮助。 目录 1.高精度加法 2.高精度减法 3.高精度乘法 4.高精度除法 （1）高精度除以低精度 （2）高精度除以高精度 5.高精度算法的优化思路 一、高精度加法 #include<bits/stdc++.h> using namespace std; #define N 10000000 int t1[N], t2[N], c[N]; char a[N], b[N];// 两个加数 int main(){
【C++】高精度模板大整合！高精度模板看这篇真的就够了
Sharon_zhugecat的博客
09-30 3712
高精度整合模板！学高精度这一篇够了！高精度的四则运算与取模、高精度与低精度的四则运算、取模和开根，以及浮点高精度！
【算法模板】高精度模板（带图详解）
Z1tai的博客
11-04 1466
高精度模板（加减乘除）
高精度乘以高精度模板
骑鱼的喵喵的博客
02-24 1043
高精度乘法：高精度乘以高精度 题目描述  高精度乘法。输入两个正整数，求它们的积。 输入     两行，每行为一个高精度整数，长度不超过255。 输出     一行，相乘的结果。 做题一定要注意边界情况。 #include&lt;stdio.h&gt; #include&lt;string.h&gt; using namespace std; char str1[265]; c...
C++高精度模板（加减乘除模）
最新发布
02-04
C++竞赛高精度模板 优点：包含四则运算 抛弃传统数组，使用vector 缺点：乘法没有使用FFT算法，复杂度O(N^2) 在某些编辑器上可能无法使用资源中定义的常量，需要手动创建（CE的话可能是这个问题） 没有运算符...
高精度模板 c++实现
08-11
高精度c++模板，实测没有问题，可以放心使用，常数一般，代码可移植性和封装性较好
二次项展开（矩阵加速）
C2022lihan的博客
04-04 596
#include <cmath> #include <stack> #include <queue> #include <vector> #include <cstdio> #include <cstdlib> #include <cstring> #include <iostream> #include <algorithm> #define LL long long #define ULL uns
各种算法模板
C2022lihan的博客
07-26 374
离散化 1. #include <iostream> #include <algorithm> using namespace std; const int MAXN = 1005; int n; int rev[MAXN], a[MAXN]; int main() { cin >> n; for(int i = 1; i <= n; i++) cin >> a[i], rev[i] = a[i]; sort(rev + 1, rev + 1
情报机器人(robot) + 三分小结
C2022lihan的博客
09-21 350
题面 思路 很容易想到思路，算出每两个机器人之间的"相遇时间"(即何时记录信号)，再用最小生成树(kruskal)算出答案。 难点：如何算出每两个机器人之间的“相遇时间”？ 考场上我脑子一抽，就想枚举(略加亿点小技巧)每两个机器人之间的相对运动关系，可是打了30多种情况后就放弃了(共有64种可能，而且打的还不一定是对的)，于是打了一个暴力枚举t就跑了 (结果只有8分) ， 可是我就没有思考t和两个机器人的距离的关系。 建立一个直角坐标系，以t为x轴，以两机器人之间的距离为y轴，函数图像成一个单峰函数。 (易
矩阵的模板
C2022lihan的博客
10-07 292
矩阵 1.基本运算(+, -, *) LL MO = INF; struct Matrix { int n, m; LL map[MAXN][MAXN]; Matrix() { memset(map, 0, sizeof map); } void read() { for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) {
LCT 模板
C2022lihan的博客
03-11 256
const int MaxLct = 2 * 1e5; #define ls(p) (Tr[p].ch[0]) #define rs(p) (Tr[p].ch[1]) #define fa(p) (Tr[p].fa) #define rev(p) (Tr[p].rev) struct Node { int rev; int ch[2], fa; }; struct Link_Cut_Tree { Node Tr[MaxLct + 5]; int st[MaxLct + 5]
高精度与高精度间的模板
07-27
- *1* *2* *3* [信息学奥赛第六节 —— 高精度模板(高精度加法、减法乘法)](https://blog.csdn.net/smallrain6/article/details/124188182)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值