ACMDay13大整数加减乘除

ACM_大数运算 模板&&讲解&&各大oj题目 c语言版大数相加,大数相减,大数相乘,大数相除,大数阶乘,大数求模,大数幂,已通过各大OJ测试,有讲解有练习,有模板,有测试。。。。。 阅读详情

大整数加减乘除法还没搞定(本蒟蒻搞了一上午)233

/*
大整数加减乘除的参数均为正若需要用到负可在主函数中进行变换操作
*/


/*
大整数加减乘除的参数均为正若需要用到负可在主函数中进行变换操作
*/


#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
string s1, s2, s3;
int file = 0;
int P;
void Plus(string s4, string s5)
{
	s3.clear();
	int up = 0;
	int a, b, c;
	int i;
	for (i = 1; i <= min(s4.size(), s5.size()); i++)
	{
		a = (int)(s4[s4.size() - i] - '0');
		b = (int)(s5[s5.size() - i] - '0');
		c = a + b + up;
		up = c / 10;
		c = c % 10;
		s3.insert(s3.begin(), (char)(c + '0'));
	}
	if (up != 0)
	{
		if (s4.size() < s5.size())
			for (i; i <= s5.size(); i++)
			{
				a = (int)(s5[s5.size() - i] - '0');
				if (a + up < 10)
				{
					s5[s5.size() - i] = (char)((a + up) % 10 + '0');
					break;
				}
				s5[s5.size() - i] = (char)((a + up) % 10 + '0');
				up = (a + up) / 10;
				if (i == s5.size())
				{
					s5.insert(s5.begin(), (char)(up + '0'));
					break;
				}
			}
		else if (s4.size() > s5.size())
		{
			for (i; i <= s4.size(); i++)
			{
				a = (int)(s4[s4.size() - i] - '0');
				if (a + up < 10)
				{
					s4[s4.size() - i] = (char)((a + up) % 10 + '0');
					break;
				}
				s4[s4.size() - i] = (char)((a + up) % 10 + '0');
				up = (a + up) / 10;
				if (i == s4.size())
				{
					s4.insert(s4.begin(), (char)(up + '0'));
					break;
				}
			}
		}
		else
		{
			s4.insert(s4.begin(), (char)(up + '0'));
		}
	}
	if (s4.size() >= s5.size())
	{
		s4.erase(s4.end() - s5.size(), s4.end());
		s4 = s4 + s3;
		s3 = s4;
	}
	if (s4.size() < s5.size())
	{
		s5.erase(s5.end() - s4.size(), s5.end());
		s5 = s5 + s3;
		s3 = s5;
	}
}

void Reduce(string s4, string s5)
{
	s3.clear();
	int a, b, c;
	int down = 0;
	if (s4.size() > s5.size())
	{
		for (int i = 1; i <= s5.size(); i++)
		{
			a = (int)(s4[s4.size() - i] - '0');
			b = (int)(s5[s5.size() - i] - '0');
			if (a < b)
			{
				if ((int)(s4[s4.size() - i - 1] - '0') > 0)
				{
					s4[s4.size() - i - 1] = (char)((int)(s4[s4.size() - i - 1] - '0') - 1 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
				else
				{
					int j = s4.size() - i - 2;
					for (j; j >= 0; j--)
					{
						if ((int)(s4[j] - '0') > 0)
						{
							s4[j] = (char)((int)(s4[j] - '0') - 1 + '0');
							break;
						}
					}
					for (j = j + 1; j <= s4.size() - i - 1; j++)
						s4[j] = char(9 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			else
			{
				c = a - b;
				s3.insert(s3.begin(), (char)(c + '0'));
			}
		}
		s4.erase(s4.end() - s5.size(), s4.end());
		s4 = s4 + s3;
		s3 = s4;
		string s6;
		for (int i = 0; i < s3.size(); i++)
			s6 = s6 + '0';
		if (s3.size() > 1 && s3 != s6)
		{
			int m;
			for (m = 0; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 0)
				s3.erase(s3.begin() + 1, s3.begin() + m);
		}
		else if (s3[0] == '0')
			s3 = "0";
	}
	else if (s4.size() < s5.size())
	{
		for (int i = 1; i <= s4.size(); i++)
		{
			a = (int)(s5[s5.size() - i] - '0');
			b = (int)(s4[s4.size() - i] - '0');
			if (a < b)
			{
				if ((int)(s5[s5.size() - i - 1] - '0') > 0)
				{
					s5[s5.size() - i - 1] = (char)((int)(s5[s5.size() - i - 1] - '0') - 1 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
				else
				{
					int j = s5.size() - i - 2;
					for (j; j >= 0; j--)
					{
						if ((int)(s5[j] - '0') > 0)
						{
							s5[j] = (char)((int)(s5[j] - '0') - 1 + '0');
							break;
						}
					}
					for (j = j + 1; j <= s5.size() - i - 1; j++)
						s5[j] = char(9 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			else
			{
				c = a - b;
				s3.insert(s3.begin(), (char)(c + '0'));
			}
		}

		s5.erase(s5.end() - s4.size(), s5.end());
		s5 = s5 + s3;
		s3 = s5;
		s3.insert(s3.begin(), '-');
		string s6;
		for (int i = 0; i < s3.size() - 1; i++)
			s6 = s6 + '0';
		s6.insert(s6.begin(), '-');
		if (s3.size() > 2 && s3 != s6)
		{
			int m;
			for (m = 1; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 1)
				s3.erase(s3.begin() + 1, s3.begin() + m);
		}
		else if (s3[1] == '0')
			s3 = "0";
	}
	else if (s4.size() == s5.size())
	{
		if (s4 > s5)
		{
			for (int i = 1; i <= s5.size(); i++)
			{
				a = (int)(s4[s4.size() - i] - '0');
				b = (int)(s5[s5.size() - i] - '0');
				if (a < b)
				{
					if ((int)(s4[s4.size() - i - 1] - '0') > 0)
					{
						s4[s4.size() - i - 1] = (char)((int)(s4[s4.size() - i - 1] - '0') - 1 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
					else
					{
						int j = s4.size() - i - 2;
						for (j; j >= 0; j--)
						{
							if ((int)(s4[j] - '0') > 0)
							{
								s4[j] = (char)((int)(s4[j] - '0') - 1 + '0');
								break;
							}
						}
						for (j = j + 1; j <= s4.size() - i - 1; j++)
							s4[j] = char(9 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
				}
				else
				{
					c = a - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			string s6;
			for (int i = 0; i < s3.size(); i++)
				s6 = s6 + '0';
			if (s3.size() > 1 && s3 != s6)
			{
				int m;
				for (m = 0; m < s3.size(); m++)
				{
					if (s3[m] != '0')
						break;
				}
				if (m > 0)
					s3.erase(s3.begin() + 1, s3.begin() + m);
			}
			else if (s3[0] == '0')
				s3 = "0";
		}
		if (s4 < s5)
		{
			for (int i = 1; i <= s4.size(); i++)
			{
				a = (int)(s5[s5.size() - i] - '0');
				b = (int)(s4[s4.size() - i] - '0');
				if (a < b)
				{
					if ((int)(s5[s5.size() - i - 1] - '0') > 0)
					{
						s5[s5.size() - i - 1] = (char)((int)(s5[s5.size() - i - 1] - '0') - 1 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
					else
					{
						int j = s5.size() - i - 2;
						for (j; j >= 0; j--)
						{
							if ((int)(s5[j] - '0') > 0)
							{
								s5[j] = (char)((int)(s5[j] - '0') - 1 + '0');
								break;
							}
						}
						for (j = j + 1; j <= s5.size() - i - 1; j++)
							s5[j] = char(9 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
				}
				else
				{
					c = a - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			s3.insert(s3.begin(), '-');
			string s6;
			for (int i = 0; i < s3.size() - 1; i++)
				s6 = s6 + '0';
			s6.insert(s6.begin(), '-');
			if (s3.size() > 2 && s3 != s6)
			{
				int m;
				for (m = 1; m < s3.size(); m++)
				{
					if (s3[m] != '0')
						break;
				}
				if (m > 1)
					s3.erase(s3.begin() + 1, s3.begin() + m);
			}
			else if (s3[1] == '0')
				s3 = "0";
		}
		else
			s3 = "0";
	}
}

void Multiplication(string s4, string s5)
{
	if (s4[0] == '-')
	{
		s1.erase(s1.begin(), s1.begin() + 1);
		file++;
	}
	if (s5[0] == '-')
	{
		s2.erase(s2.begin(), s2.begin() + 1);
		file++;
	}
	s3.clear();
	int a, b, c, d;
	int up = 0;
	s3 = "0";
	if (s4[0] == '0' || s5[0] == '0')
		return;
	string s6;
	if (s4.size() >= s5.size())
	{
		for (int i = 1; i <= s5.size(); i++)
		{
			a = (int)(s5[s5.size() - i] - '0');
			for (int j = 1; j <= s4.size(); j++)
			{
				b = (int)(s4[s4.size() - j] - '0');
				c = a * b + up;
				s6.insert(s6.begin(), (char)(c % 10 + '0'));
				up = c / 10;
			}
			if (up != 0) {
				s6.insert(s6.begin(), (char)(up + '0'));
				up = 0;
			}
			for (int j = i - 1; j > 0; j--)
			{
				s6 = s6 + '0';
			}
			Plus(s3, s6);
			s6.clear();
		}
	}
	if (s4.size() < s5.size())
	{
		for (int i = 1; i <= s4.size(); i++)
		{
			a = (int)(s4[s4.size() - i] - '0');
			for (int j = 1; j <= s5.size(); j++)
			{
				b = (int)(s5[s5.size() - j] - '0');
				c = a * b + up;
				s6.insert(s6.begin(), (char)(c % 10 + '0'));
				up = c / 10;
			}
			if (up != 0) {
				s6.insert(s6.begin(), (char)(up + '0'));
				up = 0;
			}
			for (int j = i - 1; j > 0; j--)
			{
				s6 = s6 + '0';
			}
			Plus(s3, s6);
			s6.clear();
		}
	}
	if (file == 1)
		s3.insert(s3.begin(), '-');
}

next_permutation()就是一个求一个排序的下一个排列的函数,可以遍历全排列

与之完全相反的函数还有prev_permutation(就是一个求一个排序的上一个排列的函数)
(本蒟蒻今天写火星人这道题一直以为是进制后来看到这个之后才发现是全排列)

ios::sync_with_stdio(false);关闭缓冲流能大大节省时间

改进版减法:

void Now_Reduce(string s4, string s5)
{
	s3.clear();
	int a, b, c;
	int down = 0;
	if (s4.size() > s5.size())//大于零的情况
	{
		for (int i = 1; i <= s5.size(); i++)
		{
			a = (int)(s4[s4.size() - i] - '0');
			b = (int)(s5[s5.size() - i] - '0');
			if (a > b)
			{
				c = a - b+down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = 0;
			}
			else if (a == b)
			{
				if (down < 0)
				{
					c = 9;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
				else
				{
					s3.insert(s3.begin(), '0');
				}
			}
			else if (a < b)
			{
				c = a - b + 10 + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = -1;
			}
		}
		if (down != 0)
		{
			for (int i = s4.size() - s5.size()-1; i >= 0; i--)
			{
				if (s4[i] > '0')
				{
					s4[i] = (char)(s4[i] - 1);
					down = 0;
					break;
				}
				else
				{
					s4[i] = '9';
				}
			}
		}
		s4.erase(s4.end() - s5.size(), s4.end());
		s4 = s4 + s3;
		s3 = s4;
		int m;
		for (m = 0; m < s3.size(); m++)
		{
			if (s3[m] != '0')
				break;
		}
		if (m > 0)
			s3.erase(s3.begin(), s3.begin() + m);
	}
	if (s4.size() < s5.size())
	{
		for (int i = 1; i <= s4.size(); i++)
		{
			a = (int)(s5[s5.size() - i] - '0');
			b = (int)(s4[s4.size() - i] - '0');
			if (a > b)
			{
				c = a - b + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = 0;
			}
			else if (a == b)
			{
				if (down < 0)
				{
					c = 9;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
				else
				{
					s3.insert(s3.begin(), '0');
				}
			}
			else if (a < b)
			{
				c = a - b + 10 + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = -1;
			}
		}
		if (down != 0)
		{
			for (int i = s5.size() - s4.size() - 1; i >= 0; i--)
			{
				if (s5[i] > '0')
				{
					s5[i] = (char)(s5[i] - 1);
					down = 0;
					break;
				}
				else
				{
					s5[i] = '9';
				}
			}
		}
		s5.erase(s5.end() - s4.size(), s5.end());
		s5 = s5 + s3;
		s3 = s5;
		int m;
		for (m = 0; m < s3.size(); m++)
		{
			if (s3[m] != '0')
				break;
		}
		if (m > 0)
			s3.erase(s3.begin(), s3.begin() + m);
		s3.insert(s3.begin(), '-');
	}
	if (s4.size() == s5.size())
	{
		if (s4 > s5)
		{
			for (int i = 1; i <= s5.size(); i++)
			{
				a = (int)(s4[s4.size() - i] - '0');
				b = (int)(s5[s5.size() - i] - '0');
				if (a > b)
				{
					c = a - b + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = 0;
				}
				else if (a == b)
				{
					if (down < 0)
					{
						c = 9;
						s3.insert(s3.begin(), (char)(c + '0'));
						down = -1;
					}
					else
					{
						s3.insert(s3.begin(), '0');
					}
				}
				else if (a < b)
				{
					c = a - b + 10 + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
			}
			int m;
			for (m = 0; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 0)
				s3.erase(s3.begin(), s3.begin() + m);
		}
		if (s4 == s5)
			s3 = "0";
		if (s4 < s5)
		{
			for (int i = 1; i <= s4.size(); i++)
			{
				a = (int)(s5[s5.size() - i] - '0');
				b = (int)(s4[s4.size() - i] - '0');
				if (a > b)
				{
					c = a - b + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = 0;
				}
				else if (a == b)
				{
					if (down < 0)
					{
						c = 9;
						s3.insert(s3.begin(), (char)(c + '0'));
						down = -1;
					}
					else
					{
						s3.insert(s3.begin(), '0');
					}
				}
				else if (a < b)
				{
					c = a - b + 10 + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
			}
			int m;
			for (m = 0; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 0)
				s3.erase(s3.begin(), s3.begin() + m);
			s3.insert(s3.begin(), '-');
		}
	}
}

完整的大整数加减乘除:

/*
大整数加减乘除的参数均为正若需要用到负可在主函数中进行变换操作
*/


#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
string s1, s2, s3;
int file = 0;

void Plus(string s4, string s5)
{
	s3.clear();
	int up = 0;
	int a, b, c;
	int i;
	for (i = 1; i <= min(s4.size(), s5.size()); i++)
	{
		a = (int)(s4[s4.size() - i] - '0');
		b = (int)(s5[s5.size() - i] - '0');
		c = a + b + up;
		up = c / 10;
		c = c % 10;
		s3.insert(s3.begin(), (char)(c + '0'));
	}
	if (up != 0)
	{
		if (s4.size() < s5.size())
			for (i; i <= s5.size(); i++)
			{
				a = (int)(s5[s5.size() - i] - '0');
				if (a + up < 10)
				{
					s5[s5.size() - i] = (char)((a + up) % 10 + '0');
					break;
				}
				s5[s5.size() - i] = (char)((a + up) % 10 + '0');
				up = (a + up) / 10;
				if (i == s5.size())
				{
					s5.insert(s5.begin(), (char)(up + '0'));
					break;
				}
			}
		else if (s4.size() > s5.size())
		{
			for (i; i <= s4.size(); i++)
			{
				a = (int)(s4[s4.size() - i] - '0');
				if (a + up < 10)
				{
					s4[s4.size() - i] = (char)((a + up) % 10 + '0');
					break;
				}
				s4[s4.size() - i] = (char)((a + up) % 10 + '0');
				up = (a + up) / 10;
				if (i == s4.size())
				{
					s4.insert(s4.begin(), (char)(up + '0'));
					break;
				}
			}
		}
		else
		{
			s4.insert(s4.begin(), (char)(up + '0'));
		}
	}
	if (s4.size() >= s5.size())
	{
		s4.erase(s4.end() - s5.size(), s4.end());
		s4 = s4 + s3;
		s3 = s4;
	}
	if (s4.size() < s5.size())
	{
		s5.erase(s5.end() - s4.size(), s5.end());
		s5 = s5 + s3;
		s3 = s5;
	}
}

void Reduce(string s4, string s5)
{
	s3.clear();
	int a, b, c;
	int down = 0;
	if (s4.size() > s5.size())
	{
		for (int i = 1; i <= s5.size(); i++)
		{
			a = (int)(s4[s4.size() - i] - '0');
			b = (int)(s5[s5.size() - i] - '0');
			if (a < b)
			{
				if ((int)(s4[s4.size() - i - 1] - '0') > 0)
				{
					s4[s4.size() - i - 1] = (char)((int)(s4[s4.size() - i - 1] - '0') - 1 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
				else
				{
					int j = s4.size() - i - 2;
					for (j; j >= 0; j--)
					{
						if ((int)(s4[j] - '0') > 0)
						{
							s4[j] = (char)((int)(s4[j] - '0') - 1 + '0');
							break;
						}
					}
					for (j = j + 1; j <= s4.size() - i - 1; j++)
						s4[j] = char(9 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			else
			{
				c = a - b;
				s3.insert(s3.begin(), (char)(c + '0'));
			}
		}
		s4.erase(s4.end() - s5.size(), s4.end());
		s4 = s4 + s3;
		s3 = s4;
		string s6;
		for (int i = 0; i < s3.size(); i++)
			s6 = s6 + '0';
		if (s3.size() > 1 && s3 != s6)
		{
			int m;
			for (m = 1; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 1)
				s3.erase(s3.begin() + 1, s3.begin() + m);
		}
		else if (s3[0] == '0')
			s3 = "0";
	}
	else if (s4.size() < s5.size())
	{
		for (int i = 1; i <= s4.size(); i++)
		{
			a = (int)(s5[s5.size() - i] - '0');
			b = (int)(s4[s4.size() - i] - '0');
			if (a < b)
			{
				if ((int)(s5[s5.size() - i - 1] - '0') > 0)
				{
					s5[s5.size() - i - 1] = (char)((int)(s5[s5.size() - i - 1] - '0') - 1 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
				else
				{
					int j = s5.size() - i - 2;
					for (j; j >= 0; j--)
					{
						if ((int)(s5[j] - '0') > 0)
						{
							s5[j] = (char)((int)(s5[j] - '0') - 1 + '0');
							break;
						}
					}
					for (j = j + 1; j <= s5.size() - i - 1; j++)
						s5[j] = char(9 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			else
			{
				c = a - b;
				s3.insert(s3.begin(), (char)(c + '0'));
			}
		}

		s5.erase(s5.end() - s4.size(), s5.end());
		s5 = s5 + s3;
		s3 = s5;
		s3.insert(s3.begin(), '-');
		string s6;
		for (int i = 0; i < s3.size() - 1; i++)
			s6 = s6 + '0';
		s6.insert(s6.begin(), '-');
		if (s3.size() > 2 && s3 != s6)
		{
			int m;
			for (m = 1; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 1)
				s3.erase(s3.begin() + 1, s3.begin() + m);
		}
		else if (s3[1] == '0')
			s3 = "0";
	}
	else if (s4.size() == s5.size())
	{
		if (s4 > s5)
		{
			for (int i = 1; i <= s5.size(); i++)
			{
				a = (int)(s4[s4.size() - i] - '0');
				b = (int)(s5[s5.size() - i] - '0');
				if (a < b)
				{
					if ((int)(s4[s4.size() - i - 1] - '0') > 0)
					{
						s4[s4.size() - i - 1] = (char)((int)(s4[s4.size() - i - 1] - '0') - 1 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
					else
					{
						int j = s4.size() - i - 2;
						for (j; j >= 0; j--)
						{
							if ((int)(s4[j] - '0') > 0)
							{
								s4[j] = (char)((int)(s4[j] - '0') - 1 + '0');
								break;
							}
						}
						for (j = j + 1; j <= s4.size() - i - 1; j++)
							s4[j] = char(9 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
				}
				else
				{
					c = a - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			string s6;
			for (int i = 0; i < s3.size(); i++)
				s6 = s6 + '0';
			if (s3.size() > 1 && s3 != s6)
			{
				int m;
				for (m = 1; m < s3.size(); m++)
				{
					if (s3[m] != '0')
						break;
				}
				if (m > 1)
					s3.erase(s3.begin() + 1, s3.begin() + m);
			}
			else if (s3[0] == '0')
				s3 = "0";
		}
		if (s4 < s5)
		{
			for (int i = 1; i <= s4.size(); i++)
			{
				a = (int)(s5[s5.size() - i] - '0');
				b = (int)(s4[s4.size() - i] - '0');
				if (a < b)
				{
					if ((int)(s5[s5.size() - i - 1] - '0') > 0)
					{
						s5[s5.size() - i - 1] = (char)((int)(s5[s5.size() - i - 1] - '0') - 1 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
					else
					{
						int j = s5.size() - i - 2;
						for (j; j >= 0; j--)
						{
							if ((int)(s5[j] - '0') > 0)
							{
								s5[j] = (char)((int)(s5[j] - '0') - 1 + '0');
								break;
							}
						}
						for (j = j + 1; j <= s5.size() - i - 1; j++)
							s5[j] = char(9 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
				}
				else
				{
					c = a - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			s3.insert(s3.begin(), '-');
			string s6;
			for (int i = 0; i < s3.size() - 1; i++)
				s6 = s6 + '0';
			s6.insert(s6.begin(), '-');
			if (s3.size() > 2 && s3 != s6)
			{
				int m;
				for (m = 1; m < s3.size(); m++)
				{
					if (s3[m] != '0')
						break;
				}
				if (m > 1)
					s3.erase(s3.begin() + 1, s3.begin() + m);
			}
			else if (s3[1] == '0')
				s3 = "0";
		}
		else
			s3 = "0";
	}
}

void Now_Reduce(string s4, string s5)
{
	s3.clear();
	int a, b, c;
	int down = 0;
	if (s4.size() > s5.size())//大于零的情况
	{
		for (int i = 1; i <= s5.size(); i++)
		{
			a = (int)(s4[s4.size() - i] - '0');
			b = (int)(s5[s5.size() - i] - '0');
			if (a > b)
			{
				c = a - b + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = 0;
			}
			else if (a == b)
			{
				if (down < 0)
				{
					c = 9;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
				else
				{
					s3.insert(s3.begin(), '0');
				}
			}
			else if (a < b)
			{
				c = a - b + 10 + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = -1;
			}
		}
		if (down != 0)
		{
			for (int i = s4.size() - s5.size() - 1; i >= 0; i--)
			{
				if (s4[i] > '0')
				{
					s4[i] = (char)(s4[i] - 1);
					down = 0;
					break;
				}
				else
				{
					s4[i] = '9';
				}
			}
		}
		s4.erase(s4.end() - s5.size(), s4.end());
		s4 = s4 + s3;
		s3 = s4;
		int m;
		for (m = 0; m < s3.size(); m++)
		{
			if (s3[m] != '0')
				break;
		}
		if (m > 0)
			s3.erase(s3.begin(), s3.begin() + m);
	}
	if (s4.size() < s5.size())
	{
		for (int i = 1; i <= s4.size(); i++)
		{
			a = (int)(s5[s5.size() - i] - '0');
			b = (int)(s4[s4.size() - i] - '0');
			if (a > b)
			{
				c = a - b + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = 0;
			}
			else if (a == b)
			{
				if (down < 0)
				{
					c = 9;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
				else
				{
					s3.insert(s3.begin(), '0');
				}
			}
			else if (a < b)
			{
				c = a - b + 10 + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = -1;
			}
		}
		if (down != 0)
		{
			for (int i = s5.size() - s4.size() - 1; i >= 0; i--)
			{
				if (s5[i] > '0')
				{
					s5[i] = (char)(s5[i] - 1);
					down = 0;
					break;
				}
				else
				{
					s5[i] = '9';
				}
			}
		}
		s5.erase(s5.end() - s4.size(), s5.end());
		s5 = s5 + s3;
		s3 = s5;
		int m;
		for (m = 0; m < s3.size(); m++)
		{
			if (s3[m] != '0')
				break;
		}
		if (m > 0)
			s3.erase(s3.begin(), s3.begin() + m);
		s3.insert(s3.begin(), '-');
	}
	if (s4.size() == s5.size())
	{
		if (s4 > s5)
		{
			for (int i = 1; i <= s5.size(); i++)
			{
				a = (int)(s4[s4.size() - i] - '0');
				b = (int)(s5[s5.size() - i] - '0');
				if (a > b)
				{
					c = a - b + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = 0;
				}
				else if (a == b)
				{
					if (down < 0)
					{
						c = 9;
						s3.insert(s3.begin(), (char)(c + '0'));
						down = -1;
					}
					else
					{
						s3.insert(s3.begin(), '0');
					}
				}
				else if (a < b)
				{
					c = a - b + 10 + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
			}
			int m;
			for (m = 0; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 0)
				s3.erase(s3.begin(), s3.begin() + m);
		}
		if (s4 == s5)
			s3 = "0";
		if (s4 < s5)
		{
			for (int i = 1; i <= s4.size(); i++)
			{
				a = (int)(s5[s5.size() - i] - '0');
				b = (int)(s4[s4.size() - i] - '0');
				if (a > b)
				{
					c = a - b + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = 0;
				}
				else if (a == b)
				{
					if (down < 0)
					{
						c = 9;
						s3.insert(s3.begin(), (char)(c + '0'));
						down = -1;
					}
					else
					{
						s3.insert(s3.begin(), '0');
					}
				}
				else if (a < b)
				{
					c = a - b + 10 + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
			}
			int m;
			for (m = 0; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 0)
				s3.erase(s3.begin(), s3.begin() + m);
			s3.insert(s3.begin(), '-');
		}
	}
}
void Multiplication(string s4, string s5)
{
	if (s4[0] == '-')
	{
		s1.erase(s1.begin(), s1.begin() + 1);
		file++;
	}
	if (s5[0] == '-')
	{
		s2.erase(s2.begin(), s2.begin() + 1);
		file++;
	}
	s3.clear();
	int a, b, c, d;
	int up = 0;
	s3 = "0";
	if (s4[0] == '0' || s5[0] == '0')
		return;
	string s6;
	if (s4.size() >= s5.size())
	{
		for (int i = 1; i <= s5.size(); i++)
		{
			a = (int)(s5[s5.size() - i] - '0');
			for (int j = 1; j <= s4.size(); j++)
			{
				b = (int)(s4[s4.size() - j] - '0');
				c = a * b + up;
				s6.insert(s6.begin(), (char)(c % 10 + '0'));
				up = c / 10;
			}
			if (up != 0) {
				s6.insert(s6.begin(), (char)(up + '0'));
				up = 0;
			}
			for (int j = i - 1; j > 0; j--)
			{
				s6 = s6 + '0';
			}
			Plus(s3, s6);
			s6.clear();
		}
	}
	if (s4.size() < s5.size())
	{
		for (int i = 1; i <= s4.size(); i++)
		{
			a = (int)(s4[s4.size() - i] - '0');
			for (int j = 1; j <= s5.size(); j++)
			{
				b = (int)(s5[s5.size() - j] - '0');
				c = a * b + up;
				s6.insert(s6.begin(), (char)(c % 10 + '0'));
				up = c / 10;
			}
			if (up != 0) {
				s6.insert(s6.begin(), (char)(up + '0'));
				up = 0;
			}
			for (int j = i - 1; j > 0; j--)
			{
				s6 = s6 + '0';
			}
			Plus(s3, s6);
			s6.clear();
		}
	}
	if (file == 1)
		s3.insert(s3.begin(), '-');
}
void Division(string s4, string s5)
{
	int lg;
	s3.clear();
	if (s4.size() < s5.size())
	{
		s3 = "0";
		return;
	}
	if (s4.size() == s5.size())
	{
		string q;
		int i;
		for (i = 1;; i++)
		{
			q = i + '0';
			Multiplication(s5, q);
			if (s3.size() > s4.size())
				break;
			else if (s3 > s4&&s3.size() == s4.size())
				break;
		}
		s3.clear();
		s3 = i - 1 + '0';
		return;
	}
	if (s4.size() > s5.size())
	{
		long long r = s4.size();
		string w;
		while (s4.size() >= s5.size())
		{
			string s7;
			for (int i = 0; i < s4.size(); i++)
				s7 = s7 + '0';
			if (s7 == s4)
				break;
			if (s4[0] == '0')
			{
				w = w + '0';
				s4.erase(s4.begin(), s4.begin() + 1);
				continue;
			}
			string s6(s4, 0, s5.size());
			if (s6 >= s5)
			{
				if (w.size() > 0)
				{
					for (int j = 0; j < lg-2; j++)
						w = w + '0';
				}
				int i = 0;
				string q;
				for (i = 1;; i++)
				{
					q = i + '0';
					Multiplication(s5, q);
					if (s3.size() > s6.size())
						break;
					else if (s3 > s6&&s3.size() == s6.size())
						break;
				}
				w = w + (char)(i - 1 + '0');
				Now_Reduce(s3, s5);
				Now_Reduce(s6, s3);
				if (s3 != "0")
					s4.replace(s4.begin(), s4.begin() + s5.size(), s3);
				else
					s4.erase(s4.begin(), s4.begin() + s5.size());
				lg = s5.size() - s3.size();
			}
			else if (s4.size() >= s5.size() + 1)
			{
				if (w.size() > 0)
				{
					for (int j = 0; j < lg-1; j++)
						w = w + '0';
				}
				string s6(s4, 0, s5.size() + 1);
				int i = 0;
				string q;
				for (i = 1;; i++)
				{
					q = i + '0';
					Multiplication(s5, q);
					if (s3.size() > s6.size())
						break;
					else if (s3 > s6&&s3.size() == s6.size())
						break;
				}
				w = w + (char)(i - 1 + '0');
				Now_Reduce(s3, s5);
				Now_Reduce(s6, s3);
				if (s3 != "0")
					s4.replace(s4.begin(), s4.begin() + s5.size(), s3);
				else
					s4.erase(s4.begin(), s4.begin() + s5.size() + 1);
				lg = s5.size() - s3.size();
			}
			else
				break;
		}
		if (s4.size() > 0)
		{
			for (int j = 0; j < s4.size(); j++)
				w = w + '0';
			s3 = w;
			return;
		}
		else
		{
			s3 = w;
			return;
		}
	}
}

大整数运算之 大整数加法、减法、乘法 其实大整数的问题都是在像我们打草稿的时候列竖式一样的,不要告诉我你不知道什么叫竖式~!其实我开始也不知道它叫这个名字; 所谓竖式,就是你打草稿算算术的方法,小学知识;比如你写 11+9: 11 +   9 ---------- 20 数A,B,求和,求差;数的长度不超过1000; 贴个代码,先输入一个数,代表数据的组数n,然后输入n组A B #inc 阅读详情

相关推荐

电影票购票小程序搭建(源码部署)

答:为用户提供便捷的购票方式,包括授权登录、个性化推荐、在线选座、订单管理等功能,同时在界面设计上注重用户友好性,简化用户的购票流程。答:通过展示电影院的优惠活动和票价信息,同时提供电影推荐功能,根据用户的历史购票记录和电影评分推荐个性化的电影列表,吸引用户购票。编写页面逻辑代码:使用JavaScript编写小程序页面的逻辑代码,实现电影列表的获取、电影详情的展示、座位选择的逻辑等。设计小程序界面:使用WXML和WXSS编写小程序的界面代码,实现电影列表的展示、电影详情的样式、座位选择页面的布局等。

2301_79072569的博客 2068

ACM内部函数--数学问题--大数相减

在这里我们为了方便起见,所以只设置成了大数减小数,在调用此方法之前需要进行判断,如果是小数减大数,只需要在前面加一个负号就行了 #include #include #include #include using namespace std; const int N=1005; /** 大数相减 str1:减数数组 str2:被减数数组 result:结果数组 */ v

戎码人生 691

别再手动配IP了!保姆级教程:用Cisco Packet Tracer搞定DHCP服务器配置(附实验抓包分析)

本文提供了一份详细的Cisco Packet Tracer DHCP服务器配置教程,帮助用户告别手动分配IP的繁琐过程。通过构建多子网实验环境,逐步指导DHCP地址池设置、客户端测试及协议分析,并分享常见问题排查技巧,让网络配置更高效、更智能。

weixin_42535461的博客 339

acm作业重点分析2——大整数运算

1.BUCTOJ 2169 大整数加法 题目描述:计算两个大整数的和。大整数是指超过了c,c++表示范围的整数。 输入格式:输入包括两个大整数,每个大整数不超过100位,用空格或者换行隔开 输出格式:输出两个大整数的和 自己构造测试数据: 简单:1 1 有进位的情况:9 1 复杂:888 999 边界情况:一百个9 一百个1 重点分析:(大整数加法由于位数太多超出long和int范围所以只能用字符串来计算) 首先为了好计算个位数需对应下标0(就是最初的那两重循环) 然后将两者加和结果

FightingTsinghua的博客 661

MAIXCAM无线连接实战:5分钟搞定远程调试与代码烧录(避坑版)

本文提供了一份详细的MAIXCAM无线连接实战指南,帮助嵌入式视觉开发者快速配置远程调试与代码烧录。文章重点介绍了通过MaixHub IDE进行Wi-Fi配置、建立远程终端连接、使用SFTP进行文件传输以及管理自启动应用程序的完整流程,并针对IP地址变动、信号中断等常见问题提供了实用的避坑解决方案,旨在提升开发效率与灵活性。

weixin_29188043的博客 298

SolidWorks有限元分析流程

对于很多专业,在进行设计完成后,为了缩短开发周期,往往需要配合仿真结果进行,机械行业更是如此。平时大家多采用专业有限元仿真软件进行仿真分析,如ANSYS;不过SolidWorks软件因为制图简单,同时存在专用的有限元仿真模块Simulation,对于初学者往往更加适用,下面简单介绍下SolidWorks Simulation仿真流程。 1. 分析流程 关键步骤如下: **(1)创建算例;**对模型的每次分析都是一个算例,一个模型可以包含多个算例。 **(2)应用材料;**指定模型的材料属性,如铝合金、钢材等

DYH_BK的博客 3万+

大数运算模板

#include <iostream> #include <algorithm> #include <stdio.h> #include <string.h> using namespace std; #define MAX_DIGIT 500//大数运算:加法 int Add(int *a,int *b,int *&result) { if(a==NULL || b==NULL || re

蓦然回首 452

11、RK3566/3568 Android11切割屏幕 长条屏 显示

在使用 RK3566 平台进行 Android 11 开发时,遇到切割屏(长条屏)显示画面不全。本文将详细介绍如何配置,以及如何修改 HWComposer 来调整显示区域,解决图像缩放问题。我这边屏幕是lvds接口的,分辨率1920 1080实际的屏物理尺寸是1920x463。

qq_39451352的博客 252

ACM大数相减

#include #include using namespace std; //定义MAX_SIZE #define MAX_SIZE 200 //定义两个char[]来存放输入的string类型 char charArrOne[MAX_SIZE+10]; char charArrTwo[MAX_SIZE+10]; int intArrOne[MAX_SIZE+10]; int intArrTw

qq_22125259的博客 645

【银河麒麟桌面系统】安装英伟达(NVIDIA)显卡驱动

本文详细介绍了在麒麟桌面操作系统V10 SP1(版本号2503)上安装NVIDIA RTX 5060显卡驱动的完整流程。主要内容包括:查看系统版本信息,从NVIDIA官网下载Linux 64位驱动,授予执行权限后运行安装程序,处理安装过程中的X server警告、32位库安装、DKMS模块选择等问题,以及安装完成后如何验证驱动状态。同时提供了卸载驱动的步骤和常见问题解决方案,如处理X server警告、libglvnd EGL依赖问题等。该指南适用于需要在国产麒麟系统上安装NVIDIA显卡驱动的用户,包含完

信创运维工程师 · 银河麒麟 & 容器实战 | 金融生产环境迁移·等保加固 | 142篇原创·17万+阅读 6312

城市仿真软件:AnyLogic_(8).行人与人群动态仿真

定义行人个体的行为和属性,如行走速度、目标位置等。// 创建一个行人// 设置行走速度为1.5 m/s// 设置目标位置为入口// 创建另一个行人// 设置行走速度为1.2 m/s// 设置目标位置为出口// 创建行人// 创建乘客行人与人群动态仿真在城市规划、交通管理和紧急疏散等领域具有广泛的应用。通过AnyLogic提供的行人模型模块,可以有效地模拟行人的个体行为、群体动态和与环境的交互。

kkchenjj的博客 1250

大数四则运算

#include&lt;iostream&gt; #include&lt;cstdlib&gt; #include&lt;cstring&gt; using namespace std; #define M 1000000000000000 //大数加法 //将数字以字符串的形式传入add加法函数,在函数内部完成字符串-&gt;数组的转换, //然后在数组中逐位进行相加,再判断该位相加后是否需要...

ACM_Colas_125的博客 437

手眼标定----眼在手上(eye-in-hand)

@TOC 标定之前你可以先拿个怡宝盖子进行测试。 第一步:打开halcon,采集,然后生成代码,显示十字架 第二步:把怡宝盖子放在十字架中心位置,在图像处理,找到怡宝盖子 第三步:找到怡宝盖子然后进行九点标定(眼在外帖子有讲),移动机器手然后分别拍9次照片,记录怡宝盖子坐标和当前机器坐标。这里移动到中心位置的时候记录一下单独记录一下坐标,等下要用。 顺序 第四步:拍完后利用vector_to_hom_mat2d算子求出矩阵,然后在利用write_tuple (HomMat2D, ‘路径’)进行保存。这里

苏州程序大白的博客 4280

大数相减的算法

#include #include #include using namespace std; string sub(string s,string str) { int temp; reverse(s.begin(),s.end()); reverse(str.begin(),str.end()); for (int i = 0; i < s.length(); i++) { te

summerFanL的博客 873

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

大数(加、减、乘、除、低精度*大数)模板详解(C++)

一、大数四个基本操作 首先,我们来了解什么是大数,大数就是指用我们平常常见的高级语言(如:c 、c++)的基本数据类型的最大长度都装不下的数据,例如(1234567899876543211234567896542132165465),这些只能用字符数组(char[])或者字符串(string)来处理,大数操作最基础的四个操作就是:大数加法、大数减法、大数乘法、大数除法。下面我来详细介绍下四个基

氵青-风的博客 5461

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

大数运算(3)——大数减法

大数的减法与大数加法的方法有相似之处的,都是模拟人工运算的,从最低位开始运算,一直到最高位。 其方法是: 首先,要判断减数和被减数哪一个位数长,减数位数长是正常减;被减数位数长,则被减数减减数,最后还要加上负号;两数位数长度相等时,最好比较一下哪一个数字大,否则负号处理会很繁琐,用大的减去小的,最后加上负号; 其次,处理每一项时要,如果前一位相减有借位,就先减去上一位的借位,无则不减;再去判

静之吾心的博客 4096

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

Ac日记——大整数减法 openjudge 1.6 11

11:大整数减法 总时间限制:1000ms内存限制:65536kB描述 求两个大的正整数相减的差。 输入共2行,第1行是被减数a,第2行是减数b(a > b)。每个大整数不超过200位,不会有多余的前导零。输出一行,即所求的差。样例输入 9999999999999999999999999999999999999 9999999999999 样例输出 9999999...

weixin_34290096的博客 731

ACM简单处理大数加法方法

在ACM刷题中,处理大数问题,如大数加法,减法,乘法,

LHS的专栏 3122

大数运算的算法

在数学运算的过程中 ,经常碰到这样的问题:参与运算的 数字很大或者对运算结果的精度要求很高。无论何种计算机 语言 ,在描述数据类型时都有一定的精度和位数要求 ,比如说 16 位整型数 (int) 所能表示的范围为 - 32768~32767 ,实数 (float)所能表示的精度为小数点后 8 位等 ,每种类型的数据都 有其精度和位数限制。超过 20 位有效数字的数值一般就无 法表示了。所以 ,在上

我的ACM 1万+

大数减法模板

#include<bits/stdc++.h> typedef long long ll; using namespace std; ll a[100000],b[100000]; ll z[200000],l; void sub() { for(int i = 0; i < l; i ++) { z[i] = a[i] - b[i]; ...

WINDZLY的博客 696

oj之大数相减

题目:两个大于32位的正整数str,str1相减,求str-str1。 这个题目首先把str,str1以字符串的形式输入,反排序之后,比较str,str1的大小,首先长度长的数字一定大于长度短的,如果str的度 得str为大数,str1为小数,输出‘-’,然后用resize函数补‘0‘使得两个字符串等长,在依次分类判断出str>str1 长度,str==str1的情况,一旦str>s

hj1214ing的博客 933

大整数运算模板(减法)

大整数运算模板(减法) 大整数减法(str_a - str_b = str_c) #include #include #define N 1009 void sub(char str_a[],char str_b[],char str_c[]) {  char

ACM 1002

ACM内部函数--数学问题--大数相乘

简述 这是2012年蓝桥杯全国软件大赛预赛(C++本科组)第6题,有图片可知是个简单的大数计算的问题。 题目描述     对于32位字长的机器,大约超过20亿,用int类型就无法表示了,我们可以选择int64类型,但无论怎样扩展,固定的整数类型总是有表达的极限!如果对超级大整数进行精确运算呢?一个简单的办法是:仅仅使用现有类型,但是把大整数的运算化解为若干小整数的运算,即所谓

戎码人生 1162

C++实现大数运算(加减乘除求余)

前言: 只有部分GCC编译器支持int128,而我们平常使用的软件,最大只有_int64.当这些不够用时,我们该怎么办? 我本身想写代码实现整数型大数据的加减乘除和求余,结果写着写着想着连小数运算的也一起写上(反正加的代码不多) 电脑是死的,人是活的,当数据超出范围时,我们可以想其他方法去算,在这里,我使用string类来存数据,string类的容量足够大,相信够一般大数据使用了吧。 编译软...

cai_niaocainiao的博客 2万+

大数的四则运算模板(高精度加减乘除)

普通大数运算对于不同的题目要求,在main函数里修改就可以了const int MAXSIZE = 200; void Add(char *str1, char *str2, char *str3); void Minus(char *str1, char *str2, char *str3); void Mul(char *str1, char *str2, char *str3); void...

I_believe_CWJ的博客 750
上一篇: ACMDay11
下一篇: 费马定理在算法取模中的应用
MaplePlane
博客等级 码龄7年 9粉丝 21原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值