训练日记-23

        今周末这两天的比赛完全不是一个档次的，周六那场比赛不仅题目恶心而且题意还表达有问题，很无语。。。而且其中一道题竟然是根据数据大小以及数据量之间的关系可以找出一个万能答案，看到题解的我眼泪掉下来。。。第一次碰到这样的题。。。

       不过，周末的题还挺不错，符合正常的出题规则。但是最终以三题告终，并不是太理想。其中两道为一道签到题，另外一道为数学+二分的题，最值得庆幸的则是第三道。第三道也是与数学相结合，即知道圆上三点坐标求圆心坐标的问题；但是主要问题在于高精度问题，每个数据的最大值为10的12次方，其中求圆心坐标的过程中需要用到两个数相乘，则长度可达24位数的长度，就算long double 精度也完全不够。而且看了一下过这道题的大佬队伍都是用java过的，然后战略转移，改用java（刚开始一直用的c++）。刚开始并不会java里的高精度计算，多亏了假期自学了一些c#，然后开学后也学了一点java的基本使用，然后java里的高精度计算就全是当场自学的了。

       java里的高精度计算主要优越于BigInteger跟BigDecimal这两种数据类型，java里的这两种数据类型不限精度，可以支持任意精度。BigInteger为整数类型，BigDecimal为浮点数类型。这两种数据不限精度虽然好，但是也有它的局限性，局限性在于对他们进行加减乘除基本运算只能通过调用相关的函数来完成。

        下面为我自学java高精度计算的相关资料，跟大家分享一下：

public class BigNumber {

 //默认除法运算精度,即保留小数点多少位 

 private static final int DEFAULT_DIV_SCALE = 10;

 //这个类不能实例化 

 private BigNumber() {

 }

 /** 

  * 提供精确的加法运算。 

  * @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();

 }

 /** 

  * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 

  * 小数点以后多少位，以后的数字四舍五入。 

  * @param v1 被除数 

  * @param v2 除数 

  * @return 两个参数的商 

  */

 public static double div(double v1, double v2) {

  return div(v1, v2, DEFAULT_DIV_SCALE);

 }

 /** 

  * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 

  * 定精度，以后的数字四舍五入。 

  * @param v1 被除数 

  * @param v2 除数 

  * @param scale 表示需要精确到小数点以后几位。 

  * @return 两个参数的商 

  */

 public static double div(double v1, double v2, int scale) {

  if (scale < 0) {

   System.err.println("除法精度必须大于0!");

   return 0;

  }

  BigDecimal b1 = new BigDecimal(Double.toString(v1));

  BigDecimal b2 = new BigDecimal(Double.toString(v2));

  return (b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP)).doubleValue();

 }

 /**

  * 计算Factorial阶乘！

  * @param n  任意大于等于0的int

  * @return     n!的值

  */

 public static BigInteger getFactorial(int n) {

  if (n < 0) {

   System.err.println("n必须大于等于0！");

   return new BigInteger("-1");

  } else if (n == 0) {

   return new BigInteger("0");

  }

  //将数组换成字符串后构造BigInteger

  BigInteger result = new BigInteger("1");

  for (; n > 0; n--) {

   //将数字n转换成字符串后，再构造一个BigInteger对象，与现有结果做乘法

   result = result.multiply(new BigInteger(new Integer(n).toString()));

  }

  return result;

 }

 public static void main(String[] args) {

  //  如果我们编译运行下面这个程序会看到什么？

  System.out.println(0.05 + 0.01);

  System.out.println(1.0 - 0.42);

  System.out.println(4.015 * 100);

  System.out.println(123.3 / 100);

  //  0.060000000000000005

  //  0.5800000000000001

  //  401.49999999999994

  //  1.2329999999999999

  //计算阶乘，可以将n设得更大

  int n = 30;

  System.out.println("计算n的阶乘" + n + "! = " + BigNumber.getFactorial(n));

  //用double构造BigDecimal

  BigDecimal bd1 = new BigDe
f145
cimal(0.1);

  System.out.println("(bd1 = new BigDecimal(0.1)) = " + bd1.toString());

  //用String构造BigDecimal

  BigDecimal bd2 = new BigDecimal("0.1");

  System.out.println("(bd2 = new BigDecimal(\"0.1\")) = "

    + bd2.toString());

  BigDecimal bd3 = new BigDecimal("0.10");

  //equals方法比较两个BigDecimal对象是否相等，相等返回true，不等返回false

  System.out.println("bd2.equals(bd3) = " + bd2.equals(bd3));//false

  //compareTo方法比较两个BigDecimal对象的大小，相等返回0，小于返回-1，大于返回1。

  System.out.println("bd2.compareTo(bd3) = " + bd2.compareTo(bd3));//0

  //进行精确计算

  System.out.println("0.05 + 0.01 = " + BigNumber.add(0.05, 0.01));

  System.out.println("1.0 - 0.42 = " + BigNumber.add(1.0, 0.42));

  System.out.println("4.015 * 100 =" + BigNumber.add(4.015, 100));

  System.out.println("123.3 / 100 = " + BigNumber.add(123.3, 100));

  /**

   * （1）BigInteger和BigDecimal都是不可变(immutable)的，在进行每一步运算时，都会产生一个新的对象，由于创建对象会引起开销，

   * 它们不适合于大量的数学计算，应尽量用long,float,double等基本类型做科学计算或者工程计算。

   * 设计BigInteger和BigDecimal的目的是用来精确地表示大整数和小数，使用于在商业计算中使用。

   * （2）BigDecimal有4个够造方法，其中的两个用BigInteger构造，另一个是用double构造，还有一个使用String构造。

   * 应该避免使用double构造BigDecimal，因为：有些数字用double根本无法精确表示，传给BigDecimal构造方法时就已经不精确了。

   * 比如，new BigDecimal(0.1)得到的值是0.1000000000000000055511151231257827021181583404541015625。

   * 使用new BigDecimal("0.1")得到的值是0.1。因此，如果需要精确计算，用String构造BigDecimal，避免用double构造，尽管它看起来更简单！ 

   * （3）equals()方法认为0.1和0.1是相等的，返回true，而认为0.10和0.1是不等的，结果返回false。

   * 方法compareTo()则认为0.1与0.1相等，0.10与0.1也相等。所以在从数值上比较两个BigDecimal值时，应该使用compareTo()而不是 equals()。

   * （4）另外还有一些情形，任意精度的小数运算仍不能表示精确结果。例如，1除以9会产生无限循环的小数 .111111...。

   * 出于这个原因，在进行除法运算时，BigDecimal可以让您显式地控制舍入。

   */

 }

}

        今天数学+高精度题目网址：

        http://acm.hdu.edu.cn/contests/contest_showproblem.php?cid=778&pid=1001
   

     下面是我AC的java代码：

import java.util.Scanner;

import java.math.BigDecimal;

import java.math.BigInteger;

public class Main {

public static void main(String []args)

{

Scanner sc=new Scanner(System.in);

int t;

double s;

t=sc.nextInt();

while(t>0)

{

s=sc.nextDouble();

BigDecimal x1 = new BigDecimal(Double.toString(s));

s=sc.nextDouble();

BigDecimal y1 = new BigDecimal(Double.toString(s));

s=sc.nextDouble();

BigDecimal x2 = new BigDecimal(Double.toString(s));

s=sc.nextDouble();

BigDecimal y2 = new BigDecimal(Double.toString(s));

s=sc.nextDouble();

BigDecimal x3 = new BigDecimal(Double.toString(s));

s=sc.nextDouble();

BigDecimal y3 = new BigDecimal(Double.toString(s));

s=sc.nextDouble();

BigDecimal x = new BigDecimal(Double.toString(s));

s=sc.nextDouble();

BigDecimal y = new BigDecimal(Double.toString(s));

BigDecimal i = new BigDecimal(Double.toString(2.0));

BigDecimal a=(x1.subtract(x2));

BigDecimal b=(y1.subtract(y2));

BigDecimal c=(x1.subtract(x3));

BigDecimal d=(y1.subtract(y3));

    BigDecimal a1 = x1.multiply(x1);

    BigDecimal b1 = y1.multiply(y1);

    BigDecimal a2 = x2.multiply(x2);

    BigDecimal b2 = y2.multiply(y2);

    BigDecimal a3 = x3.multiply(x3);

    BigDecimal b3 = y3.multiply(y3);

    

    BigDecimal e = ((a1.subtract(a2)).add (b1.subtract(b2))).divide(i);

    BigDecimal f = ((a1.subtract(a3)).add (b1.subtract(b3))).divide(i);

    BigDecimal det=(b.multiply(c)).subtract(a.multiply(d));

   

    BigDecimal x0=((d.multiply(e)).subtract(b.multiply(f))).divide(det);

    BigDecimal y0=((a.multiply(f)).subtract(c.multiply(e))).divide(det);

    

    BigDecimal r1=(((x1.add(x0)).multiply(x1.add(x0))).add((y1.add(y0)).multiply(y1.add(y0))));

    BigDecimal r2=(((x.add(x0)).multiply(x.add(x0))).add((y.add(y0)).multiply(y.add(y0))));

   

    if(r2.compareTo(r1)==1)

    System.out.println("Accepted");

    else System.out.println("Rejected");

    t--;

}

      因为是当场自学的java高精度相关操作，所以很多函数什么的用起来可能并不是最简的方法，或许也有多余的操作，欢迎指点。同时今后还要更深入的了解一下java高精度计算算法，今天用过之后感觉java中的高精度计算挺不错的。

    同时这道题牵扯到的圆上三点确定圆心的代码如下：

    double a = x1 - x2;

    double b = y1 - y2;

    double c = x1 - x3;

    double d = y1 - y3;

    double e = ((x1 * x1 - x2 * x2) + (y1 * y1 - y2 * y2)) / 2.0;

    double f = ((x1 * x1 - x3 * x3) + (y1 * y1 - y3 * y3)) / 2.0;

    double det = b * c - a * d;

    double x0 = -(d * e - b * f) / det;

    double y0 = -(a * f - c * e) / det;

    double r=sqrt((x1-x0)*(x1-x0)+(y1-y0)*(y1-y0));

   （x1，y1）（x2，y2）（x3，y3）分别为已知圆上三点坐标，（x0，y0）为所求圆心坐标，r为所求圆的半径。

     总体来说这两天比赛收获挺大的，不仅锻炼的思路，而且还掌握了一下题目的小套路，最重要的是学会了如何用java处理高精度问题，再也不担心高精度超内存或超时问题了。

    继续加油！