拷贝下ps代码，以备不时之需。。
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
using namespace std;
#define MAXN 9999//万进制
#define DLEN 4//4位
class BigNum{
private:
int a[5000];///可以控制大数位数(500*4)
int len;///大数长度
public:
BigNum(){///构造函数
len=1;
memset(a,0,sizeof(a));
}
BigNum(const int);///将int转化为大数
BigNum(const char*);///将字符串转化为大数
BigNum(const BigNum &);///拷贝构造函数
BigNum &operator=(const BigNum &);///重载复制运算符，大数之间赋值
BigNum operator+(const BigNum &)const;///大数+大数
BigNum operator-(const BigNum &)const;///大数-大数
BigNum operator*(const BigNum &)const;///大数*大数
BigNum operator/(const int &)const;///大数/int
BigNum operator^(const int &)const;///幂运算
int operator%(const int &)const;///取模
bool operator>(const BigNum &)const;///大数与大数比较
bool operator>(const int &)const;///大数与int比较
void print();///输出大数
};
BigNum::BigNum(const int b){///将int转化为大数
int c,d=b;
len=0;
memset(a,0,sizeof(a));
while(d>MAXN){
///c=d-(d/(MAXN+1))*(MAXN+1);
c=d%(MAXN+1);///取出后四位
d=d/(MAXN+1);//
a[len++]=c;
}
a[len++]=d;
}
BigNum::BigNum(const char *s){//将字符串转化为大数
int t,k,index,l,i,j;
memset(a,0,sizeof(a));
l=strlen(s);
len=l/DLEN;
if(l%DLEN)++len;
index=0;
for(i=l-1;i>=0;i-=DLEN){
t=0;
k=i-DLEN+1;
if(k<0)k=0;
for(j=k;j<=i;++j)
t=t*10+s[j]-'0';
a[index++]=t;
}
}
BigNum::BigNum(const BigNum &T):len(T.len){//拷贝构造函数
int i;
memset(a,0,sizeof(a));
for(i=0;i<len;++i)
a[i]=T.a[i];
}
BigNum &BigNum::operator=(const BigNum &n){//重载复制运算符，大数之间赋值
int i;
len=n.len;
memset(a,0,sizeof(a));
for(i=0;i<len;++i)
a[i]=n.a[i];
return *this;
}
BigNum BigNum::operator+(const BigNum &T)const{//大数+大数
BigNum t(*this);
int i,big;//位数
big=T.len>len?T.len:len;
for(i=0;i<big;++i){
t.a[i]+=T.a[i];
if(t.a[i]>MAXN){
++t.a[i+1];
t.a[i]-=MAXN+1;
}
}
if(t.a[big]!=0)t.len=big+1;
else t.len=big;
return t;
}
BigNum BigNum::operator-(const BigNum &T)const{//大数-大数
int i,j,big;
bool flag;
BigNum t1,t2;//t1大的，t2小的
if(*this>T){
t1=*this;
t2=T;
flag=0;//前面的大
}
else{
t1=T;
t2=*this;
flag=1;//前面的小
}
big=t1.len;
for(i=0;i<big;++i){
if(t1.a[i]<t2.a[i]){
j=i+1;
while(t1.a[j]==0)++j;
--t1.a[j--];
while(j>i)t1.a[j--]+=MAXN;
t1.a[i]+=MAXN+1-t2.a[i];
}
else t1.a[i]-=t2.a[i];
}
while(t1.a[t1.len-1]==0&&t1.len>1){
--t1.len;
--big;
}
if(flag)t1.a[big-1]=-t1.a[big-1];//前面的小，结果为负
return t1;
}
BigNum BigNum::operator*(const BigNum &T)const{//大数*大数
BigNum ret;
int i,j,up;
int temp,temp1;
for(i=0;i<len;++i){
up=0;
for(j=0;j<T.len;++j){
temp=a[i]*T.a[j]+ret.a[i+j]+up;
if(temp>MAXN){
//temp1=temp-temp/(MAXN+1)*(MAXN+1);
temp1=temp%(MAXN+1);
up=temp/(MAXN+1);
ret.a[i+j]=temp1;
}
else{
up=0;
ret.a[i+j]=temp;
}
}
if(up!=0)ret.a[i+j]=up;
}
ret.len=i+j;
while(ret.a[ret.len-1]==0&&ret.len>1)--ret.len;
return ret;
}
BigNum BigNum::operator/(const int &b)const{//大数/int
BigNum ret;
int i,down=0;
for(i=len-1;i>=0;--i){
ret.a[i]=(a[i]+down*(MAXN+1))/b;
down=a[i]+down*(MAXN+1)-ret.a[i]*b;
}
ret.len=len;
while(ret.a[ret.len-1]==0&&ret.len>1)--ret.len;
return ret;
}
BigNum BigNum::operator^(const int &n)const{//幂运算
BigNum t,ret(1);
int i;
if(n<0)exit(-1);
if(n==0)return 1;
if(n==1)return *this;
int m=n;
while(m>1){
t=*this;
for(i=1;i<<1<=m;i<<=1){
t=t*t;
}
m-=i;
ret=ret*t;
if(m==1)ret=ret*(*this);
}
return ret;
}
int BigNum::operator%(const int &b)const{//取模
int i,d=0;
for(i=len-1;i>=0;--i){
d=((d*(MAXN+1))%b+a[i])%b;
}
return d;
}
bool BigNum::operator>(const BigNum &T)const{//大数与大数比较
int ln;
if(len>T.len)return true;
else if(len==T.len){
ln=len-1;
while(a[ln]==T.a[ln]&&ln>=0)--ln;
if(ln>=0&&a[ln]>T.a[ln])return true;
else return false;
}
else return false;
}
bool BigNum::operator>(const int &t)const{//大数与int比较
BigNum b(t);
return *this>b;
}
void BigNum::print(){//输出大数
int i;
printf("%d",a[len-1]);
for(i=len-2;i>=0;--i){
printf("%.4d",a[i]);//%.4d代表4位，不够前面补0
}
printf("
");
}
int main(){
int n,i;
BigNum a,b;
char str1[10000],str2[10000];
scanf("%d",&n);
for(i=1;i<=n;++i){
scanf("%s%s",str1,str2);
a=BigNum(str1);
b=BigNum(str2);
if( (( !(a>b) && !(b>a))) && a%11==0 )
printf("YES
");
else
printf("NO
");
}
return 0;
}
在用C或者C++处理大数时感觉非常麻烦，但是在JAVA中有两个类BigInteger和BigDecimal分别表示大整数类和大浮点数类，至于两个类的对象能表示最大范围不清楚，理论上能够表示无线大的数，只要计算机内存足够大。
这两个类都在java.math.*包中，因此每次必须在开头处引用该包。
Ⅰ基本函数：
1.valueOf(parament); 将参数转换为制定的类型
2.add(); 大整数相加
BigInteger a=new BigInteger(“23”);
BigInteger b=new BigInteger(“34”);
a.add(b);
3.subtract(); 相减
4.multiply(); 相乘
5.divide();
6.remainder(); 取余
7.pow();
8.gcd();
9.abs(); 绝对值
10.negate(); 取反数
11.mod(); a.mod(b)=a%b=a.remainder(b);
12.max(); min();
13.punlic int comareTo();
14.boolean equals(); 是否相等
15.BigInteger构造函数：
一般用到以下两种：
BigInteger(String val);
将指定字符串转换为十进制表示形式；
BigInteger(String val,int radix);
将指定基数的 BigInteger 的字符串表示形式转换为 BigInteger
Ⅱ.基本常量：
A=BigInteger.ONE
B=BigInteger.TEN
C=BigInteger.ZERO
Ⅲ.基本操作
1.读入：
用Scanner类定义对象进行控制台读入,Scanner类在java.util.*包中
Scanner cin=new Scanner(System.in);// 读入
while(cin.hasNext())
{
}
Ⅳ.运用
四则预算：
import java.util.Scanner;
import java.math.*;
import java.text.*;
public class Main
{
public static void main(String args[])
{
Scanner cin = new Scanner ( System.in );
BigInteger a,b;
int c;
char op;
String s;
while( cin.hasNext() )
{
a = cin.nextBigInteger();
s = cin.next();
op = s.charAt(0);
if( op == '+')
{
b = cin.nextBigInteger();
System.out.println(a.add(b));
}
else if( op == '-')
{
b = cin.nextBigInteger();
System.out.println(a.subtract(b));
}
else if( op == '*')
{
b = cin.nextBigInteger();
System.out.println(a.multiply(b));
}
else
{
BigDecimal a1,b1,eps;
String s1,s2,temp;
s1 = a.toString();
a1 = new BigDecimal(s1);
b = cin.nextBigInteger();
s2 = b.toString();
b1 = new BigDecimal(s2);
c = cin.nextInt();
eps = a1.divide(b1,c,4);
//System.out.println(a + " " + b + " " + c);
//System.out.println(a1.doubleValue() + " " + b1.doubleValue() + " " + c);
System.out.print( a.divide(b) + " " + a.mod(b) + " ");
if( c != 0)
{
temp = "0.";
for(int i = 0; i < c; i ++) temp += "0";
DecimalFormat gd = new DecimalFormat(temp);
System.out.println(gd.format(eps));
}
else System.out.println(eps);
}
}
}
}//=====================================================================================
//PKU1311八进制浮点数化为十进制浮点数，高精度
import java.io.*;
import java.util.*;
import java.math.*;
public class Main
{
public static void main(String[] args)
{
Scanner cin=new Scanner(System.in);
BigDecimal temp,sum,ans,num; //java大数
String str;
int i,len;
while(cin.hasNext())
{
str=cin.next();
len=str.length();
temp=BigDecimal.valueOf(8.0);
sum=BigDecimal.ONE;
ans=BigDecimal.ZERO;
for(i=2;i<len;i++)
{
int val=str.charAt(i)-'0';
num=BigDecimal.valueOf(val);
sum=sum.multiply(temp); //8的n次幂
ans=ans.add(num.divide(sum)); //按权累加
}
System.out.printf("%s [8] = ",str);
System.out.println(ans+" [10]");
}
}
}BigDecimal类
双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。表5.7中列出了BigDecimal类的主要构造器和方法。
BigDecimal类的主要构造器和方法
构 造 器描 述
BigDecimal(int)创建一个具有参数所指定整数值的对象。
BigDecimal(double)创建一个具有参数所指定双精度值的对象。
BigDecimal(long)创建一个具有参数所指定长整数值的对象。
BigDecimal(String)创建一个具有参数所指定以字符串表示的数值的对象。
方 法描 述
add(BigDecimal)BigDecimal对象中的值相加，然后返回这个对象。
subtract(BigDecimal)BigDecimal对象中的值相减，然后返回这个对象。
multiply(BigDecimal)BigDecimal对象中的值相乘，然后返回这个对象。
divide(BigDecimal)BigDecimal对象中的值相除，然后返回这个对象。
toString()将BigDecimal对象的数值转换成字符串。
doublue()将BigDecimal对象中的值以双精度数返回。
floatValue()将BigDecimal对象中的值以单精度数返回。
longValue()将BigDecimal对象中的值以长整数返回。
intValue()将BigDecimal对象中的值以整数返回。
注意，由于一般数值类型，例如double，不能准确地代表16位有效数以上的数字，在使用BigDecimal时，应用BigDecimal(String)构造器创建对象才有意义。另外，BigDecimal所创建的是对象，我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。
构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。关于构造器概念和编写技术，将在本书第6章详细介绍。
下面讨论BigDecimal的一些常用例子：
//完整程序例子在本书配套资源目录Ch5中名为BigDecimalTestApp.Java
//创建BigDecimal对象
BigDecimal bigNumber = new BigDecimal("89.1234567890123456789");
BigDecimal bigRate = new BigDecimal(1000);
BigDecimal bigResult = new BigDecimal(); //对象bigResult的值为0.0
//对bigNumber的值乘以1000，结果 赋予bigResult
bigResult = bigNumber.multiply(bigRate);
System.out.println(bigResult.toString());
//或者System.out.println(bigResult);
//显示结果：89123.4567890123456789000
//以双精度数返回bigNumber中的值
double dData = bigNumber.doublue();
System.out.println(dData); //结果：89.12345678901235
注意使用方法doublue()将对象bigNumber中的值以双精度数值返回时，将丢失数据的准确性。使用其他方法，如xxxValue()时均存在这个问题，使用时必须慎重。
BigDecimal用来对超过16有效位以上的数值进行运算和操作。所有的算术运算都通过调用其相应的方法进行。创建一个超过16有效位数的对象时，运用BigDecimal(String)才可避免丢失数字的精确度。
BigDecimal和格式化
由于NumberFormat类的format()方法可以使用BigDecimal对象作为其参数，可以利用BigDecimal对超出16位有效数字的货币值，百分值，以及一般数值进行格式化控制。
java四舍五入
package Test;
import java.math.BigDecimal; //引入这个包
public class Test {
public static void main(String[] args) {
double i = 3.856;
// 舍掉小数取整
System.out.println("舍掉小数取整:Math.floor(3.856)=" + (int) Math.floor(i));
// 四舍五入取整
System.out.println("四舍五入取整:(3.856)="
+ new BigDecimal(i).setScale(0, BigDecimal.ROUND_HALF_UP));
// 四舍五入保留两位小数
System.out.println("四舍五入取整:(3.856)="
+ new BigDecimal(i).setScale(2, BigDecimal.ROUND_HALF_UP));
// 凑整，取上限
System.out.println("凑整:Math.ceil(3.856)=" + (int) Math.ceil(i));
// 舍掉小数取整
System.out.println("舍掉小数取整:Math.floor(-3.856)=" + (int) Math.floor(-i));
// 四舍五入取整
System.out.println("四舍五入取整:(-3.856)="
+ new BigDecimal(-i).setScale(0, BigDecimal.ROUND_HALF_UP));
// 四舍五入保留两位小数
System.out.println("四舍五入取整:(-3.856)="
+ new BigDecimal(-i).setScale(2, BigDecimal.ROUND_HALF_UP));
// 凑整，取上限
System.out.println("凑整(-3.856)=" + (int) Math.ceil(-i));
package com.bigDecimal;
import java.math.BigDecimal;
/**
* 对BigDecimal类的封装操作
* BigDecimal的构造函数的参数必须要是字符串型
*/
public class Arith {
// 默认除法运算精度
private static final int DEF_DIV_SCALE = 10;
// 这个类不能实例化
private Arith() {
}
/**
* 提供精确的加法运算。
*
* @param v1 被加数
* @param v2 加数
* @return 两个参数的和
*/
public static double add(double v1, double v2) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
/**
* 提供精确的减法运算。
*
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static double sub(double v1, double v2) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
/**
* 提供精确的乘法运算。
*
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static double mul(double v1, double v2) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后10位，以后的数字四舍五入。
*
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/
public static double div(double v1, double v2) {
return div(v1, v2, DEF_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。
*
* @param v1 被除数
* @param v2 除数
* @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double div(double v1, double v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* 提供精确的小数位四舍五入处理。
*
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static double round(double v, int scale) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(Double.toString(v));
BigDecimal one = new BigDecimal("1");
return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
}