目录
—————————————————正片开始—————————————————
例4：（高精除以低精）输入两个正整数，求他们的商（做整除）。
——————————————————————————————————————————
【第一节：高精度运算】
0.预告
大家好，今天给大家带来的是高精度算法。
知周所众，有些计算精度非常高，位数甚至可能达到几十位或几百位，我们知道，因为硬盘限制，无法计算如此大的算式（像288194716471361786131+283641643189476321314这种，由于long long 类型最大只能计算20位，因此无法算出最终结果），但是我们可以利用程序设计来计算这样的高精度运算。
那既然要使用高精度计算，那么以下几个问题就需要处理，下面我们就逐一分析：
—————————————————正片开始—————————————————
1.数据的接收与储存
因为数据输入特别长，甚至有可能超出long long类型，导致无法接收，所以我们可以采用字符串（cstring库）类型类接收一长串的数字。
接着，我们利用字符串的函数和操作运算，将数据的每一个数字都存储在数组之内，这样就可以完成这第一个难题了，参考代码如下：
#include <cstring>
#include <iostream>
//这里用bits/stdc++.h也可以
using namespace std;
int slen;
void init(int a[]) //传入一个数组
{
string s;
cin >> s; //读入字符串s
slen = s.length(); //用slen计算字符串s的长度，用size()亦可
for(int i = 1;i <= slen;i++){
a[i] = s[slen - i] - '0'; //将数串s转换为数组a，并倒序存储
}
}当然，用循环加数组亦可。
2.高精度数位数的确定
位数的确定：接收时的字符串长度就是它的位数。
3.进位、借位处理
这里直接看处理，要用。
1.加法进位：
c[i] = a[i] + b[i];
if(c[i] >= 10) c[i] %= 10,++c[i + 1];2.减法借位
if(a[i] < b[i]) --a[i + 1],a[i] += 10;3.乘法进位
c[i + j - 1] = a[i] * b[i] + x + c[i + j - 1];
x = c[i + j - 1] / 10;
c[i + j - 1] %= 10;4.商和余数的求法
商和余数的处理：视被除数和除数的位数情况进行处理。
4.例题
例1 （高精度加法）输入两个正整数，求它们的和。
【算法分析】
正常情况下是输入两个数到变量，把他们相加后输出。但是我们知道，在C++中任何数据类型都有一定的范围。当两个加数属于高精度时，这种方法显然不能求出精确解，所以我们要寻求另一种方法。我们读小学时，我们做大数加法的笔算时通常都会用竖式计算。这样，我们的计算也就变得方便了。
既然这样，我们使用数组a，b分别存储加数和被加数，用数组c存储结果。那么就可以通过以下代码来计算：（仅仅为描述，直接用会报错，不要复制）
int c[100];
void add(int a[],int b[])
{
int i = 1,x = 0;
while((i <= a.length) || (i <= b.length))
{
c[i] = a[i] + b[i] + x;
x = c[i] / 10;
c[i] %= 10;
i++;
}
}通常，我们用字符串来接收，程序如下：
【参考程序】
#include <bits/stdc++.h>
using namespace std;
int main(){
char a1[100],b1[100];
int a[100],b[100],c[100],lena,lenb,lenc,x;
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
memset(c,0,sizeof(c));
gets(a1);
gets(b1); //输入加数与被加数
lena = strlen(a1);
lenb = strlen(b1);
for(int i = 0;i <= lena - 1;i++) a[lena - i] = a1[i] - 48; //加数放入a数组
for(int i = 0;i <= lenb - 1;i++) b[lenb - i] = b1[i] - 48; //加数放入b数组
lenc = 1;
x = 0;
while(lenc <= lena || lenc <= lenb)
{
c[lenc] = a[lenc] + b[lenc] + x; //两数相加
x = c[lenc] / 10;
c[lenc] %= 10;
lenc++;
}
c[lenc] = x;
if(c[lenc] == 0)
lenc--; //处理最高进位
for(int i = lenc;i >= 1;i--)
cout << c[i]; //输出结果
cout << endl;
return 0;
}
【注意事项】
这里因为是字符串类型，所以不能通过空格隔开两个数
（如：123456789101112131415161718 181716151413121110987654321）
需要用换行（enter）来输入（如：123456789101112131415161718 【这里是换行】
181716151413121110987654321）
例2： （高精度减法）输入两个正整数，求他们的差。
【算法分析】
类似加法，也可以用竖式来计算，但要注意，减法的减数一定要比被减数小，因此需要先借位，再做减法。
【参考程序】
#include <bits/stdc++.h>
using namespace std;
int main(){
char n[256],n1[256],n2[256];
int a[256],b[256],c[256],lena,lenb,lenc;
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
memset(c,0,sizeof(c));
printf("Input minuend:"); gets(n1); //输入被减数
printf("Input subtrahend:"); gets(n2); //输入减数
if(strlen(n1) < strlen(n2) || (strlen(n1) == strlen(n2) && strcmp(n1,n2) < 0))
{
//strcmp()为字符串比较函数，当n1 == n2，返回0
//n1 > n2时，返回正整数;n1 < n2时，返回负整数
//处理被减数和减数，若减数 > 被减数，则交换并输出"-"
strcpy(n,n1); //将n1数组的值完全赋值给n数组
strcpy(n1,n2);
strcpy(n2,n);
cout << "-"; //交换了减数和被减数后，原数为负数，需先输出符号
}
lena = strlen(n1); lenb = strlen(n2);
for(int i = 0;i <= lena - 1;i++) a[lena-i] = int(n1[i] - '0'); //被减数放入a数组
for(int i = 0;i <= lenb - 1;i++) b[lenb-i] = int(n2[i] - '0'); //减数放入b数组
int cnt = 1;
while(cnt <= lena || cnt <= lenb)
{
if(a[cnt] < b[cnt])
{
a[cnt] += 10; //不够减向高位借1
a[cnt + 1]--;
}
c[cnt] = a[cnt] - b[cnt]; //对应位相减
cnt++;
}
lenc = cnt;
while((c[lenc] == 0) && (lenc > 1)) lenc--; //最高位0不输出
for(int i = lenc;i >= 1;i--) cout << c[i]; //输出结果
cout << endl;
return 0;
}例3：（高精度乘法）输入两个正整数，求他们的积。
【算法分析】
与减法一样，和加法类似，我们照样可以使用竖式来计算乘法。乘法当然也有进位，但对每一位进行乘法时，必须要进行错位相加。
我们分析一下数组c下标的规律，可以发现有这样一个关系式：ci = c'i + c''i + ......由此可见，ci跟a[i] * b[j]乘积有关，也跟上次进位有关，还跟原ci值有关，那么我们通过对ci的下标分析，可以得出以下结论：c[i+j-1] = a[i] * b[j] + x + c[i+j-1]；x = c[i+j-1] / 10；c[i+j-1] %= 10；。
那么这样就可以通过这种算法来算高精度的乘法了。
【参考程序】
#include <bits/stdc++.h>
using namespace std;
int main(){
char a1[101],b1[101];
int a[101],b[101],c[10001],lena,lenb,lenc,x;
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
memset(c,0,sizeof(c));
scanf("%s",a1);
scanf("%s",b1);
lena = strlen(a1); lenb = strlen(b1);
for(int i = 0;i <= lena - 1;i++) a[lena-i] = a1[i] - 48;
for(int i = 0;i <= lenb - 1;i++) b[lenb-i] = b1[i] - 48;
for(int i = 1;i <= lena;i++)
{
x = 0; //用于存放进位
for(int j = 1;j <= lenb;j++) //对乘数的每一位进行处理
{
c[i + j - 1] = a[i] * b[j] + x + c[i + j - 1]; //当前乘积 + 上次乘积进位 + 原数
x = c[i + j - 1] / 10;
c[i + j - 1] %= 10;
}
c[lenb + i] = x; //进位
}
lenc = lena + lenb;
while((c[lenc] == 0) && (lenc > 1)) lenc--; //删除前导0
for(int i = lenc;i >= 1;i--) cout << c[i];
cout << endl;
return 0;
}例4：（高精除以低精）输入两个正整数，求他们的商（做整除）。
【算法分析】
做除法时，我们知道每一次商的值都在0~9，每次求得的余数连接往后的n位得到新的被除数，继续做除法（简而言之，就是像543/3，5%3 = 2，那么剩下的2就和后面的4合成24再/3）。因此，再做高精度除法时，需要涉及乘、减法运算，还要移位处理，所以难度相较前三题都比较高。当然，为了程序简洁，可以避免使用高精度乘法（不然真的难上天了），而用0~9次循环减法取代（高精度乘法）得到商的值。我们先从高精度除以低精度来算一下，这里使用的是按位相除法。
【参考程序】
#include <bits/stdc++.h>
using namespace std;
int main(){
char a1[100];
int a[100],c[100],lena,lenc,x = 0,b;
memset(a,0,sizeof(a));
memset(c,0,sizeof(c));
gets(a1);
cin >> b;
lena = strlen(a1);
for(int i = 0;i <= lena - 1;i++) //按位相除
a[i + 1] = a1[i] - 48;
for(int i = 1;i <= lena;i++)
{
c[i] = (x * 10 + a[i]) / b;
x = (x * 10 + a[i]) % b;
}
lenc = 1;
while((c[lenc] == 0) && (lenc < lena)) lenc--; //删除前导0
for(int i = lenc;i <= lena;i++) cout << c[i];
cout << endl;
return 0;
}
【注意事项】
实质上，在做两个高精度数运算的时候，存储高精度数的数组元素可以不仅仅只保留一位数字，还可以采取保留多位数（像一个整形或长整型那样的数），这样的话在做运算时（特别是做成发的时候）时，可以减少很多运算次数。
例5：（高精除以高精）输入两个正整数，求他们的商和余数。
【算法分析】
高精除以低精是对被除数的每一位（当然，这里的“一位”包含前面的余数，以下同理）除以余数，而高精除以高精则是用减法来模拟除法，对被除数的每一位都减去除数，一直减到当前位置的数字（包括前面一位的余数）小于除数（由于每一位数字小于10，所以对于每一位最多进行10次计算）便可以了。这个程序比前4个都要难很多，请小心观看【狗头】！
【参考程序】
#include <bits/stdc++.h>
using namespace std;
int a[101],b[101],c[101],d;
void init(int a[])
{
string s;
cin >> s; //读入字符串s
a[0] = s.length(); //用a[0]计算字符串s的位数
for(int i = 1;i <= a[0];i++)
{
a[i] = s[a[0] - i] - '0'; //将数串s转换为数组a，并倒序存储
}
}
void print(int a[]) //打印输出
{
if(a[0] == 0) {cout << 0 << endl; return;}
for(int i = a[0];i > 0;i--) cout << a[i];
cout << endl;
return;
}
int compare(int a[],int b[])
//比较a和b的大小关系，若a > b则返回1，若a < b则返回-1，若a = b则返回0
{
if(a[0] > b[0]) return 1; //a的位数大于b则a > b
if(a[0] < b[0]) return -1; //反之则b > a
for(int i = a[0];i > 0;i--) //从高位至低位比较
{
if(a[i] > b[i]) return 1;
if(a[i] < b[i]) return -1;
}
return 0; //各位都相等则返回相等
}
void jian(int a[],int b[]) //计算a = a - b
{
int flag;
flag = compare(a,b); //调用比较函数判断大小
if(flag == 0) {a[0] = 0; return;} //相等
if(flag == 1) //大于
{
for(int i = 1;i <= a[0];i++)
{
if(a[i] < b[i]) {a[i+1]--; a[i] += 10;} //若不够减则向上借一位
a[i] -= b[i];
}
while(a[0] > 0 && a[a[0]] == 0) a[0]--; //修正a的位数
return;
}
}
void numcpy(int p[],int q[],int det)
//复制p数组到q数组从det开始的地方
{
for(int i = 1;i <= p[0];i++) q[i+det-1] = p[i];
q[0] = p[0] + det - 1;
}
void chugao(int a[],int b[],int c[])
{
int tmp[101];
c[0] = a[0] - b[0] + 1;
for(int i = c[0];i > 0;i--)
{
memset(tmp,0,sizeof(tmp)); //数组清零
numcpy(b,tmp,i);
while(compare(a,tmp) >= 0) {c[i]++; jian(a,tmp);}; //用减法模拟
}
while(c[0] > 0 && c[c[0]] == 0) c[0]--;
return;
}
int main()
{
memset(a,0,sizeof(a));
memset(b,0,sizeof(b));
memset(c,0,sizeof(c));
init(a);init(b);
chugao(a,b,c);
print(c);
print(a);
return 0;
}是的，你没看错，这道题比起前4题长了“亿”点:）
例6：（Noip1999）回文数
【问题描述】
若一个数（首位不为0）从左向右读与从右往左读都一样，那我们就称其为回文数。
例如：给定一个10进制数56，将56加65（即把56从右往左读），得到121是个回文数。又如：10进制数87。
STEP1: 87 + 78 = 165 STEP2: 165 + 651 = 726
STEP3: 726 + 627 = 1353 STEP4:1353 + 3531 = 4884
这里一步指一次n进制的加法，在上例最少使用了4次得到了回文数4884。
现在给出一个n进制数m，试编一程序，求至少需经过几步才可以得到回文数。若30步以内无法得到回文数，则输出“Impossible”。
【输入样例】
9 87
【输出样例】
6
【算法分析】
n进制运算： 1.当前位规范由%10改为%n 2.进位处理由/10改为/n 3.其他运算规则不变
【参考程序】
#include <bits/stdc++.h>
using namespace std;
int n,a[101],b[101],ans;
void init(int a[]) //将数串s转化为整数数组a
{
string s;
cin >> n >> s; //读入字符串s
memset(a,0,sizeof(a)); //数组a清零
a[0] = s.length(); //用a[0]计算字符串s的位数
for(int i = 1;i <= a[0];i++)
if(s[a[0] - i] >= '0' && s[a[0] - i] <= '9') a[i] = s[a[0] - i] - '0';
else a[i] = s[a[0] - i] - 'A' + 10;
}
bool check(int a[]) //判断整数数组a是否为回文数
{
for(int i = 1;i <= a[0];i++)
if(a[i] != a[a[0] - i + 1]) return false;
return true;
}
void jia(int a[]) //整数数组a与其反序数b进行n进制加法运算
{
for(int i = 1;i <= a[0];i++) b[i] = a[a[0] - i + 1]; //反序数b
for(int i = 1;i <= a[0];i++) a[i] += b[i]; //逐位相加
for(int i = 1;i <= a[0];i++) //处理进位
{
a[i+1] += a[i] / n;
a[i] %= n;
}
if(a[a[0] + 1] > 0) a[0]++; //修正新的a的位数(a + b最多只能进一位)
}
int main(){
init(a);
if(check(a)) {cout << 0 << endl; return 0;}
ans = 0; //步骤初始化为零
while(n <= 30)
{
ans++;
jia(a);
if(check(a)) {cout << ans << endl; return 0;}
}
cout << "Impossible"; //输出无解信息
return 0;
}其实只要将上述几个例子综合一下，这道看似摸不着头绪的题也就迎刃而解了。
5.总结
好的，这就是小编今天给大家带来的“高精度算法”的一系列计算，最近开学了，时间少请见谅，有什么问题欢迎大家指出，谢谢大家，我们下个基础算法“数组排序”见！
3584
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
