Java BigInteger类（大数综合模板）

有的时候当我们做一些关于大数的题目时，若要用C++的代码，可能过于冗长，而Java里有专门的BigInteger类来解决大数问题。

首先Java的大数计算与其他的不同，下面给出解释

 大数的加减运算不同于普通整数的加减乘除运算
 加—— a+b: a=a.add(b);
 减—— a-b: a=a.subtract(b); 
 乘—— a*b: a=a.multiply(b);
 除—— a/b: a=a.divide(b);
 求余—a%b: a=a.mod(b);
 转换—a=b: b=BigInteger.valueOf(a);
 比较 if (ans.compareTo(x) == 0)//比较
     System.out.println("相等");
 System.out.println("a + b = "+ans_add); // 这里的‘+’ （第二个） 是连接的意思

了解了大数的计算方法，下面给出声明一个大数的方法

import java.util.*;
import java.math.*;//必须要有
import java.io.*;
public class Main{
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		BigInteger a=cin.nextBigInteger();
		BigDecimal b=cin.nextBigDecimal();//double型
	}
}

下面给出基本模板

//模板
import java.util.*;
import java.math.*;
public class Main{
	public static void main(String[] args) {
		Scanner cin =new Scanner(System.in);
		BigInteger a,b,x,y;
		BigInteger ans_add,ans_sub,ans_mul,ans_div,ans_mod;
		a=cin.nextBigInteger();
		b=cin.nextBigInteger();
		ans_add=a.add(b);//a+b
		ans_sub=a.subtract(b);//a-b
		ans_mul=a.multiply(b);//a*b
		ans_div=a.divide(b);//a/b
		ans_mod=a.mod(b);//a%b
		x=BigInteger.valueOf(1);//转换,赋值
		System.out.println("a+b="+ans_add);
		System.out.println("a-b="+ans_sub);
		System.out.println("a*b="+ans_mul);
		System.out.println("a/b="+ans_div);
		System.out.println("a%b="+ans_mod);
		System.out.println(x);
		if(a.compareTo(b)==0)//比较a和b
			System.out.println("相等");
		else
			System.out.println("不相等");
		System.out.println(a.abs());//取绝对值
		int e=10;
		System.out.println(a.pow(e));//求a^e
		System.out.println(a.toString());//将大数a转字符串输出
		int p=8;
		System.out.println(a.toString(p));//将大数a转换成p进制后 按字符串输出

这里有更全面一点的基础模板：https://blog.csdn.net/nuoyanli/article/details/88583739

接下来，了解一些其他的东西

Java大数实现递推公式：f[i]=f[i-1]+f[i-2]*2 

import java.util.*;
import java.math.*; //导入类
 
public class Main{
    static BigInteger[] ans; //定义全局变量
    public static void main(String[] args){
 
        Scanner reader=new Scanner(System.in);
        //定义Scanner类对象
 
        ans = new BigInteger[251]; //定义ans大数数组的大小
 
        ans[0]=BigInteger.valueOf(1);//大数赋初值
        ans[1]=BigInteger.valueOf(1);
        ans[2]=BigInteger.valueOf(3);
        for(int i=3; i<=250; i++)
        {
            ans[i] = ans[i-1].add(ans[i-2].multiply(BigInteger.valueOf(2)));
        }  //大数加法的使用
        int n;
        while(reader.hasNextInt()){
            n=reader.nextInt();
            System.out.println(ans[n]); //普通输出
        }
    }
}

HDU-1002 大数A+B模板题

import java.util.*;
import java.math.*;
public class Main{
	public static void main(String[] args) {
		Scanner cin =new Scanner(System.in);
		int t=cin.nextInt();
		for(int i=1;i<=t;i++)
		{
			BigInteger a=cin.nextBigInteger();
			BigInteger b=cin.nextBigInteger();
			BigInteger ans_add;
			ans_add=a.add(b);
			System.out.println("Case "+i+":");
			System.out.println(a+" + "+b+" = "+ans_add);
			if(i!=t)
			System.out.println();
		}
	}
}

HDU-1042 大数阶乘

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	public static void main(String[] args) {
		Scanner cin =new Scanner(System.in);
		int n;
		while(cin.hasNext())
		{
			n=cin.nextInt();
			BigInteger sum=BigInteger.valueOf(1);
			for(int i=1;i<=n;i++)
				sum=sum.multiply(BigInteger.valueOf(i));
			System.out.println(sum);
		}
	}
}

UVA-10106 大数乘法

import java.math.BigInteger;
import java.util.*;
public class Main {
    public static void main(String args[]) {
        Scanner s = new Scanner(System.in);
        while(s.hasNext()) {
            BigInteger a=s.nextBigInteger();
            BigInteger b=s.nextBigInteger();
            BigInteger ans=a.multiply(b);
            System.out.println(ans);
        }
    }
}

UVA-10494 大数相除或者取余

import java.math.BigInteger;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        BigInteger a, b, t = new BigInteger("1");
        String c;
        while (s.hasNext()) {
            a = s.nextBigInteger();
            c = s.next();
            b = s.nextBigInteger();
            if (c.equals("%"))///equals用来比较的是两个对象的内容是否相等
                t = a.mod(b);
            if (c.equals("/"))
                t = a.divide(b);
            System.out.println(t);
        }
    }
}

POJ-1001( HDU-1063) 大数a^b

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		while(cin.hasNext())
		{
			BigDecimal a=cin.nextBigDecimal();
			int b=cin.nextInt();
			a=a.pow(b);
			String s=a.stripTrailingZeros().toPlainString();
			if(s.charAt(0)=='0')
				s=s.substring(1);
			System.out.println(s);
		}
	}
}

这里一个注释：

关于BigDecimal的用法大致上和BigInteger一样。

不过这里需要提一下，在进行大浮点数运算的时候，小数点后面可能会含有多余的后导0

比如0.5000，在题目要求中可能只需要输出0.5

当然，有的题目可能还会要求小数点前面的0也要去掉，输入.5

这时候我们就需要去除掉后导0

转化成 字符型的

方法如下：

String str;
str=ans.stripTrailingZeros().toPlainString();//去除所有后导0，并且转化成字符型
//ans为大浮点数运算后得到的答案
//如果小数点前面的0也需要去掉，那么输出的时候处理一下即可：
if(str.charAt(0)=='0')//如果以0开头
        System.out.println(str.substring(1));//返回以位置1开头的字符串
else
        System.out.println(str);

HDU-1023 计算卡特兰数：h(n)=h(n-1)*(4*n-2)/(n+1)

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	public static void main(String[] args) {
		Scanner cin =new Scanner(System.in);
			BigInteger[] dp=new BigInteger[110];
			dp[1]=BigInteger.valueOf(1);
			int m;
			for(int i=2;i<=100;i++)
				dp[i]=dp[i-1].multiply(BigInteger.valueOf(4*i-2)).divide(BigInteger.valueOf(i+1));//卡特兰数打表
			while(cin.hasNext())
			{
				m=cin.nextInt();
				System.out.println(dp[m]);
			}
	}
}

HDU-1047  T组大数，每组数据输入直到0终止，计算刚才输入的数之和。

//两种不同的赋值方法
import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	public static void main(String[] args) {
		Scanner cin =new Scanner(System.in);
		int t=cin.nextInt();
		while(cin.hasNext())
		{
			BigInteger n,sum,ans;
			sum=BigInteger.ZERO;
			while(cin.hasNext())
			{
				n=cin.nextBigInteger();
				if(n.equals(BigInteger.ZERO)) break;
				sum=sum.add(n);
			}
			System.out.println(sum);
            if(t!=1)
            	System.out.println();
            t--;
		}
	}
}



import java.math.*;
import java.util.Scanner;
import java.io.*;
public class Main {
    public static void main(String args[]){
    	Scanner cin = new Scanner(System.in);
    	int t=cin.nextInt();
    	while(cin.hasNext())
    	{
        BigInteger ans = BigInteger.valueOf(0);
        BigInteger x;
        BigInteger y = BigInteger.valueOf(0);
        
        while(cin.hasNext())
        {
             x = cin.nextBigInteger();
             if(x.equals(y)) ///加到0就要停止相加
                 break;
             ans  = ans.add(x);
        }
        System.out.println(ans);
        if(t!=1)
        	System.out.println();
        t--;
    }
 }
}

HDU-1753 两个超长的浮点类型数求和

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		BigDecimal a,b,ans;
		while(cin.hasNext())
		{
			a=cin.nextBigDecimal();
			b=cin.nextBigDecimal();
			ans=a.add(b);
			String s=ans.stripTrailingZeros().toPlainString();//去除后面的0
			System.out.println(s);
		}
	}
}

HDU-1715  计算1000以内的斐波那契数列

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		BigInteger ans[]=new BigInteger[10000];
		ans[1]=BigInteger.ONE;
		ans[2]=BigInteger.ONE;
		int t=cin.nextInt();
		while(cin.hasNext())
		{
			int n=cin.nextInt();
			for(int i=3;i<=n;i++)
				ans[i]=ans[i-1].add(ans[i-2]);
			System.out.println(ans[n]);
		}
	}
}

HDU-1250 计算斐波那契数列（不同于HDU-1715）

import java.util.*;
import java.math.*;
import java.io.*;
public class Main{
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		
		BigInteger ans[]=new BigInteger[10000];
		ans[1]=BigInteger.valueOf(1);
		ans[2]=BigInteger.valueOf(1);
		ans[3]=BigInteger.valueOf(1);
		ans[4]=BigInteger.valueOf(1);
		while(cin.hasNext())
		{
		int n=cin.nextInt();
		for(int i=5;i<=n;i++)
			ans[i]=ans[i-1].add(ans[i-2]).add(ans[i-3]).add(ans[i-4]);
			System.out.println(ans[n]);
		}
	}
}