完整代码请扒拉到最底下↓。
解题要求:掌握基础的判断、循环、数组、字符串以及一些计算原理即可
“高精度”是怎么一回事?
简单来说,就是我们计算的数字太大太大了,导致已经超出了我们可以定义的范围,以至于我们不能用正常的定义来定义和计算数字,不然只能计算我们能所容纳的数字部分,无法达到要求。
比如longlong可以定义的范围在 -(2的63次方)到 2的63次方-1
如果此时数据过大,超过了longlong可以定义的范围,那么我们该如何计算它呢?这就需要我们运用到高精度的知识了。
题外话:Python没有这个限制,所以一行代码就解决了。
高精度乘法计算的原理
1.存储数据
你看既然我们数据太大,普通的定义都装不下了,那我们拿什么来装数据呢?没错,就是
数组
有同学可能会问:我们又不知道这个数有多长,我现在又不会用vector,(其实我现在也不会),那我们定义数组的时候应该定义多长的数组呢?
题目给出的数据范围是非负整数,且不超过10的2000次方,那么我们就定义两个长度为2000的数组,分别容纳两个乘数:
int anum[2000] = {0}, bnum[2000] = {0};
另外再定义一个可以容纳乘积的数组:
int pro[40000000] = {0};
接下来一步就是要输入数据了,但是这里有个坑,如果按照正常的顺序输入,算起来会非常麻烦,具体原因是什么呢?我们先看看我们是如何计算的
2.计算原理
其实计算原理我们早在小学就已经学过了,那就是
竖式运算
11
* 22
-------------
22
22
-------------
242
我们发现再计算的时候,下边的乘数的每一位会和上边的乘数每一位相乘,于是我们便利用两个for循环嵌套,外边的for循环对应下边的数,里边的for循环对应上边的数。
接下来就涉及乘积的每一位该怎么表示了:
1.将每一位相乘的结果存入第三个数组
2.错位相加,更新第三个数组对应的元素
3.如果相乘/相加结果大于10就需要存入结果个位的数
4.进位要保存一下,下一位相乘的时候就要加上,注意如果计算到最后一步也出现了进位,那么还要再多加一次循环,往多出来的一位存储进位
5.最终得到第三个数组排列的数值就是计算的结果。
但是这里如果仔细思考,就会发现有两个大麻烦:
1.决定每一位的数不仅仅有乘法,还有加法,所以要保存两次进位,一次是乘法进位,一次是加法进位
2.相加的时候是错位计算的,下标该如何对应?
第一个问题很好解决,定义两个进位即可,不过注意由于计算的顺序是:
乘法,更新位数->计算乘法进位->加法,再更新位数->计算加法进位
我在实现的时候将乘法和加法合并在一起算,直接一步到位,所以我的计算顺序是:
乘法,加法,更新位数->计算加法进位->计算乘法进位
(具体代码后边会一步一步解释)
但是这里在计算加法进位的时候,需要用到上一步未更新的数据和未更新的乘法进位(代码会解释的,别急),所以我把乘法进位的计算放在了后边,然而按照我的计算顺序,此时位数已经更新了,所以我还需要新建一个临时容器去存储未更新的数据。
那么第二个很关键的问题就是错位计算如何解决?
关于这个我还是选择了参考大佬,大佬给出的方法就是:下标相加
例如我定义的是
for (int i = 0;i < bl;i++)//下边的乘数
{
for (int j = 0; j <= al; j++)//上边的乘数
{
pro[?]=bnum[i] * anum[j]
}
}
那么怎么将相乘的结果错位相加呢?这里举个例子:
12
* 34
-------------
48
36
-------------
408
这里第一个乘数12中的“2”对应的就是anum[0],“1”对应的就是anum[1],同理第二个乘数34中“4”对应的就是bnum[0],“3”对应的就是bnum[1].
那么我们来看第一步计算2 * 4 = 8:
两个乘数分别为anum[0],bnum[0],乘积为pro[0]
第二步1 * 4 = 4:
两个乘数分别为anum[1],bnum[0],乘积为pro[1]
第三步2 * 3 = 6:
两个乘数分别为anum[0],bnum[1],乘积为pro[1]
第四步1 * 3 = 3:
两个乘数分别为anum[1],bnum[1],乘积为pro[2]
观察规律你就会发现乘积的下标正好等于两个乘数下标相加之和!这也就是实现错位相加的核心原理。
接下来就是核心的计算部分了:
首先定义我们所需要的各种东东
int anum[2000] = {0}, bnum[2000] = {0};
int pro[4000000] = {0};//乘积
int dig_mul = 0;//乘法进位
int dig_add = 0;//加法进位
int temp = 0;//临时存储当前位数的容器,防止更新数据后,后续计算使用的是更新后的数据
//嵌套循环准备好
for (int i = 0;i < bl;i++)//下边的乘数
{
for (int j = 0; j <= al; j++)//上边的乘数
{
temp = pro[i + j];//先将未更改的数据临时保存一下
}
}
然后就是计算位数,这里一步一步来:
bnum[i] * anum[j]//首先二者相乘
bnum[i] * anum[j] + dig_mul//相乘之后再加上上一步乘法的进位
(bnum[i] * anum[j] + dig_mul) % 10//模10就是除以10取余数,可以取得各位数的数字,现在得到的就是乘法结束后当前位数的数字
//此时乘法计算已经结束,下面继续计算加法
pro[i + j] + (bnum[i] * anum[j] + dig_mul) % 10//乘法计算结束后,加上上一次计算结束的结果
pro[i + j] + (bnum[i] * anum[j] + dig_mul) % 10 + dig_add//再加上上一次加法的进位
(pro[i + j] + (bnum[i] * anum[j] + dig_mul) % 10 + dig_add) % 10//最后整体模10,取的当前位数
//完整过程如下:
pro[i + j] = (pro[i + j] + (bnum[i] * anum[j] + dig_mul) % 10 + dig_add) % 10
接下来就是计算加法进位:
dig_add = (temp + (bnum[i] * anum[j] + dig_mul) % 10 + dig_add) / 10;//计算加法进位
计算乘法进位:
dig_mul = (bnum[i] * anum[j] + dig_mul) / 10;//计算乘法的进位
注意在一次循环完成后,需要将本次计算的进位都清零,不然会干扰下一次计算
完整如下:
int dig_mul = 0;//乘法进位
int dig_add = 0;//加法进位
int temp = 0;//临时存储当前位数的容器,防止更新数据后,后续计算使用的是更新后的数据
for (int i = 0;i < bl;i++)//下边的乘数
{
for (int j = 0; j <= al; j++)//上边的乘数
{
temp = pro[i + j];//先将未更改的数据临时保存一下
pro[i + j] = (pro[i + j] + (bnum[i] * anum[j] + dig_mul) % 10 + dig_add) % 10;//计算当前位的数字
dig_add = (temp + (bnum[i] * anum[j] + dig_mul) % 10 + dig_add) / 10;//计算加法进位
dig_mul = (bnum[i] * anum[j] + dig_mul) / 10;//计算乘法的进位
}
dig_mul = 0;//计算完一位后乘法进位清零
dig_add = 0;//计算完一位后加法进位清零
}
3.输入数据
细心的同学已经发现了问题:
我们输入数据是从高位往低位输入的,换句话说,如果按照输入顺序存储,那我们输入的两个数据是“最高位对齐”的:
123
123456
但是我们竖式计算的要求是“个位对其”:
000123
123456
如果按照输入顺序存储数据,这样对我们计算有着很大的影响,由于每次输入的数据长度不一,想把下标对其非常困难,那我们怎么解决这个问题呢?
聪明的我大佬想到了一种方法,就是将输入的数据倒序存入数组,这样一来,两个数的第一位不就对其了吗?
321000
654321
细心的同学似乎又注意到一点:短一点的数字后边是用0补齐的,为什么不直接空着呢?
我们回顾一下上边关于计算部分的代码,就发现在整个循环中,始终都是要访问anum[i]和bnum[i]这两个元素的,如果其中一个数比另一个数短,那么短的那个数计算完之后,也仍然会访问它剩下的元素,所以我们不能让它空着,就拿0过来填位置。
接下来先讲怎么输入数据
由于int、longlong这些都装不下了,我们又不能直接往数组里边存,所以需要一个中介来暂存一下数据,接下来就轮到伟大的字符串登场了:
//由于int、longlong无法容纳足够多的数字,只能用string来存储:
string a, b;
cin >> a >> b;
然后咱们就开始把string里的字符倒序存入数组
//获取两个字符串的长度:
int al = a.length();
int bl = b.length();
//倒序将两个数字存入一个int数组里
//目的是将两个数从个位对其
for (int i = 0; i < al; i++)
{
//字符串a是可以变成a[i]的,每一个元素就是对应的字符
//-'0'可以将数字字符转换为数字
anum[i] = a[al - i - 1]-'0';//利用al - i - 1实现倒序
}
for (int i = 0; i < bl; i++)
{
bnum[i] = b[bl - i - 1]-'0';
}
4.最后差不多就剩下输出结果了
由于我们是倒序存储的,所以输出的时候就需要倒序输出,这样输出来就是正序了。
不过注意我们还要把数据前边多余的0给删掉,之前我用的方法是设置一个检测系统,在for循环里不断判断是否遇到第一个非零数字,没有遇到就跳过这次循环。不过后来发现还有一种更简单的方法,给大家分享一下:
//若前边几位都是0,且直到最后一位之前没有找到非零数,则减少字符串的长度
//不判断到最后一位的原因是,如果计算结果为0,能保证输出计算结果
while (len > 0 && pro[len] == 0)
{
len--;
}
//因为我们是反向计算,所以最后需要反向输出,才能使数字为正序
for (int i = len; i >= 0 ; i--)
{
cout << pro[i];
}
至此高精度乘法计算就结束了,不过它并不是真正意义上的高精度乘法,因为它并没有涉及小数部分,或者负数,所以这只是一个半成品,有兴趣的小伙伴可以下去实现一下。
完整代码如下
#include <iostream>
using namespace std;
int anum[2000] = {0}, bnum[2000] = {0};
int pro[4000000] = {0};
int main() {
//由于int无法容纳足够多的数字,只能用string来存储
string a, b;
cin >> a >> b;
//获取两个字符串的长度:
int al = a.length();
int bl = b.length();
int len = al + bl;
//倒序将两个数字存入一个int数组里
//目的是将两个数从个位对其,才能计算
for (int i = 0; i < al; i++)
{
//字符串a是可以变成a[i]的,每一个元素就是对应的字符
//-'0'可以将数字字符转换为数字
anum[i] = a[al - i - 1]-'0';//利用al - i - 1实现倒序
}
for (int i = 0; i < bl; i++)
{
bnum[i] = b[bl - i - 1]-'0';
}
int dig_mul = 0;//乘法进位
int dig_add = 0;//加法进位
int temp = 0;//临时存储当前位数的容器,防止更新数据后,后续计算使用的是更新后的数据
for (int i = 0;i < bl;i++)//下边的乘数
{
for (int j = 0; j <= al; j++)//上边的乘数
{
temp = pro[i + j];//先将未更改的数据临时保存一下
pro[i + j] = (pro[i + j] + (bnum[i] * anum[j] + dig_mul) % 10 + dig_add) % 10;//计算当前位的数字
dig_add = (temp + (bnum[i] * anum[j] + dig_mul) % 10 + dig_add) / 10;//计算加法进位
dig_mul = (bnum[i] * anum[j] + dig_mul) / 10;//计算乘法的进位
}
dig_mul = 0;//计算完一位后乘法进位清零
dig_add = 0;//计算完一位后加法进位清零
}
//若前边几位都是0,且直到最后一位之前没有找到非零数,则减少字符串的长度
//不判断到最后一位的原因是,如果计算结果为0,能保证输出计算结果
while (len > 0 && pro[len] == 0)
{
len--;
}
//因为我们是反向计算,所以最后需要反向输出,才能使数字为正序
for (int i = len; i >= 0 ; i--)
{
cout << pro[i];
}
return 0;
}