Java简单高精度合集

第一个Java的算法程序。记得可以使用Alt+'/'自动补全sysout和main之类的。

BigInteger在java.math.BigInteger中。

import java.math.BigInteger;

import java.util.Scanner;

public class Main {

    public static void main(String args[]) {

        Scanner sc=new Scanner(System.in);

        BigInteger a=sc.nextBigInteger();

        BigInteger b=sc.nextBigInteger();

        BigInteger c=a.add(b);

        System.out.println(c);

        sc.close();

    }

}

顺便把A*B也搞了，Java是有FFT优化的乘法。

import java.math.BigInteger;

import java.util.Scanner;

public class Main {

    public static void main(String args[]) {

        Scanner sc=new Scanner(System.in);

        BigInteger a=sc.nextBigInteger();

        BigInteger b=sc.nextBigInteger();

        BigInteger c=a.multiply(b);

        System.out.println(c);

        sc.close();

    }

}

减法也就是变成subtract罢了。

斐波那契大数：

import java.math.BigInteger;

import java.util.Scanner;

public class Main {

    public static void main(String args[]) {

        Scanner sc=new Scanner(System.in);

        while(sc.hasNext()) {

            int n=sc.nextInt();

            BigInteger f0=BigInteger.ONE;

            BigInteger f1=BigInteger.ONE;

            for(int i=1;i<n;i++) {

                BigInteger t=f1;

                f1=f0.add(f1);

                f0=t;

            }

            System.out.println(f1);

        }

        sc.close();

    }

}

https://www.luogu.org/problemnew/show/P1604

Java的高精度整数还有很多意想不到的神奇功能。例如BigInteger其实可以修改进制。

在读入的时候先用String暂时保存结果，生成BigInteger的时候在第二个参数指定进制，在BigInteger的toString方法也可以指定进制。当需要进制转换时使用String作为中转就可以了。

import java.math.BigInteger;

import java.util.Scanner;

public class Main {

    public static void main(String args[]) {

        Scanner sc=new Scanner(System.in);

        while(sc.hasNext()) {

            int b=sc.nextInt();

            String sa=sc.next();

            String sb=sc.next();

            BigInteger ba=new BigInteger(sa,b);

            BigInteger bb=new BigInteger(sb,b);

            BigInteger bc=ba.add(bb);

            System.out.println(bc.toString(b).toUpperCase());

        }

        sc.close();

    }

}

要计算阶乘的和，熟悉一下BigInteger的初始化方法以及与正常的整数运算的方法：

import java.math.BigInteger;

import java.util.Scanner;

public class Main {

    public static void main(String args[]) {

        Scanner sc=new Scanner(System.in);

        while(sc.hasNext()) {

            int n=sc.nextInt();

            BigInteger ans=BigInteger.ZERO;

            BigInteger fac=BigInteger.ONE;

            for(int i=1;i<=n;i++) {

                fac=fac.multiply(BigInteger.valueOf(i));

                ans=ans.add(fac);

            }

            System.out.println(ans);

        }

        sc.close();

    }

}

BigDecimal高精，注意BigDecimal的toString可能会出现科学计数法的结果。

注意！除法可能商是无限循环小数，这时候必须截断！

public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode);

其中scale是小数点后的精度。

而roundingMode也就是舍入模式：

输入RoundingMode.之后会出现如下：

CEILING    //向正无穷方向舍入

FLOOR    //向负无穷方向舍入

DOWN    //向零方向舍入

UP    //向远离0的方向舍入

HALF_DOWN    //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向下舍入, 例如1.55 保留一位小数结果为1.5

HALF_UP    //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向上舍入, 1.55保留一位小数结果为1.6

HALF_EVEN    //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，如果保留位数是奇数，使用ROUND_HALF_UP，如果是偶数，使用ROUND_HALF_DOWN

UNNECESSARY    //计算结果是精确的，不需要舍入模式

四舍五入就是是用

ROUND_HALF_UP

而直接设置截断时，使用：

public static void main(String[] args)

{

    BigDecimal a = new BigDecimal("4.5635");

    a = a.setScale(3, RoundingMode.HALF_UP);    //保留3位小数，且四舍五入

    System.out.println(a);

}

第一次使用BigDecimal的题：

https://www.luogu.org/problemnew/show/P1517

import java.math.BigDecimal;

import java.util.Scanner;

public class Main {

    public static void main(String args[]) {

        Scanner sc=new Scanner(System.in);

        while(sc.hasNext()) {

            BigDecimal x=sc.nextBigDecimal();

            int n=sc.nextInt();

            BigDecimal ans=BigDecimal.ONE;

            for(int i=0;i<n;i++) {

                ans=ans.multiply(x);

                //BigDecimal的乘法需要调用multiply()方法，乘以一个BigDecimal对象，返回一个BigDecimal对象

            }

            String s=ans.toPlainString();

            //在这里要使用toPlainString()方法，默认的toString()方法在某些情况是科学计数法，错了很多次才知道

            /*

             * 例如样例：

             * 0.000001 5

            */

            int len=s.length();

            int leadzero=-1;

            boolean metdot=false;

            for(int i=0;i<len;i++) {

                if(leadzero==-1&&s.charAt(i)!='0') {

                    leadzero=i;

                    //把整数部分的0去掉

                }

                if(s.charAt(i)=='.') {

                    metdot=true;

                    //遇到了小数点，说明是小数

                    break;

                }

            }

            if(metdot==true) {

                s=s.substring(leadzero);

                //遇到了小数点，说明是小数

                len=s.length();

                //重新计算s的长度，因为前面可能截断了整数部分的0

                int releadzero=-1;

                for(int i=len-1;i>=0;i--) {

                    if(s.charAt(i)!='0') {

                        releadzero=i+1;

                        //遇到第一个非零位置，其后的无效0截断

                        if(s.charAt(i)=='.') {

                            releadzero=i;

                            //遇到第一个非零位置是小数点，连小数点也截断

                        }

                        break;

                    }

                }

                s=s.substring(0,releadzero);

            }

            else {

                //没有遇到小数点，是整数，不可能有无效0

                ;

            }

            System.out.println(s);

        }

        sc.close();

    }

}

巴特西

Java简单高精度合集

最新文章

热门文章