分治法实验之大整数乘法(算法设计分析)

最新推荐文章于 2024-05-03 10:27:39 发布
最新推荐文章于 2024-05-03 10:27:39 发布
阅读量4.1k 收藏 60
点赞数 5
文章标签： 算法 分治 大整数乘法 大整数加法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52117223/article/details/124419230
版权

分治法实验之大整数乘法

01. 问题描述

编写一个能计算两个n（16<=n<=256）位整数的乘法。

02. 输入格式

输入两行数据，每行表示一个大整数

03. 输出格式

输出运算后大整数的数据值

04. 输入样例

1111111111111111
1111111111111111

05. 输出样例

结果:1234567901234567654320987654321

06. 问题分析

  1. 大整数的位数n≥16，可以是十进制或者二进制数。
  2. 两个大整数相乘如果按照传统的方法，需要耗费n2次数量相乘，利用分治算法，可降低其时间复杂度。
  3. 分治实现思想：将第一个整数分成AB两部分，第二个整数分成CD两部分，当n=1时，直接利用普通乘法相乘，当n>1时，根据公式分治解乘法AC、(B-A)(C-D)、BD，然后根据公式将AC、(B-A)(C-D)、BD相加并移动n/2位，将AC结果移动n位，最后合并求解结果。
  4. 这样，原整数乘法化为3次n/2规模整数乘法运算和6次加减运算(Θ(n))

公式一：AC*10^2^ + ( B-A)(C-D) + AC + BD )*10^n/2^ + BD
公式二：AC*10^n^ + ( A+B)(C+D) - AC - BD )*10^n/2^ + BD

  1. 以下实现采用第一个公式实现

07. 算法设计

算法设计：
算法：MULTIFY
input：存储数组x,y;整数的位数n
output：相乘结果数组result
过程：Multify(x,y,result,n)
1.	if n=1 直接相乘计算结果
2.	else
3.	    x_div2[1…n/2] ← x[1…n/2]
4.	    x_div1[1…n/2] ← x[n/2+1…n]
5.	    y_div2[1…n/2] ← y[1…n/2]
6.	    y_div1[1…n/2] ← y[n/2+1…n]
7.	    Multify(x_div1,y_div2,ac,n/2)
8.	    Multify(x_div2,y_div2,bd,n/2)
9.	    subx[1…n/2] ← x_div2[1…n/2] – x_div1[1…n/2]
10.	    suby[1…n/2] ← y_div1[1…n/2] – y_div2[1…n/2]
11.	    Multify(subx,suby,middleresult_1,n/2)
12.	    addxy_1 ← ac + bd;
13.	    middleresult_2 ← addxy_1 + middleresult_1
14.	    move middleresult_2  n/2位
15.	    move ac  n位
16.	    addxy_2 ← ac + bd;
17.	    result ← addxy_2 + middleresult_2
18.	endif

08. 代码实现

位数对齐函数：

/*位数对齐函数
 *将输入的字符串转换为数字数组(数字数组倒序存储，即高位放在后面，并在数组[0]位置放置数字位的位数)
 *位数对齐：为了方便计算，直接对齐到一个大于两数最大位数的一个2的幂次
 */
int align(char* ch_x,char* ch_y,int& ch_x_length,int& ch_y_length){

    int k = 0;
    int n = pow(2,k);
    while(1){
        if(n>=max(ch_x_length,ch_y_length))
            break;
        ++k;
        n = pow(2,k);
    }

    int i = 0,j = 0;
    if(ch_x_length < n){
        char ch_x_tmp[n];
        for(;i<n;++i){
            if(i < n - ch_x_length)
                ch_x_tmp[i] = '0';
            else
                ch_x_tmp[i] = ch_x[j++];
        }
        strncpy(ch_x,ch_x_tmp,n);
        ch_x_length = n;
    }
    i = 0;
    j = 0;
    if(ch_y_length < n){
        char ch_y_tmp[n];
        for(;i<n;++i){
            if(i < n - ch_y_length)
                ch_y_tmp[i] = '0';
            else
                ch_y_tmp[i] = ch_y[j++];
        }
        strncpy(ch_y,ch_y_tmp,n);
        ch_y_length = n;
    }
    return n;
}

大整数加法函数：

/*大整数加法函数
 *考虑进位
 *并将两数相加和直接补位到指定new_bits位数，存于addxy数组中
 */
void Add(int* x,int* y,int* addxy,int new_bits){//这里应当保证位数的对齐
    for(int i = 1;x[0]+i <= new_bits;++i)
        x[x[0]+i] = 0;
    for(int i = 1;y[0]+i <= new_bits;++i)
        y[y[0]+i] = 0;
    x[0] = new_bits;
    y[0] = new_bits;

    int carry = 0;//进位位

    for(int i = 1;i<=new_bits;++i){
        addxy[i] = (x[i]+y[i]+carry)%10;
        if(x[i]+y[i]+carry>9)
            carry = 1;
        else
            carry = 0;
    }

    if(carry == 1){
        addxy[0] = new_bits+1;//结果长度
        addxy[addxy[0]] = 1;//进位为1
    }
    else
        addxy[0] = new_bits;//结果长度
}

大整数减法函数：

/*大整数减法函数
 *减法位数不会改变
 *考虑大减小和小减大两种情况
 *用数组[0]位的符号表示结果的正负，绝对值为其位数
 */
void Sub(int* x,int* y,int* subxy,int bits){  //x-y  减位 位数不变
    int flag = 0;
    for(int i = bits;i>=1;--i){
        if((x[i]!=0||y[i]!=0)&&(x[i]!=y[i])){
            if(x[i]<y[i])
                flag = 1;
            break;
        }
    }

    if(flag == 0){ //大减小
        int borrow = 0;//借位
        for(int i = 1;i <= bits;++i){
            if(x[i]-y[i]<0){
               x[i+1]--;
                borrow = 1;
            }
            else
                borrow = 0;
            subxy[i] = (10*(borrow) + x[i] - y[i]);
        }
        subxy[0] = bits;

    }
    else{   //小减大
        int borrow = 0;//借位
        for(int i = 1;i <= bits;++i){
            if(y[i]-x[i]<0){
               y[i+1]--;
                borrow = 1;
            }
            else
                borrow = 0;
            subxy[i] = (10*(borrow) + y[i] - x[i]);
        }
        subxy[0] = -bits;
    }

}

位数移动函数：

/*位数移动函数
 *即扩大10的n次幂
 *这里考虑的是倒序存储的情况
 */
void Move(int* arr,int n){   //正序左移n位  //这里先扩大位数再移位
    for(int i=arr[0];i>=1;--i)
        arr[i+n]= arr[i];
    for(int i = 1;i<=n;++i)
        arr[i] = 0;
    arr[0] += n;
}

分治函数：

/*分治函数
 *将一个大整数分成左右两部分
 */
void Divide(int* arr_1,int* arr_2,int s,int t){ //由arr_1分到arr_2
    int i;
    for(i = 1;i <= t - s;++i)
        arr_2[i] = arr_1[s+i-1];
    arr_2[0] = t -s;
}

大整数乘法函数：

/*大整数乘法实现函数
 */
void Multify(int* x,int* y,int* result,const int& n){ //大整数乘法
	//申请空间存放数据四部分
    int* x_div1 = (int *)malloc((n*8+1)*sizeof(int));
    int* x_div2 = (int *)malloc((n*8+1)*sizeof(int));
    int* y_div1 = (int *)malloc((n*8+1)*sizeof(int));
    int* y_div2 = (int *)malloc((n*8+1)*sizeof(int));
    //递归出口
    if(n==1){
        result[1]=x[1]*y[1];
        if(result[1]<=9)
            result[0] = 1;
        else{//存在进位
            result[2]=result[1]/10;
            result[1]%=10;
            result[0] = 2;
        }
        if(x[0]*y[0]<0){ //判断正负
            result[0] = - abs(result[0]);
        }
    }
    else{
    	//分成四部分
        Divide(x,x_div2,1,(n>>1)+1);
        Divide(x,x_div1,n/2+1,n+1);
        Divide(y,y_div2,1,(n/2)+1);
        Divide(y,y_div1,n/2+1,n+1);
        
        int* ac = (int *)malloc((n*32+1)*sizeof(int));//分治结果
        int* bd = (int *)malloc((n*32+1)*sizeof(int));//分治结果
        int* addxy_1 = (int *)malloc((n*32+1)*sizeof(int));//存放加法和
        int* addxy_2 = (int *)malloc((n*32+1)*sizeof(int));//存放加法和
        int* subx = (int *)malloc((n*32+1)*sizeof(int));//存放减法差
        int* suby = (int *)malloc((n*32+1)*sizeof(int));//存放减法差
        int* middle_result_1 = (int *)malloc((n*32+1)*sizeof(int));//中间结果
        int* middle_result_2 = (int *)malloc((n*32+1)*sizeof(int));//中间结果

        Multify(x_div1,y_div1,ac,n/2);//分治
        Multify(x_div2,y_div2,bd,n/2);//分治
        Sub(x_div2,x_div1,subx,n/2);    //B-A
        Sub(y_div1,y_div2,suby,n/2);    //C-D
        Multify(subx,suby,middle_result_1,n/2);//分治
        Add(ac,bd,addxy_1,n*2);
        if(middle_result_1[0] < 0){ //根据正负号 判断接下来的某种操作
            for(int i = 1;abs(middle_result_1[0])+i <= addxy_1[0];++i)
                middle_result_1[middle_result_1[0]+i] = 0;
            Sub(addxy_1,middle_result_1,middle_result_2,n*2);
        }
        else
            Add(addxy_1,middle_result_1,middle_result_2,n*4);

		//下面将所用到的进行退位，排除没用的0空位 因为当前的值的每个位数可能差距太大

        for(int i = abs(middle_result_2[0]);i>=1;--i){
            if(middle_result_2[i]==0)
                continue;
            else{
                middle_result_2[0] = i;
                break;
            }
        }
        for(int i = abs(ac[0]);i>=1;--i){
            if(ac[i]==0)
                continue;
            else{
                ac[0] = i;
                break;
            }
        }
        for(int i = abs(bd[0]);i>=1;--i){
            if(bd[i]==0)
                continue;
            else{
                bd[0] = i;
                break;
            }
        }

        //合并
        Move(middle_result_2,n/2);
        Move(ac,n);
        Add(ac,bd,addxy_2,n*2);
        Add(addxy_2,middle_result_2,result,n*2);

        if(x[0]*y[0]<0) //判断符号
            result[0] = -abs(result[0]);
        else
            result[0] = abs(result[0]);
    }
}

主函数：

/*main函数
 */

#include <iostream>
using namespace std;
#include <bits/stdc++.h>
#include <math.h>
#include <cstdlib>
#include <stdio.h>
#include <cstring>

int main(){
    const int maxbits = 1024;
    char ch_x[maxbits];
    char ch_y[maxbits];
    scanf("%s",&ch_x);
    scanf("%s",&ch_y);
    int ch_x_length = strlen(ch_x);
    int ch_y_length = strlen(ch_y);
    int bits = align(ch_x,ch_y,ch_x_length,ch_y_length);//补位
    int* x = (int *)malloc((maxbits*2+1)*sizeof(int));
    int* y = (int *)malloc((maxbits*2+1)*sizeof(int));
    int* addxy = (int *)malloc((maxbits*4+1)*sizeof(int));
    int* subxy = (int *)malloc((maxbits*4+1)*sizeof(int));
    int* result = (int *)malloc((maxbits*8+1)*sizeof(int));
    x[0] = bits;//默认输入的都是正整数
    y[0] = bits;//默认输入的都是正整数
    for(int i = 0;i<bits;++i){ //逆序存储 方便进位
        x[bits-i] = ch_x[i] - '0';
        y[bits-i] = ch_y[i] - '0';
    }
    Multify(x,y,result,bits); //调用函数
    //打印实现
    cout<<"结果:";
    int flag = 0;
    for(int i = abs(result[0]);i>=1;--i){
        if(result[i]!=0){
            flag = i;
            break;
        }
    }
    for(int i = flag;i>=1;--i)
        cout<<result[i];
    return 0;
}

09. 测试结果

1234567890123
1234567890123
结果:1524157875322755800955129
Process returned 0 (0x0)   execution time : 52.699 s
Press any key to continue.

10. 复杂度分析

在这里插入图片描述

在这里插入图片描述

——————END-2022-04-26——————

苡荏
关注
  • 5
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
大整数乘法
m0_52048415的博客
03-18 925
文章目录大整数乘法Karatsuba乘法求解步骤：1.首先是理想化的情况，两个大整数的位数相同2.在非理想化的情况，两个大整数的位数不同 大整数乘法 这里记录一下karatsuba分治算法的方法 （现阶段只写了在long long int范围内的程序） 有关karatsuba算法的知识移步查看<karatsuba - DGSO百科)> karatsuba算法即为将大整数分为两部分后分别计算，以此来减少程序的时间复杂度 可以将X,Y,分开来计算，同时对于AD+BC 可以采用已经计算过的AC,
分治法——大整数相乘
qq_36165148的博客
07-22 3万+
大整数相乘：A、B两个整数，A有n位（123456……n），B有m位（123456……m），一般的思路是像最初学习乘法时一样逐位相乘后相加，但是这样做算法的复杂度过高，但这仍然是解题的基本思想。 既然提到分治，那么如何分，怎么治？ 分： 能够找到一个大问题划分为小问题方法的重要技巧是能够看到大问题的规模和所谓规模的单位。在大整数相乘中大问题的规模就是一个n位的整数要乘以一个m位的整数，所谓规...
大整数乘法算法
Royce Wang专栏
07-11 3万+
一 转换为二进制求，推导出的公式适合十进制计算 设X和Y都是n位的二进制整数，现在要计算它们的乘积XY。我们可以用小学所学的方法来设计一个计算乘积XY的算法，但是这样做计算步骤太多，显得效率较低。如果将每2个1位数的乘法或加法看作一步运算，那么这种方法要作O(n2)步运算才能求出乘积XY。下面我们用分治法来设计一个更有效的大整数乘积算法。 　 图6-3 大整数X和Y的分段
分治算法解大整数相乘问题
qq_39545674的博客
11-15 2053
1 问题 有两个n位大整数XXX，YYY，它们数值之分大，如1e10001e10001e1000。现在要计算它们的乘积XYXYXY。 2 分析 2.1 传统方法 逐位相乘、错位相加，时间复杂度O(n2)O(n^2)O(n2)。效率太低。 2.2 分治方法 将n位的二进制整数X和Y各分为2段，每段的长为n/2位（为简单起见，假设n是2的幂）。此处整数用2进制表示。 X=a2n2+bY=c2n2+d X=a2^{\frac{n}{2}}+b\\ Y=c2^{\frac{n}{2}}+d X=a22n​+bY=
大整数的乘法（分治法）
weixin_44469806的博客
09-24 1万+
通常执行一次加法或乘法运算所需的计算时间看作一个仅取决于计算机硬件处理速度的常数。这个仅在参加运算的整数能在计算机硬件对整数的表示范围内直接处理才是合理的。若要精确地表示大整数并在计算结果中要求精确得到所有位数上的数字，就必须用软件的方法来实现大整数的算术运算。 问题描述：假设有两个大整数X、Y，分别设X=1234、Y=6789。现在要求X*Y的乘积，小学的算法就是把X与Y中的每一项去乘，但是这样的乘法所需的时间复杂度为O(N^2)，(因为每一位要逐个去乘)，所以效率比较低下。那我们可以采用分治的算法，将X
大整数乘法的详解
笼中鸟
11-29 3万+
一.问题 由于编程语言提供的基本数值数据类型表示的数值范围有限，不能满足较大规模的高精度数值计算，因此需要利用其他方法实现高精度数值的计算，于是产生了大数运算。尤其是乘法运算，下面就是大整数的乘法的过程（加 减法都一样的原理）。 二.解决问题的方法 方法一（传统的相乘逐步相加） 乘法规律，一个数的第i位和另一个数的第j位相乘，一定会累加到结果的第i+j位，结果的数组一个数组元素存2位数，最后对结果整除得到进位，mod得到余数就是i+j位的数字，最后打印出来。 对于大整数比较方便的输入方法是，.
分治法求大数乘法
crazy123snail的专栏
08-14 1650
摘要： 乘法主要有3种方法：1、模拟竖式计算法复杂度O（ N 2次方）；2、分治法，最优O（N 1.58次方）；3、傅里叶变换法FFT。其中竖式计算法占物理空间小，思维简单；分治法复杂度有所降低，旨在以加法代替乘法，减少乘法次数。FFT法效率最高，有待研究。 本文针对分治，给出递归分解为两段的乘法的求解，JAVA语言实现。在实际应用中，数字长度超600时分治法的优越才能够体现，但
探索分治算法：解决复杂问题的有效策略
m0_73731708的博客
06-30 849
该算法将问题分解为更小、更易解决的子问题，然后通过合并子问题的解来得到原问题的解。通过将原问题划分为规模较小的子问题，递归地解决每个子问题，并将子问题的解合并为原问题的解，我们能够高效地解决复杂问题。归并排序（Merge Sort）是一种常用的排序算法，它利用分治算法的思想来将一个待排序的数组分成两个相等大小的子数组，然后递归地对子数组进行排序，并最后将两个有序子数组合并为一个有序数组。分治算法的核心思想是将一个复杂的问题划分为可解决的小问题，然后通过递归地求解这些小问题，最后将其结果合并为原问题的解。
分治法的经典问题——大整数相乘
热门推荐
刘剑峰的博客
12-03 7万+
分治法的原理讨论问题时，先来了解一下什么是分治法。 分治法的意思就是，分而治之，也就是把一个问题，拆分成几个小问题，最后再汇总解决的方法 通过大整数相乘问题来了解分治法假如现在我们要求两个大整数相乘的乘积，如1234 * 1234（这里为了了分析简便，所以不举形如1234567891234567这样的大整数，不必要在此纠结），那么按照我们小学学的乘法，就是用乘数的每一项去和1234相乘，这样很明
分治法解决大整数乘法问题.docx
04-07
分治法解决大整数乘法问题.docx
大整数乘法分治算法实现
03-25
利用字符串和分治法来实现大整数乘法，内含c++源代码和实验报告说明
large_integer.rar_分治法_大整数乘法
09-22
VC++ 分治法大整数乘法
算法分析与设计实验报告-分治法.docx
09-12
算法分析与设计实验报告-分治法（免积分下载）
用分治法实现两个二进制数的大整数乘法（带界面）
10-31
大整数分解问题：给定两个n位长二进制数x和y，求这两个数的乘积。时间复杂性控制在Θ(n1.6)
笔试强训-day17_T2 十字爆破
weixin_46186903的博客
05-03 453
模拟即可，但是由于数据量过⼤，我们可以提前把每⼀⾏以及每⼀列的和存起来，⽅便统计总和。解法二：提前把每⼀⾏以及每⼀列的和存起来，然后输入输出使用快速的IO方式，解答如下所示。解法一：暴力遍历，这种方法很容易想到，并且也容易编写出代码，但是会超时。因为1+2+3=6，1+2+4=7，1+3+4=8，2+3+4=9。牛牛选择一个方格，可以得到和这个方格同行、同列的所有数之和的得分。现在牛牛想知道下一步选择每个格子的得分情况，你可以帮帮他吗？m个方格，每个方格中有一个整数。
Python机器学习项目开发实战：在数据分析竞赛平台遴选最佳算法模型
最新发布
一个好知识的传播者
05-03 947
在Python机器学习项目开发实战中，数据分析竞赛平台为我们提供了一个实践和验证算法模型性能的理想场所。在这些平台上，参赛者需要面对各种真实世界的数据集，通过选择和应用合适的算法模型，来解决各种复杂的数据分析问题。下面将详细阐述如何在数据分析竞赛平台上遴选最佳的算法模型。
leetcode16-3Sum Closest
我的程序人生
04-29 304
这道题目和那道3Num的题目很类似，解题思路也是类似的，我们先对数组排序，然后固定一个元素，通过双指针遍历剩下的元素，用一个哨兵记录三个元素的和与target的diff，分别处理三个元素的和小于target，大于target，等于target这三种情况即可。请你从 nums 中选出三个整数，使它们的和与 target 最接近。解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2)。输入：nums = [-1,2,1,-4], target = 1。假定每组输入只存在恰好一个解。
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真
熟悉MATLAB/fpga/RK3588/LABVIEW/protus/单片机/dsp/Multisim
04-30 637
基于模糊PI控制算法的龙格库塔CSTR模型控制系统simulink建模与仿真。基于模糊PI控制算法的龙格-库塔（Runge-Kutta, RK）连续搅拌釜反应器（Continuous Stirred Tank Reactor, CSTR）模型控制系统，是将模糊控制理论与经典的数值积分方法相结合的一种先进控制策略。模糊控制是一种基于模糊集合理论和语言变量的控制方法，适用于非线性、时变系统的控制。
分治法大整数乘法c语言代码
09-14
分治法是一种算法设计策略，通过将问题分解成更小的子问题，再通过将解合并起来来解决原始问题。在大整数乘法问题中，可以使用分治法来提高算法效率。 下面是一个使用C语言编写的分治法大整数乘法的代码示例： #include <stdio.h> #include <math.h> long long int power(int a, int b) { if (b == 0) { return 1; } else { return a * power(a, b - 1); } } long long int multiply(long long int x, long long int y) { int n; if (x < 10 || y < 10) { return x * y; } n = fmax(log10(x) + 1, log10(y) + 1); int m = ceil(n / 2.0); long long int a = x / power(10, m); long long int b = x % power(10, m); long long int c = y / power(10, m); long long int d = y % power(10, m); long long int ac = multiply(a, c); long long int bd = multiply(b, d); long long int ad_bc = multiply(a + b, c + d) - ac - bd; return ac * power(10, 2 * m) + ad_bc * power(10, m) + bd; } int main() { long long int x, y; printf("请输入两个整数："); scanf("%lld %lld", &x, &y); long long int result = multiply(x, y); printf("两数乘积为：%lld\n", result); return 0; } 在这个代码示例中，使用了递归来实现分治法的思想。首先判断输入的两个数是否小于10，如果是，则直接返回乘积。如果不是，则计算出这两个数的位数n，然后取n的一半向上取整得到m。分别将两个数的高位和低位等分为a、b、c、d四部分。 接着，使用递归调用multiply函数来计算ac、bd和ad_bc三个结果，最后将这三个结果按照指定的规则相加得到最终的乘积。 通过使用分治法，可以显著提高大整数乘法的效率。因为将问题分解成更小的子问题，每个子问题处理的数据规模更小，计算量相对减少，从而提高了算法的效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

苡荏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值