[复习]高精度算法

今天又复习了一下高精度（高精度减、加、乘）

仍然用结构体来存储

数据结构：

typedef struct HP{

         int w[10001]             //储存数据，0下标储存有多少位

}HP；

注意：高精度为了进位需要反着存储

例如：原数             a     123   -int

       高精度数          b       3 |2|1 –int[]

1. 加法

先将最大的位数+1，然后按位相加，每次加完进位，最后删除前导0

1. 减法

和高精度加法类似，相当于就是加上一个负数，只是需要借位

在之前需要预处理一下，一定保证用大数减小数

1. 乘法

虽然复习的是高精度乘单精度，但是我还是觉得直接用高精度乘比较简单

例如下面这个竖式：

       1    2    3

  ×         1    2

-------------------------

       2    4    6

  1    2    3

------------------------

  1    4    7    6

我们可以发现当HP a与HP b相乘时，a[i]*b[j]得到的是（i + j - 1）位上的数

下面附上源代码：

/*

 * [输入文件] hp.in

 * 共三行

 * 第一行和第二行是两个高精度数

 * 第三行是一个符号（+ -或*）

 * [输出文件] hp.out

 * 仅一行，运算的结果

 */

#include<iostream>

#include<string>

#include<cstring>

#include<cstdio>

using namespace std;

FILE *fp;

#ifndef _HPDEF_H_

#define _HPDEF_H_

typedef int HPI;

//高精度类

typedef struct

{

      int w[10005];    

}HP;

#endif

#ifndef _HP_H_

#define _HP_H_

//带成员函数的hp类

class hp{

      public:

      static HP hps(string str);

      static HP add(HP *p1,HP *p2);

      static HPI cmp(HP *p1,HP *p2);

      static HP rem(HP *p1,HP *p2);

      static void fout(HP *p);

      static HP chen(HP *p1,HP *p2);

}hp;

/**

 * 将字符串转化成高精度数

 * @param str 要转化的字符串

 * @return 转化后的高精度数

 */

HP hp::hps(string str)

{

      HP h;

      memset(h.w,0,sizeof(h.w));

      h.w[0]=str.size();

      for(int i=h.w[0];i>=1;i--){

           h.w[i]=str[(h.w[0]-i)]-'0';

      }

      return h;

}

/**

 * 将两个高精度数相加

 * @param p1 第一个高精度数的地址

 * @param p2 第二个高精度数的地址

 * @return 计算的结果

 */

HP hp::add(HP *p1,HP *p2)

{

      HP p;

      memset(p.w,0,sizeof(p.w));

      if(p1->w[0]>p2->w[0]) p.w[0]=p1->w[0];

      else p.w[0]=p2->w[0];

      for(int i=1;i<=p.w[0];i++){

           p.w[i]+=p1->w[i]+p2->w[i];

           p.w[i+1]+=p.w[i]/10;

           p.w[i]%=10;

      }

      p.w[0]+=2;

      while(p.w[0]>1&&p.w[p.w[0]]==0) p.w[0]--;

      return p;

}

/**

 * 比较两个高精度数的大小

 * @param p1 第一个高精度数的地址

 * @param p2 第二个高精度数的地址

 * @return 当*p1大于*p2时，返回1，<br>

 *           当*p1小于*p2时，返回-1，<br>

 *         否则返回0

 */ 

HPI hp::cmp(HP *p1,HP *p2){

      if(p1->w[0]>p2->w[0]) return 1;

      else if(p1->w[0]<p2->w[0]) return -1;

      for(int i=p1->w[0];i>=1;i--){

           if(p1->w[i]>p2->w[i])

                 return 1;

           else if(p1->w[i]<p2->w[i])

                 return -1;

      }

      return 0;

}

/**

 * 将高精度数输出到文件流fp中

 * @param p 要输出的高精度数的地址

 */

void hp::fout(HP *p){

      for(int i=p->w[0];i>=1;i--)

      fprintf(fp,"%d",p->w[i]);

}

/**

 * 将两个高精度数相减

 * @param p1 被减高精度数的地址

 * @param p2 减高精度数的地址

 * @return 计算的结果

 */

HP hp::rem(HP *p1,HP *p2){

      HP p;

      memset(p.w,0,sizeof(p.w));

      p.w[0]=p1->w[0];

      for(int i=1;i<=p.w[0];i++){

           if(p1->w[i]<p2->w[i]){

                 p1->w[i]+=10;

                 p1->w[i+1]--;

           }

           p.w[i]=p1->w[i]-p2->w[i];

      }

      while(p.w[0]>1&&p.w[p.w[0]]==0) p.w[0]--;

      return p;

}

/**

 * 将两个高精度数相乘

 * @param p1 第一个高精度数的地址

 * @param p2 第二个高精度数的地址

 * @return 计算的结果

 */

HP hp::chen(HP *p1,HP *p2){

      HP p;

      memset(p.w,0,sizeof(p.w));

      p.w[0]=p1->w[0]+p2->w[0];

      for(int i=1;i<=p1->w[0];i++){

           for(int j=1;j<=p2->w[0];j++){

                 p.w[i+j-1]+=p1->w[i]*p2->w[j];

                 p.w[i+j]+=p.w[i+j-1]/10;

                 p.w[i+j-1]%=10;

           }

      }

      p.w[0]+=2;

      while(p.w[0]>1&&p.w[p.w[0]]==0) p.w[0]--;

      return p;

}

#endif

int main(int argc,char* argv[])

{

      freopen("gjc1.in","r",stdin);

      fp=fopen("gjc1.out","w");

      //局部变量定义

      string str1,str2;

      HP hp1,hp2,hp3;

      char fu;

      cin>>str1>>str2>>fu;

      //转化字符串

      hp1=hp::hps(str1);

      hp2=hp::hps(str2);

      fu = '*';

      //计算

      switch(fu){

           case '+':

                 hp3=hp::add(&hp1,&hp2);

                 break;

           case '-':

                 switch(hp::cmp(&hp1,&hp2)){

                      case 1:

                            hp3=hp::rem(&hp1,&hp2);

                            break;

                      case 0:

                            fprintf(fp,"0");

                            return 0;

                      case -1:

                            hp3=hp::rem(&hp2,&hp1);

                            fprintf(fp,"-");

                            break;

                 }

                 break;

            case '*':

                 hp3=hp::chen(&hp1,&hp2);

                 break;

      }

      hp::fout(&hp3);

      return 0;

}