大数乘法　分治法

2019年3月24日 118次阅读 来源: 大整数乘法问题
  1. #include<stdio.h>
  2. #include<memory.h>
  3. #include<math.h>
  4. #include<assert.h>
  5. #include<string.h>
  6. #include<malloc.h>
  7. #include<time.h>
  8. int max(int x,int y)
  9. {
  10.     return x>y?x:y;
  11. }
  12. typedef struct
  13. {
  14.     int *NumHead;
  15.     int size;
  16. }BigNumber;
  17. const size_t BigSize=sizeof(BigNumber);
  18. /*********************************************************************************/
  19. /*******************                                  思想                     **********************/
  20. /*               int n=31*log2    即表示一个int型整数表示成十进制需要n位,n计算得9                                  */
  21. /*              因此,可设进制为10^9,但因为base^2<=10^9,所以BigBase=10^4
  22.                  输出时转换成十进制在每个元素后面加相应位数的0即可                              */
  23. /********************************************************************************/
  24. const int BigBase = 10000;
  25. const int PerBitLen = 4;
  26. /*  (1+x+x^2+x^3+…+x^(n-2)+x^(n-1))^2多项式乘法,系统最大项为x^(n-1)项,最大系数为n,而如果原来每一项前面都是BigBase,那么最大系数就变成
  27. BigBase*BigBase*n了,最大系数可以用2^64存储,若要保证n足够大,就要缩小BigBase
  28. */
  29. BigNumber *add(BigNumber *a,BigNumber *b,int offset)//可通过偏移来计算各种加法,O(N)
  30. {
  31.     int nsize=a->size;
  32.     char mark=-1;
  33.     BigNumber *result=(BigNumber *)malloc(BigSize);
  34.     if(offset==0)
  35.     {
  36.         if(a->size>b->size)
  37.         {
  38.             nsize=a->size;
  39.             {
  40.                 BigNumber *newb=(BigNumber *)malloc(BigSize);
  41.                 newb->NumHead=(int *)malloc(4*nsize);
  42.                 newb->size=nsize;
  43.                 memset(newb->NumHead,0,4*(nsize-b->size));
  44.                 memcpy(newb->NumHead+nsize-b->size,b->NumHead,4*b->size);
  45.                 b=newb;
  46.             }
  47.             mark=1;
  48.         }
  49.         else if(a->size<b->size)
  50.         {
  51.             nsize=b->size;
  52.             {
  53.                 BigNumber *newa=(BigNumber *)malloc(BigSize);
  54.                 newa->NumHead=(int *)malloc(4*nsize);
  55.                 newa->size=nsize;
  56.                 memset(newa->NumHead,0,4*(nsize-b->size));
  57.                 memcpy(newa->NumHead+nsize-a->size,a->NumHead,a->size*4);
  58.                 a=newa;
  59.             }
  60.             mark=0;
  61.         }
  62.     }
  63.     else
  64.     {
  65.         if(a->size+offset>b->size)
  66.         {
  67.             nsize=a->size+offset;
  68.             {
  69.                 BigNumber *newa=(BigNumber *)malloc(BigSize);
  70.                 BigNumber *newb=(BigNumber *)malloc(BigSize);
  71.                 newb->NumHead=(int *)malloc(4*nsize);
  72.                 newb->size=nsize;
  73.                 memset(newb->NumHead,0,4*(nsize-b->size));
  74.                 memcpy(newb->NumHead+nsize-b->size,b->NumHead,4*b->size);
  75.                 b=newb;
  76.                 newa->NumHead=(int *)malloc(4*nsize);
  77.                 newa->size=nsize;
  78.                 memset(newa->NumHead+a->size,0,4*offset);
  79.                 memcpy(newa->NumHead,a->NumHead,a->size*4);
  80.                 a=newa;
  81.             }
  82.             mark=2;
  83.         }
  84.         else if(a->size+offset<=b->size)
  85.         {
  86.             nsize=b->size;
  87.             {
  88.                 BigNumber *newa=(BigNumber *)malloc(BigSize);
  89.                 newa->NumHead=(int *)malloc(4*nsize);
  90.                 newa->size=nsize;
  91.                 memset(newa->NumHead,0,4*nsize);
  92.                 memcpy(newa->NumHead+nsize-a->size-offset,a->NumHead,a->size*4);
  93.                 a=newa;
  94.             }
  95.             mark=0;
  96.         }
  97.     }
  98.     
  99.     result->NumHead=(int *)malloc(4*nsize);
  100.     result->size=nsize;
  101.     while(–nsize>=0)
  102.         result->NumHead[nsize]=a->NumHead[nsize]+b->NumHead[nsize];
  103.     if(mark==0)
  104.     {
  105.         free(a->NumHead);
  106.         free(a);
  107.     }
  108.     else if(mark==1)
  109.     {
  110.         free(b->NumHead);
  111.         free(b);
  112.     }
  113.     else if(mark==2)
  114.     {
  115.         free(a->NumHead);
  116.         free(b->NumHead);
  117.         free(a);
  118.         free(b);
  119.     }
  120.     
  121.     return result;
  122. }
  123. BigNumber *Merge(BigNumber * front,BigNumber * last,BigNumber * middle,int halfn)//整合函数 O(N)
  124. {
  125.     int i;
  126.     int carry=0,borrow=0;
  127.     BigNumber *mid=add(add(front,middle,0),last,0);//2次内存申请与释放
  128.     BigNumber *nonperfect=add(add(front,mid,halfn),last,halfn);//2
  129.     BigNumber *result=(BigNumber *)malloc(BigSize);
  131.     result->size=nonperfect->size+1;
  132.     result->NumHead=(int *)malloc(4*nonperfect->size+4);//1
  133.     result->NumHead[0]=0;
  134.     memcpy(result->NumHead+1,nonperfect->NumHead,4*nonperfect->size);
  135.     
  136.     for(i=nonperfect->size;i>=0;–i)
  137.     {
  138.         int temp;
  139.         result->NumHead[i]+=carry;
  140.         result->NumHead[i]-=borrow;
  141.         if((temp=result->NumHead[i])>=0)
  142.         {
  143.             carry=temp/BigBase;//进位
  144.             result->NumHead[i]=temp%BigBase;//余位
  145.             borrow=0;
  146.         }
  147.         else
  148.         {
  149.             carry=0;
  150.             if((-result->NumHead[i])%BigBase==0)
  151.             {
  152.                 borrow=(-result->NumHead[i])/BigBase;
  153.                 result->NumHead[i]=0;
  154.             }
  155.             else if(i!=0)//最高位无处借位
  156.             {
  157.                 borrow=(-result->NumHead[i])/BigBase+1;
  158.                 result->NumHead[i]+=borrow*BigBase;
  159.             }
  160.         }
  161.     }
  162.         
  163.     free(front->NumHead);
  164.     free(middle->NumHead);
  165.     free(last->NumHead);
  166.     free(mid->NumHead);
  167.     free(nonperfect->NumHead);
  168.     free(front);
  169.     free(middle);
  170.     free(last);
  171.     free(mid);
  172.     free(nonperfect);
  174.     if(result->NumHead[0]==0)
  175.     {
  176.         memcpy(result->NumHead,result->NumHead+1,(result->size-1)*4);
  177.         result->size–;
  178.     }
  179.     return result;
  180. }
  181. BigNumber * sub(BigNumber *a,BigNumber *b)//差函数，不考虑借位与进位，O(N)，2次内存释放与申请
  182. {
  183.     int nsize=a->size;
  184.     char mark=0;
  185.     BigNumber *diff=(BigNumber *)malloc(BigSize);
  186.     if(a->size>b->size)
  187.     {
  188.         BigNumber *c=(BigNumber *)malloc(BigSize);
  189.         c->NumHead=(int *)malloc(4*a->size);
  190.         c->size=a->size;
  191.         memset(c->NumHead,0,4*(a->size-b->size));
  192.         memcpy(c->NumHead+a->size-b->size,b->NumHead,4*b->size);
  193.         b=c;
  194.         nsize=a->size;
  195.         mark=1;
  196.     }
  197.     else if(b->size>a->size)
  198.     {
  199.         BigNumber *c=(BigNumber *)malloc(BigSize);
  200.         c->NumHead=(int *)malloc(4*b->size);
  201.         c->size=b->size;
  202.         memset(c->NumHead,0,4*(b->size-a->size));
  203.         memcpy(c->NumHead+b->size-a->size,a->NumHead,4*a->size);
  204.         a=c;
  205.         nsize=b->size;
  206.         mark=-1;
  207.     }
  209.     diff->NumHead=(int *)malloc(nsize*4);
  210.     diff->size=nsize;
  211.     while(–nsize>=0)
  212.         diff->NumHead[nsize]=a->NumHead[nsize]-b->NumHead[nsize];
  213.     if(mark==-1)
  214.     {
  215.         free(a->NumHead);
  216.         free(a);
  217.     }
  218.     else if(mark==1)
  219.     {
  220.         free(b->NumHead);
  221.         free(b);
  222.     }
  223.     
  224.     return diff;
  225. }
  226. BigNumber *Mutiply(BigNumber *a,BigNumber *b)//
  227. {
  228.     int nsize=max(a->size,b->size);
  229.         
  230.     if(a->size!=nsize)
  231.     {
  232.         BigNumber *c=(BigNumber *)malloc(BigSize);
  233.         c->NumHead=(int *)malloc(4*nsize);
  234.         c->size=nsize;
  235.         memset(c->NumHead,0,4*(nsize-a->size));
  236.         memcpy(c->NumHead+nsize-a->size,a->NumHead,4*a->size);
  237.         free(a->NumHead);
  238.         free(a);
  239.         a=c;
  240.     }
  241.     if(b->size!=nsize)
  242.     {
  243.         BigNumber *c=(BigNumber *)malloc(BigSize);
  244.         c->NumHead=(int *)malloc(4*nsize);
  245.         c->size=nsize;
  246.         memset(c->NumHead,0,4*nsize);
  247.         memcpy(c->NumHead+nsize-b->size,b->NumHead,4*b->size);
  248.         free(b->NumHead);
  249.         free(b);
  250.         b=c;
  251.     }
  252.     //对齐并变双
  253.     
  254.     if(nsize==1)
  255.     {
  256.         BigNumber *result=(BigNumber *)malloc(BigSize);
  257.         long long temp=(long long)(a->NumHead[0])*(long long)(b->NumHead[0]);
  259.         if(temp/BigBase==0)
  260.         {
  261.             result->NumHead=(int *)malloc(4);
  262.             result->NumHead[0]=(int)temp;
  263.             result->size=1;
  264.         }
  265.         else
  266.         {
  267.             result->NumHead=(int *)malloc(8);
  268.             result->NumHead[1]=(int)(temp%BigBase);
  269.             result->NumHead[0]=(int)(temp/BigBase);
  270.             result->size=2;
  271.         }
  272.         
  273.         free(a->NumHead);
  274.         free(b->NumHead);
  275.         free(a);
  276.         free(b);
  277.         
  278.         return result;
  279.     }
  280.     else
  281.     {
  282.         int left=nsize/2;
  283.         int right=nsize-left;
  284.         
  285.         BigNumber *a1=(BigNumber *)malloc(BigSize);
  286.         BigNumber *a2=(BigNumber *)malloc(BigSize);
  287.         BigNumber *b1=(BigNumber *)malloc(BigSize);
  288.         BigNumber *b2=(BigNumber *)malloc(BigSize);
  289.         
  290.         a1->size=b1->size=left;
  291.         a2->size=b2->size=right;
  292.         a1->NumHead=(int *)malloc(4*left);
  293.         b1->NumHead=(int *)malloc(4*left);
  294.         a2->NumHead=(int *)malloc(4*right);
  295.         b2->NumHead=(int *)malloc(4*right);
  297.         memcpy(a1->NumHead,a->NumHead,4*left);
  298.         memcpy(b1->NumHead,b->NumHead,4*left);
  299.         memcpy(a2->NumHead,a->NumHead+left,4*right);
  300.         memcpy(b2->NumHead,b->NumHead+left,4*right);
  302.         free(a->NumHead);
  303.         free(b->NumHead);
  304.         free(a);
  305.         free(b);
  306.         nsize=nsize%2!=0?nsize+1:nsize;
  307.         return Merge(Mutiply(a1,b1),Mutiply(a2,b2),Mutiply(sub(a2,a1),sub(b1,b2)),nsize/2);
  308.     }
  309. }
  310. /////////////////////////////////初始化/////////////////////////////////////
  311. BigNumber *Int_BigInit(int tar)
  312. {
  313.     int bitlen=(int)log10((long double)tar)/PerBitLen+1;
  314.     BigNumber *Big=(BigNumber *)malloc(BigSize);
  315.     Big->NumHead=(int *)malloc(4*bitlen);
  316.     assert(Big!=NULL);
  317.     Big->size=bitlen;
  318.     //memset(Big->NumHead,0,4*(bitlen));
  319.     while(–bitlen>=0)
  320.     {
  321.         Big->NumHead[bitlen]=tar%BigBase;
  322.         tar/=BigBase;
  323.     }
  324.     return Big;
  325. }
  326. int BaseChange(char *str,int low,int up)
  327. {
  328.     int i=up;
  329.     int sum=0;
  330.     
  331.     for(;i>=low;–i)
  332.     {
  333.         if(str[i]==‘0’)continue;
  334.         if(str[i]<‘0’||str[i]>‘9’)return -1;
  335.         sum+=(str[i]-‘0’)*((int)pow((double)10,(double)up-i));
  336.     }
  338.     return sum;
  339. }
  340. BigNumber *Str_BigInit(char * str)
  341. {
  342.     int strlenth,bitlen;
  343.     int i=0,k=0;
  344.     BigNumber *Big;
  346.     assert(str!=NULL);
  347.     while(*str++==‘0’);
  348.     strlenth=strlen(–str);
  349.     bitlen=strlenth/PerBitLen;
  350.     /*strlenth–;
  351.     bitlen–;*/
  352.     if(strlenth%PerBitLen!=0)
  353.         ++bitlen;
  354.     Big=(BigNumber *)malloc(BigSize);
  355.     Big->NumHead=(int *)malloc(4*(bitlen));
  356.     //memset(Big->NumHead,0,4*(len+1));
  357.     Big->size=bitlen;
  358.     assert(Big->NumHead!=NULL);
  359.     for(;bitlen>0;–bitlen,strlenth-=PerBitLen)
  360.     {
  361.         int max= strlenth-1;
  362.         int min=strlenth-PerBitLen;
  363.         min=min<0?0:min;
  364.         Big->NumHead[bitlen-1]=BaseChange(str,min,max);
  365.     }
  366.     return Big;
  367. }
  369. /////////////////////////////////////////////////////////////////////////////
  370. void BigPrint(BigNumber * result,FILE *fp)
  371. {
  372.     int i=0;
  373.     assert(result!=NULL&&result->NumHead!=NULL);
  374.     while(result->NumHead[i++]==0);
  375.     fprintf(fp,“%d”,result->NumHead[i++]);
  376.     for(;i<result->size;++i)
  377.     {
  379.         fprintf(fp,“%04d”,result->NumHead[i]);
  380.         //fprintf(fp,”%01d”,result->NumHead[i]);
  381.     }
  382.     fprintf(fp,“/n”);
  383. }
  384. BigNumber * Factorial(int n)//测试阶乘
  385. {
  386.     if(n==0||n==1)
  387.         return Int_BigInit(n);
  388.     else return Mutiply(Int_BigInit(n),Factorial(n-1));
  389. }
  390. int main()
  391. {
  392.     //printf(“%d”,sizeof(long long));
  393.     int i=0;
  394.     clock_t start, finish; 
  395.     //fscanf(stdin,”%d”,&i);
  396.     start=clock();
  397.     BigPrint(Mutiply(Str_BigInit(“99912344444445384759347523452”),Str_BigInit(“11345623453452345235”)),stdout);
  398.     finish=clock();
  399.     printf(“用时 %lf 秒/n”,(double)(finish – start) / CLOCKS_PER_SEC);
  400.     //BigPrint(BigMutiply(Str_BigInit(“479001600”),Int_BigInit(13)),stdout);
  401.     return 0;
  402. }
  403. //程序频繁的申请与释放内存是个缺点，乘法复杂度为O(N 1.59),
    原文作者：大整数乘法问题
    原文地址: https://blog.csdn.net/fuchuangbob/article/details/3220156
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞