算法：蓝桥杯——大数乘法（C语言）

目录

​​​​​​​问题说明

设计思路

程序代码

运行结果

反思

---

问题说明

对于32位字长的机器，大约超过20亿，用int类型就无法表示了，我们可以选择int64类型，但无论怎样扩展，固定的整数类型总是有表达的极限！如果对超级大整数进行精确运算呢？一个简单的办法是：仅仅使用现有类型，但是把大整数的运算化解为若干小整数的运算，即所谓：“分块法”。

上图表示了分块乘法的原理。可以把大数分成多段（此处为2段）小数，然后用小数的多次运算组合表示一个大数。可以根据int的承载能力规定小块的大小，比如要把int分成2段，则小块可取10000为上限值。注意，小块在进行纵向累加后，需要进行进位校正。

设计思路

该方法类似于两位数的乘法，具体步骤如下：
将第一个数的个位数与第二个数的个位数相乘，得到部分积的个位数。
将第一个数的个位数与第二个数的十位数相乘，得到部分积的十位数。
将第一个数的十位数与第二个数的个位数相乘，得到部分积的十位数。
将第一个数的十位数与第二个数的十位数相乘，得到部分积的百位数。
将得到的部分积相加，得到最终结果。

举个例子：计算 35 × 47
5 × 7 = 35，部分积的个位数为5。
5 × 4 = 20，部分积的十位数为2。
3 × 7 = 21，部分积的十位数为2。
3 × 4 = 12，部分积的百位数为1。
将部分积相加：100 + 20 + 21 + 5 = 146，所以35 × 47 = 146。

程序代码

#include <stdio.h>
 
int main()
{
    int base = 10000; //以万作为分段点
    long x = 0;
    lont y = 0;
    int z[4] = {0, 0, 0, 0};
 
    scanf("%ld%ld", &x, &y);
    //将大数分段
    int x1 = x % base;
    int x2 = x / base;
    int y1 = y % base;
    int y2 = y / base;
    //分段相乘
    int n1 = x1 * y1;
    int n2 = x1 * y2;
    int n3 = x2 * y1;
    int n4 = x2 * y2;
    //纵向相加
    z[3] = n1 % base;
    z[2] = (n1 / base) + (n2 % base) + (n3 % base);
    z[1] = (n2 / base) + (n3 / base) + (n4 % base);
    z[0] = n4 / base;
    //进位校正   
    z[1] += z[2] / base;
    z[2] = z[2] % base;
    z[0] += z[1] / base;
    z[1] = z[1] % base;
 
    printf("%d,%d,%d,%d", z[0], z[1], z[2], z[3]);
 
    return 0;
}

运行结果

反思

该项目中，若乘数连续多个位置为0，比如10000000*10000000，会出现进位之后单个数块字符串不足的问题，导致结果不准确的情况，如下图所示：

因此，采用数组存储两个乘数每一位的数值，再逐位进行乘法及进位运算。改进代码如下：

#include <stdio.h>
#include <string.h>
 
int main()
{
    const int N = 100;
    char A[N], B[N];
    int a[N], b[N], c[2*N];
    //初始化存储结果的数组c
    for (int i = 0; i < (2 * N); i++)
    {
        c[i] = 0;
    }  
    //读取字符数组A并将数值赋予整型数组a
    gets(A);
    int lena = strlen(A);
    for (int i = 0; i < lena; i++)
    {
        a[i] = A[lena - 1 - i] - '0';
    }
    //读取字符数组B并将数值赋予整型数组b
    gets(B);
    int lenb = strlen(B);
    for (int j = 0; j < lenb; j++)
    {
        b[j] = B[lenb - 1 - j] - '0';
    }
    //逐位相乘
    for (int i = 0; i < lena; i++)
    {
        for (int j = 0; j < lenb; j++)
        {
            c[i + j] += a[i] * b[j];
        }
    }
    //进位校正
    for (int i = 0; i < (lena + lenb); i++)
    {
        c[i+1] += c[i]/10;
        c[i] %= 10;
    }
    //判断结果从第几位开始输出
    int len = lena + lenb - 1; 
    while(0 == c[len] && len > 0)
    {
        len--;
    }
    //输出结果
    for (int i = len; i >= 0; i--)
    {
        printf("%d", c[i]);
    }
 
    return 0;
}

编译运行后，结果输出正常。