重点：

• 高精度数的读入与输出
• 高精度数的加减乘除
• 进一步熟悉函数的使用（模块化编程的思想）

难点：

• 高精度数的除法
• 高精度计算的优化

为什么要用到高精度计算？

int
long long
double
等进行计算的精度只有十几位，如果要进行数十、百、千、万位的数的计算就要用到高精度计算

高精度计算的基本方法

• 用字符串来读入数据
• 将字符串转为整数数组，该数组的每一个元素对应一位十进制数，下标顺序指明每一位的序号（为了计算对位的方便，一般会进行倒序存储），一般还用其下标0来存储该数的位数，如a[0]，也是为了方便计算和输出等。
• 然后对每一位进行计算，运算规则如同算术运算。
• 输出的时候一般也是倒序（因为存储的时候是倒序的）。

高精度加法

首先观察我们在竖式加法时的做法
str1=“3216”
str2=“999765”

     3216
 + 999765
---------
  1002981

• 对位（将str1的各位6和str2的各位5对齐，倒序存储就是为了对位和计算的方便）
• 从最低位开始依次相加，相加的时候要处理进位
  主程序分为三个模块来处理
• 读数
• 加法处理
• 输出

int main(){
	int a[N],b[N];
	memset(a,0,sizeof(a)); //对a数组进行清零处理，在库<cstring>中
	memset(b,0,sizeof(b));
	Read(a); //读入第一个加数存到a数组中
	Read(b); //读入第一个加数存到b数组中
	Add(a,b); //将a和b加起来，将和存到a数组中
	Out(a); //将和a输出
	return 0;
}

然后分模块去进行分别处理

void Read(int a[]){ //读数模块
	string s;
	cin>>s; //用字符串读入该数
	a[0]=s.size(); //存储该数的长度，也可用a[0]=s.length();
	for(int i=1;i<=a[0];i++)
	  a[i]=s[a[0]-i]-'0'; //i和a[0]-i实现下标的倒序，-‘0’实现字符和整数的转换，注意字符串的下标是从0到a[0]-1，整数数组下标是从a[0]到1
	return ;
}
void Add(int a[],int b[]){//相加模块
	if(a[0]<b[0])a[0]=b[0]; //和存储在a数组中，a[0]要保证能加到两个数的最高位
	for(int i=1;i<=a[0];i++){
		a[i]+=b[i]; //存储和
		a[i+1]+=a[i]/10; //处理进位，将进位加到上一位去
		a[i]%=10; //去掉进位后的数值。处理进位也可以改成if(a[i]>9) a[i+1]++,a[i]-=10;
	}
	if(a[a[0]+1]>0) a[0]++; //如果最高位上有进位，则结果位数要加一位
	return;
}
void Out(int a[]){
	for(int i=a[0];i>0;i--)cout<<a[i]; //倒序输出每一位，有时候需要处理最高位上有0的情况，具体情况再具体处理
	return;
}

练习

• 高精度数+单精度数
  Description
  　　输入两个整数x,y，输出它们的和。
  Input
  　　输入两个整数x,y（0 <= x <= 10^100，0<=y<10 ^9）
  Output
  　　输出它们的和
  Sample Input
  123456789000
  234
  Sample Output
  123456789234
• 高精度加法
  Description
  　　输入两个整数x,y，输出它们的和。
  Input
  　　输入两个整数x,y（0 <= x,y <= 10^100）
  Output
  　　输出它们的和
  Sample Input
  123
  234
  Sample Output
  357
• 1168（注意前导0）
  【题目描述】
  求两个不超过200位的非负整数的和。

【输入】
有两行，每行是一个不超过200位的非负整数，可能有多余的前导0。

【输出】
一行，即相加后的结果。结果里不能有多余的前导0，即如果结果是342，那么就不能输出为0342。

【输入样例】
22222222222222222222
33333333333333333333
【输出样例】
55555555555555555555

• 1309：【例1.6】回文数(Noip1999)
  【题目描述】
  若一个数（首位不为零）从左向右读与从右向左读都是一样，我们就将其称之为回文数。例如：给定一个 10进制数 56，将 56加 65（即把56从右向左读），得到 121是一个回文数。又如，对于10进制数87，

STEP1： 87＋78= 165 STEP2： 165＋561= 726

STEP3： 726＋627＝1353 STEP4：1353+3531=4884

在这里的一步是指进行了一次N进制的加法，上例最少用了4步得到回文数4884。

写一个程序，给定一个N（2＜N＜＝10或N=16）进制数 M．求最少经过几步可以得到回文数。如果在30步以内（包含30步）不可能得到回文数，则输出“Impossible” 。

【输入】
给定一个N（2＜N＜＝10或N=16）进制数M。

【输出】
最少几步。如果在30步以内（包含30步）不可能得到回文数，则输出“Impossible”。

【输入样例】
9 87
【输出样例】
6

• 兔子繁殖问题
  Description
  　　有一对小兔,过一个月之后长成大兔,到第四个月就可以生下一对小兔,并且以后每个月都 生下一对小兔。而所生的一对小兔也同样到一个月之后长成大兔,到第四个月就可以生下一 对小兔,并且以后也每个月都生下一对小兔.假设所有的兔子均不死亡，问第n个月后共有多少对兔子？请设计一个程序，解决这一问题。
  Input
  　　一个正整数n（n <= 5000）
  Output
  　　第n个月后共有多少对兔子
  Sample Input
  5
  Sample Output
  3

解答

• 高精度数+单精度数
  Add模块和main模块有些变化

void Add(int a[],int b){
	a[1]+=b;
	int i=1;
	while(a[i]>9){
		a[i+1]+=a[i]/10;
		a[i]%=10;
		i++;
	}
	if(i>a[0])a[0]=i;
}

int main(){
	int a[N],b;
	memset(a,0,sizeof(a));
	cin>>b;
	Read(a);
	Add(a,b);
	Out(a); 
	return 0;
}

• 高精度加法
  看前面的讲义
• 1168（注意前导0）
  前导0可以在读数的时候处理，嫌麻烦的话直接在输出模块中修改就可以

void Out(int a[]){
	while(a[0]>1&&a[a[0]]==0)a[0]--; //去掉结果数据中前面多余的0
	for(int i=a[0];i>0;i--)cout<<a[i];
	return;
}

• 兔子繁殖问题
  请仔细思考

#include<iostream>
#include<cstdio>
#include<cstring>
#define N 5005
using namespace std;
void Out(int a[]){
	for(int i=a[0];i>0;i--)
		cout<<a[i];
	cout<<endl;
	return;
}
void Copy(int a[],int b[]){
	memset(b,0,sizeof(b));
	for(int i=0;i<=a[0];i++)
		b[i]=a[i];
	return;
}
void Add(int a[],int b[],int c[] ){
	memset(c,0,sizeof(c));
	c[0]=b[0];
	for(int i=1;i<=b[0];i++){
		c[i]+=a[i]+b[i];//要加上进位，c[i]里边存储了进位
		c[i+1]=c[i]/10; //进位
		c[i]%=10;
	}
	if(c[c[0]+1])c[0]++;
	return;
}
int main(){
	int a1[N],a2[N],a3[N],a4[N],n; //a[n]=a[n-1]+a[n-3] 
	memset(a1,0,sizeof(a1));
	memset(a2,0,sizeof(a2));
	memset(a3,0,sizeof(a3));
	memset(a4,0,sizeof(a4));
	a1[0]=a1[1]=a2[0]=a2[1]=a3[0]=a3[1]=1;
	cin>>n;
	for(int i=4;i<=n;i++){
		Add(a1,a3,a4);
		Copy(a2,a1);
		Copy(a3,a2);
		Copy(a4,a3);
	}
	Out(a3);
	return 0;
}

• 1309：【例1.6】回文数(Noip1999)
  见信息奥赛一本通教材
  16进制数在读数的时候要处理一下

if(s[a[0]-i]>='A'&&s[a[0]-i]<='F') a[i]=s[a[0]-i]-'A'+10;//超过十进制的处理方式

回文和反转可以各加一个函数

高精度乘法

高精度乘单精度

单精度数不需要转为数组存储
可以先用高精度数的每一位乘上单精度数，然后再用一个循环来处理进位，这里不可以同加法一样去边乘边处理进位

      999765
 *      3216
-------------
  3215244240

乘法模块中有三个循环

• 第一个循环，高精度数的每一位乘上单精度数
• 第二个循环，处理每一位上的进位
• 第三个循环，处理最高位上的进位

void Mul(int a[],int b){
	for(int i=1;i<=a[0];i++)//单精度数b和高精度数a的每一位相乘
		a[i]*=b;
	for(int i=1;i<=a[0];i++){//处理每一位上的进位
		a[i+1]+=a[i]/10;
		a[i]%=10;
	}	
	while(a[a[0]+1]>0){//最高位上如果有进位则位数a[0]增加后继续处理，可根据情况决定是否要分成一位一位的
		a[0]++;
		a[a[0]+1]=a[a[0]]/10;
		a[a[0]]%=10;
	}
}

练习

• 1170：计算2的N次方（一本通）
  【题目描述】
  任意给定一个正整数N(N≤100)，计算2的n次方的值。

【输入】
输入一个正整数N。

【输出】
输出2的N次方的值。

【输入样例】
5
【输出样例】
32

• 1172：求10000以内n的阶乘
  【题目描述】
  求10000以内n的阶乘。

【输入】
只有一行输入，整数n（0≤n≤10000）。

【输出】
一行，即n!的值。

【输入样例】
4
【输出样例】
24

• 1173：阶乘和
• 【题目描述】
  用高精度计算出S=1!+2!+3!+…+n!（n≤50）,其中“!”表示阶乘，例如：5!=5×4×3×2×1。

输入正整数n，输出计算结果S。

【输入】
一个正整数n。

【输出】
计算结果S。

【输入样例】
5
【输出样例】
153

练习解答

• 1170：计算2的N次方（一本通）
  主模块中修改a[0]a[1]的值为1
  然后使用n次方的循环进行计算，在循环中放入高精乘单精模块

int main(){
	int a[N],n;
	memset (a,0,sizeof (a));
	a[0]=a[1]=1;//累乘要赋初始值为1
	cin>>n;
	for (int i=1; i<=n; i++) Mul(a);//让a连续乘以n个2
	Out(a); 
	return 0;
}

高精乘单精模块中的单精度数一直为2，这样就是2的n次方

void Mul(int a[]){
	for(int i=1;i<=a[0];i++)//每一位乘以2
		a[i]*=2;
	for(int i=1;i<=a[0];i++){//处理进位
		a[i+1]+=a[i]/10;
		a[i]%=10;
	}	
	while(a[a[0]+1]>0){//处理最高位的进位
		a[0]++;
		a[a[0]+1]=a[a[0]]/10;
		a[a[0]]%=10;
	}
}

• 1172：求10000以内n的阶乘
  10000的阶乘位数有30000多位，运算次数达到上亿次，所以会出现超时的情况，需要进行高精度计算的优化
• 高精度计算的优化
  本题的优化比较简单，直接在存储的时候将十进制改成万进制就可以了
  将代码中的10改为10000
• 注意在输出的时候要做相应的调整，除最高位上的每一位都对应的是4位，即便是2位数，如25，在输出的时候要输出为0025
  主模块

int main(){
	int n;
	a[0]=a[1]=1;
	cin>>n;
	for (int i=2; i<=n; i++) Mul(a,i);
	Out(a); 
	return 0;
}

万进制高精度乘单精度

void Mul(int a[],int b){
	for(int i=1;i<=a[0];i++)
		a[i]*=b;
	for(int i=1;i<=a[0];i++){//将10改为10000就形成万进制存储，循环次数大大减少
		a[i+1]+=a[i]/10000;
		a[i]%=10000;
	}	
	while(a[a[0]+1]>0){
		a[0]++;
		a[a[0]+1]=a[a[0]]/10000;
		a[a[0]]%=10000;
	}
}

输出的时候要做相应处理

void Out(int a[]){
	cout<<a[a[0]];//先输出最高位
	for(int i=a[0]-1;i>0;i--) {//其他位不足4位的话前面要用0来占位
		if (a[i]<1000) cout<<0;
		if (a[i]<100) cout<<0;
		if (a[i]<10) cout<<0;
		cout<<a[i];
	}
}

• 1173：阶乘和

高精度乘高精度

       847
 *     295
--------------
      4235
     7623
 +  1694  
--------------
    249865

在纸上写出并仔细分析上面的乘法竖式
因为假设的都是高精度数，只能一位一位来相乘，大致分成以下步骤：

• 一个高精度数上的每一位乘以另一个高精度数上的每一位（双重循环，实际上就是高精度乘单精度）
• 将每一个乘积值进行错位累加（在双重循环内）
• 最后处理累加的这个高精度数的进位

从上面可以看出高精度乘高精度的问题实质为若干个高精度乘单精度之和，即：

• 先高精度*单精度
• 再依次高精度+高精度

#define N 5005
void Mul(int a[],int b[],int c[]){
	int i,j;
	for(i=1;i<=a[0];i++)
		for(j=1;j<=b[0];j++)
			c[i+j-1]+=a[i]*b[j];//用c数组来存储错位累加的和
	c[0]=a[0]+b[0];//位数最多为两个高精度为数之和
	for(i=1;i<=c[0];i++){//处理进位
		c[i+1]+=c[i]/10;
		c[i]%=10;
	}
	while(c[0]>1&&c[c[0]]==0)c[0]--;//处理最高位多余的0，考虑了和0相乘的情况
	return;
}
int main(){
	int a[N],b[N],c[N];
	memset(a,0,sizeof(a));
	memset(b,0,sizeof(b));
	memset(c,0,sizeof(c));
	Read(a);
	Read(b);
	Mul(a,b,c);
	Out(c);
	return 0;
}

请根据代码写出上面竖式乘法进行计算的过程

               847
 *             295
--------------------------
            40    20   35
    72     36+40 63+20 35
16 8+72 14+36+40 63+20 35  
16  80    90       83  35
249865
前面没有多余0

练习

• 1307：【例1.3】高精度乘法
  【题目描述】
  求两个不超过200位的非负整数的积。

【输入】
有两行，每行是一个不超过200位的非负整数，没有多余的前导0。

【输出】
一行，即相乘后的结果。结果里不能有多余的前导0，即如果结果是342，那么就不能输出为0342。

【输入样例】
12345678900
98765432100
【输出样例】
1219326311126352690000

练习解答见讲解

高精度减法

先在纸上书写几个代表性的减法式子并进行分析，提炼出处理模块

     90
  - 215
---------
  - 125

   3100
  - 215
---------
   2885

     190
  -  190
---------
       0

首先要比较两个高精度数的大小
分为三种情况

• a==b相等则输出0
• a>b，计算a-b并输出
• a<b，输出 - 号，计算b-a并输出
  计算的时候存在着向高位借位的情况
  处理差的位数

	927
-	896
-----------
	  1	7-6=1
         3	   12-9=3,借位12
	0	(9-1)-8=0
-----------
	 31

主模块可编写如下：

int main(){
	int a[N],b[N],f;
	memset(a,0,sizeof(a));
	memset(b,0,sizeof(b));
	Read(a);
	Read(b);
	f=Comp(a,b);
	if(f==0){
		cout<<0;
		return 0;
	}
	if(f>0) {
		Minus(a,b);
		Out(a);
	}
	else {
		cout<<'-';
		Minus(b,a);
		Out(b);
	}
	return 0;
}

比较模块

int Comp(int a[],int b[]){//比较a和b的大小关系，若a>b则为1，a<b则为-1,a=b则为0 
     if(a[0]>b[0])return 1;   //a的位数大于b,则a比b大 
     if(a[0]<b[0])return -1;  //a的位数小于b,则a比b小 
     for(int i=a[0];i>0;i--) { //否则a和b的位数相同，则从高位到低位比较 
         if(a[i]>b[i])return 1; 
         if(a[i]<b[i])return -1;
     } 
     return 0;//各位都相等则两数相等。 	
}

减法模块

void Minus(int a[],int b[]){//计算a=a-b
      for(int i=1;i<=a[0];i++){
      	if(a[i]<b[i]){ a[i+1]--;a[i]+=10;} //若不够减则向上借一位 
         a[i]=a[i]-b[i]; 
      } 
      while(a[0]>0&&a[a[0]]==0) a[0]--; //修正a的位数 
      return;
} 

练习

• 1169：大整数减法
  【题目描述】
  求两个大的正整数相减的差。

【输入】
共2行，第1行是被减数a，第2行是减数b(a > b)。每个大整数不超过200位，不会有多余的前导零。

【输出】
一行，即所求的差。

【输入样例】
9999999999999999999999999999999999999
9999999999999
【输出样例】
9999999999999999999999990000000000000

练习解答

• 见讲解

高精度除单精度

在纸上写出除式并进行分析

竖式除法
            36      商
       ---------
12345 √ 452678
        37035	 12345*3=37035
         8232	 45267-37035=8232
         82328	 进行下一位处理
         74070	 12345*6=74070
          8258	 82328-74070=8258 余数

被除数的第一位和除数比较，比它小的话就再加一位，否则就可以计算商和余数，然后再用余数来加一位进行循环处理
实际处理的时候不用比较，小的话商就为0，输出结果的时候将商高位的0去掉就可以
主模块比较简单
读数
相除
输出商和余数

int y;//存储余数
int main(){
	int a[N],c[N],b;
	memset(a,0,sizeof(a));
	memset(c,0,sizeof(c));
	Read(a);
	cin>>b;
	Div(a,b,c);
	cout<<y<<endl;
	Out(c);
	return 0;
}

void Div(int a[],int b,int c[]){
	c[0]=a[0]; //商的位数
	for(int i=a[0];i>0;i--){
		y=y*10+a[i]; //被除数，每次处理一位
		c[i]=y/b; //商
		y%=b; //余数
	}
	while(c[0]>1&&c[c[0]]==0)c[0]--; //去掉高位上多余的0
	return;
}

练习

• 1171：大整数的因子
  【题目描述】
  已知正整数k满足2≤k≤9，现给出长度最大为30位的十进制非负整数c，求所有能整除c的k。

【输入】
一个非负整数c，c的位数≤30。

【输出】
若存在满足 c%k == 0 的k，从小到大输出所有这样的k，相邻两个数之间用单个空格隔开；若没有这样的k，则输出"none"。

【输入样例】
30
【输出样例】
2 3 5 6

• 1175：除以13
  【题目描述】
  输入一个大于0的大整数N，长度不超过100位，要求输出其除以13得到的商和余数。

【输入】
一个大于0的大整数，长度不超过100位。

【输出】
两行，分别为整数除法得到的商和余数。

【输入样例】
2132104848488485
【输出样例】
164008065268345
0

练习解答

• 1171：大整数的因子
  见讲义，简单修改一下主程序即可

	for(int k=2;k<10;k++)
		if(Div(a,k)==0) cout<<k<<' ';

• 1175：除以13
  见讲义，简单修改即可

高精度除高精度

思路：需要转化为减法来进行计算
先在纸上进行分析

两个数均为高精度数的时候，无法使用高精度除以单精度的方法
但在分析的时候，还是可以用两个较小的数来分析
如：a=12346578, b=139, 求 a÷b
在139后面填充0，使其位数与被除数一致，然后看被除数中包含了几个，这个可以用减法来实现
             088824
       ------------------   //tmp=13900000，139后面填充5个0，填充的0的个数为a[0]-b[0]+1
 139  /    12346578 //第一次商为0，Comp(a,tmp)，第二次将139后面的0减少1位
           11120000 //a比tmp大时，循环执行Minus(a,tmp)，直到a<tmp，每减1次，商c[i]++
            1226578 //循环处理
            1112000
             114578
             111200
             003378
               2780
               0598
                556
                 42 //最后剩下的a就是余数

int Comp(int a[],int b[]){
	int i;
	if(a[0]>b[0])return 1;
	if(a[0]<b[0])return -1;
	for(i=a[0];i>0;i--){
		if(a[i]>b[i])return 1;
		if(a[i]<b[i])return -1;
	}
	return 0;
}
void numcopy(int b[],int t[],int i){
	t[0]=b[0]+i-1; //t的位数，全部数字为0
	for(int j=b[0];j>0;j--)
		t[i+j-1]=b[j]; //将t数组的高位全部赋为b数组
}
void Div(int a[],int b[],int c[]){
	int i,j,t[N];
	c[0]=a[0]-b[0]+1;//商的最大位数
	for(i=c[0];i>0;i--){
		memset(t,0,sizeof(t));
		numcopy(b,t,i); //在b后面添加0，每次循环的时候0的个数会减少1，为方便处理，将其拷贝到t数组中。上一句话中已经将t数组全部赋0了，numcpy中只需要将b数组的每一位拷贝到t数组的高位就可以了
		while(Comp(a,t)>=0){//a比t大的时候就统计a中包含了多少个t(个数<10)
			c[i]++; //包含的个数就是第i位上的商
			Minus(a,t);  //标准减法模块
		}
	}
	while(c[0]>0&&c[c[0]]==0)c[0]--;//去掉商高位上多余的0
}
int main(){
	int f,a[N],b[N],c[N];
	memset(a,0,sizeof(a));
	memset(b,0,sizeof(b));
	memset(c,0,sizeof(c));
	Read(a); //标准读数模块
	Read(b);
	f=Comp(a,b);//根据a和b之间的三种大小关系分别处理，比较大小是标准模块
	if(f==0){ //相等则商为1，余数为0
		cout<<1<<endl<<0;
		return 0;
	}
	if(f==-1){ //a<b则商为0，余数为a
		cout<<0<<endl;
		Out(a);
		return 0;
	}
	Div(a,b,c); //a>b时进行高精度除法，c用来存储商，余数最终存在a中
	Out(c);  //标准输出模块
	Out(a);
	return 0;
}

练习

• 1308：【例1.5】高精除
  【题目描述】
  高精除以高精，求它们的商和余数。

【输入】
输入两个低于300位的正整数。

【输出】
输出商和余数。

【输入样例】
1231312318457577687897987642324567864324567876543245671425346756786867867867
1231312318767141738178325678412414124141425346756786867867867
【输出样例】
999999999748590
179780909068307566598992807564736854549985603543237528310337

练习解答

• 1308：【例1.5】高精除
  见讲义

高精度数的优化

如果只是针对加减法的话可以采用亿进制来优化，乘法的话考虑万进制（不超出int或long long的范围）
前面有一个高精度数优化的实例
优化的时候，主要是读数和输出模块上略有变化，其他只需要修改相应的进制基数就可以了

• 读数模块
  123456
  万进制表示为：a[0]=2,a[2]=12,a[1]=3456
  6位变成2位，减少计算次数

void Read(int a[]){ //读数模块
	string s;
	cin>>s;
	int len=s.size(); 
	for(int i=0; i<len; i++)
	   a[(len+3-i)/4]=a[(len+3-i)/4]*10+s[i]-'0'; //(len+3-i)/4，处理每一个万进制位上的值
	a[0]=(len+3)/4; //万进制的位数
	return ;
}

• 输出模块

void Out(int a[]){
	cout<<a[a[0]];//先输出最高位，最高位前面不需要多加0
	for(int i=a[0]-1;i>0;i--){ //除最高位外的其他位都要输出4位（万进制）
		cout<<a[i]/1000;
		cout<<a[i]/100%10;
		cout<<a[i]/10%10;
		cout<<a[i]%10; 
	}

练习

• 高精度乘法
  求a和b的乘积，0<a,b<10^ 20000
  样例输入：
  2
  3
  样例输出：
  6

练习解答

略

综合练习

• 求组合公式C(n,m)的值，C(n,m)=n!/(m!(n-m)!)
  样例输入：
  6 2
  样例输出：
  15
• 奇怪的贸易
  【问题描述】
  刚结束了CS战斗的小D又进入了EVE的游戏世界,在游戏中小D是一名商人,每天要做的事情就是在这里买东西,再运到那里去卖.这次小D来到了陌生的X星,X星上有n种货物,小D决定每种都买走一些,他用ai来表示第i种货物购买的数量,X星人对物品的单价有特别的决定方式.他们首先会选择一个基本价x,第一种物品单价为x,第二种物品单价为x ^ 2,第三种物品单价为x ^ 3……第i种物品单价为x^i.结算总价时,你还需要给他们一笔手续费a0,小D不知道自己带的钱是否能够进行这笔交易,所以请你帮助他计算这笔交易他要支付的总金额是多少.
  【输入文件】
  　　第一行两个数分别表示基准价x (x<=10),物品种数n (n<=100000)
  　　第二行一个数,手续费a0 (a0<=100)
  　　接下来的n行每行一个数,第i行表示第i种物品购买的数量(ai<=100)
  【输出文件】输出结果的最后100位,若不足100位请高位用零补足
  【样例输入】
  2 3
  4
  3
  2
  1
  【样例输出】 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000026

综合练习解答

• 求组合公式C(n,m)的值，C(n,m)=n!/(m!(n-m)!)
  直接根据公式为：高精度乘再加一个高精度除
  也可以做一些变化
• 奇怪的贸易
  高精度乘以单精度，高精度和