java题目集总结4~5&期中

1.前言：

　　在这一阶段Java的学习过程中，我们学习了继承与多态，抽象类与接口，异常处理方式以及圈复杂度的判定还有其他的常用方法等，进行完成了更进一步的相关大作业(点线形系列在原有的基础上进一步的提高和突破)，我认为这一阶段这些作业均是具有一定的难度的，但我认为这样的几次作业很好的将编程与数学结合起来（果然计算机的尽头是数学。。。(￣ー￣)），在解决这些问题的同时，合理的运用数学思维同时选择合适的数学方法来寻找解决方法，从而再需要通过合理的编程结构来设计实现，往往会起到事半功倍的效果。 考查难度由易到难，层层递进，前面的题目即为后面的代码做了很大的设计铺垫。对于期中考试，层层递进，很好的考查了半个学期所学知识。在此阶段的学习过程中，我也意识到了我的很多问题，紧密完成我的作业同时，也要学会花时间停下来去思考代码结构问题（不要一味盲目莽撞地去写），花更多时间去完成作业和掌握知识点，要细心一点去思考。

2.设计与分析：

7-2 点线形系列4-凸四边形的计算

import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int count = 0, cnt = 0;
        String point = sc.nextLine();
        String data[] = null;
        if (point.charAt(0) >= '1' && point.charAt(0) <= '5' && point.charAt(1) == ':') {
            for (int i = 2; i < point.length(); i++) {
                if(point.charAt(i) == ' '){
                    cnt++;
                }
                if (point.charAt(i) == ',') {
                    count++;
                }
            }
            if(point.charAt(point.length()-1)==' '){
                cnt--;
            }
            if (count - 1 != cnt) {
                System.out.print("Wrong Format");
                return;
            }
            data = point.split(":|,| ");
            for (int i = 1; i < data.length; i++) {
                if (!data[i].matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$")) {
                    System.out.print("Wrong Format");
                    return;
                }
            }
        } else {
            System.out.print("Wrong Format");
            return;
        }
        switch (data[0]) {
            case "1":
                ISquadrilateral_parallelogram(data);
                break;
            case "2":
                Quadrilateraltype(data);
                break;
            case "3":
                ISConcaveQuadrilateral(data);
                break;
            case "4":
                Piontnumber(data);
                break;
            default:
                Isoutside(data);
                break;
        }
    }

    public static boolean ISQuadrilateral(Point a, Point b, Point c, Point d) {//是否为四边形
        Line l1=new Line(a,b);
        Line l2=new Line(b,c);
        Line l3=new Line(d,c);
        Line l4=new Line(a,d);
        if((l1.getSlope()==l2.getSlope())||(l3.getSlope()==l4.getSlope())||(l1.getSlope()==l4.getSlope())||(l2.getSlope()==l3.getSlope())){
            return false;
        }
        if(!l1.isParallel(l3)){
            if(l1.Intersection(l3)){
                return false;
            }
        }
        if(!l2.isParallel(l4)){
            if(l2.Intersection(l4)){
                return false;
            }
        }
        return true;
    }

    public static Point[] IStriangle(Point a, Point b, Point c, Point d){
        Line l1=new Line(a,b);
        Line l2=new Line(b,c);
        Line l3=new Line(c,d);
        Line l4=new Line(a,d);
        Line l5=new Line(a,c);
        Line l6=new Line(b,d);
        Point[] num =new Point[3];
        Point p=new Point(65536.0,65536.0);
        num[0]=p;
        if(b.pointsCoincideError(a)||c.pointsCoincideError(a)||d.pointsCoincideError(a)){
            trianglepro x=new trianglepro(l2,l6,l3);
            if(x.IStriangle()){
                num[0]=b;
                num[1]=c;
                num[2]=d;
                return num;
            }
        }
        if(a.pointsCoincideError(b)||c.pointsCoincideError(b)||d.pointsCoincideError(b)){
            trianglepro x=new trianglepro(l4,l5,l3);
            if(x.IStriangle()){
                num[0]=a;
                num[1]=c;
                num[2]=d;
                return num;
            }
        }if(a.pointsCoincideError(c)||b.pointsCoincideError(c)||d.pointsCoincideError(c)){
            trianglepro x=new trianglepro(l1,l6,l4);
            if(x.IStriangle()){
                num[0]=a;
                num[1]=b;
                num[2]=d;
                return num;
            }
        }if(a.pointsCoincideError(d)||b.pointsCoincideError(d)||c.pointsCoincideError(d)){
            trianglepro x=new trianglepro(l1,l5,l2);
            if(x.IStriangle()){
                num[0]=b;
                num[1]=c;
                num[2]=d;
                return num;
            }
        }
        if(l1.isParallel(l4)&&l6.isOnline(a)){
            trianglepro x=new trianglepro(l2,l6,l3);
            if(x.IStriangle()){
                num[0]=b;
                num[1]=c;
                num[2]=d;
                return num;
            }
        }
        if(l1.isParallel(l2)&&l5.isOnline(b)){
            trianglepro x=new trianglepro(l3,l5,l4);
            if(x.IStriangle()){
                num[0]=a;
                num[1]=c;
                num[2]=d;
                return num;
            }
        }
        if(l2.isParallel(l3)&&l6.isOnline(c)){
            trianglepro x=new trianglepro(l1,l6,l4);
            if(x.IStriangle()){
                num[0]=a;
                num[1]=b;
                num[2]=d;
                return num;
            }
        }
        if(l3.isParallel(l4)&&l5.isOnline(d)){
            trianglepro x=new trianglepro(l1,l5,l2);
            if(x.IStriangle()){
                num[0]=a;
                num[1]=b;
                num[2]=c;
                return num;
            }
        }
        return num;
    }


    public static boolean pointsCoincide(Point a, Point b, Point c, Point d){
        if(a.pointsCoincideError(b)||b.pointsCoincideError(c)||c.pointsCoincideError(d)||b.pointsCoincideError(d)||a.pointsCoincideError(d)||a.pointsCoincideError(c)){
            return true;
        }
        else{
            return false;
        }
    }

    public static void ISquadrilateral_parallelogram(String[] arr) {
        if (arr.length!= 9) {
            System.out.print("wrong number of points");
            return;
        }
        int k = 0;
        Point[] num = new Point[4];
        for (int i = 1; i <arr.length; i =i+2){
            Point p=new Point(Double.valueOf(arr[i]),Double.valueOf(arr[i+1]));
            num[k]=p;
            k++;
        }
        if(pointsCoincide(num[0],num[1],num[2],num[3])){
            System.out.print("points coincide");
            return;
        }
        if (ISQuadrilateral(num[0],num[1], num[2], num[3])) {
            System.out.print("true");
        } else {
            System.out.print("false false");
            return;
        }
        if (ISparallelogram(num[0],num[1],num[2],num[3])){
            System.out.print(" true");
        } else {
            System.out.print(" false");
        }
        return;
    }

    public static void Quadrilateraltype(String[] arr){
        if (arr.length!= 9) {
            System.out.print("wrong number of points");
            return;
        }
        Point[] num = new Point[4];
        int k=0;
        for (int i = 1; i <arr.length; i =i+2){
            Point p=new Point(Double.valueOf(arr[i]),Double.valueOf(arr[i+1]));
            num[k]=p;
            k++;
        }
        if(!ISQuadrilateral(num[0],num[1], num[2], num[3])) {
            System.out.print("not a quadrilateral");
            return;
        }
        if(pointsCoincide(num[0],num[1],num[2],num[3])){
            System.out.print("points coincide");
            return;
        }
        if(ISdiamond(num[0],num[1],num[2],num[3])){
            System.out.print("true");
        }
        else{
            System.out.print("false");
        }
        if(ISrectangle(num[0],num[1],num[2],num[3])){
            System.out.print(" true");
        }
        else{
            System.out.print(" false");
        }
        if(ISsquare(num[0],num[1],num[2],num[3])){
            System.out.print(" true");
        }
        else{
            System.out.print(" false");
        }
        return;
    }
    public static boolean ISparallelogram(Point a, Point b, Point c, Point d){//平行四边形
        Line l1 = new Line(a, b);
        Line l2 = new Line(d,c);
        if(l1.isParallel(l2)&&Math.abs(l1.segment()-l2.segment())<1e-6){
            return true;
        }
        return false;
    }

    public static boolean ISdiamond(Point a, Point b, Point c, Point d){//菱形
        if(ISparallelogram(a,b,c,d)){
            if(Math.abs(a.getDistance(b)-a.getDistance(d))<1e-6){
                return true;
            }
        }
        return false;
    }

    public static boolean ISrectangle(Point a, Point b, Point c, Point d){//长方形
        Line l1 = new Line(a,b);
        Line l2 = new Line(a,d);
        if(ISparallelogram(a,b,c,d)){
            if(l1.isVertical(l2)){
                return true;
            }
        }
        return false;
    }

    public static boolean ISsquare(Point a, Point b, Point c, Point d){//正方形
        if(ISrectangle(a,b,c,d)){
            if(Math.abs(a.getDistance(b)-a.getDistance(d))<1e-6){
                return true;
            }
        }
        return false;
    }

    public static void ISConcaveQuadrilateral(String[] arr){
        if (arr.length!= 9){
            System.out.print("wrong number of points");
            return;
        }
        Point[] num = new Point[4];
        int k=0;
        for(int i = 1; i <arr.length; i =i+2){
            Point p=new Point(Double.valueOf(arr[i]),Double.valueOf(arr[i+1]));
            num[k]=p;
            k++;
        }
        if(!ISQuadrilateral(num[0],num[1], num[2], num[3])) {
            System.out.print("not a quadrilateral");
            return;
        }
        if(pointsCoincide(num[0],num[1],num[2],num[3])){
            System.out.print("points coincide");
            return;
        }
        Line l1=new Line(num[0],num[1]);
        Line l2=new Line(num[0],num[2]);
        Line l3=new Line(num[0],num[3]);
        Line l4=new Line(num[1],num[2]);
        Line l5=new Line(num[2],num[3]);
        Line l6=new Line(num[1],num[3]);
        double circumference=l1.segment()+l4.segment()+l5.segment()+l3.segment();
        trianglepro a=new trianglepro(l1,l2,l4);
        trianglepro b=new trianglepro(l3,l2,l5);
        trianglepro c=new trianglepro(l4,l6,l5);
        trianglepro d=new trianglepro(l1,l6,l3);
        if(Math.abs(a.area()+b.area()-c.area()-d.area())<1e-6){
            System.out.print("true ");
            System.out.print(new DecimalFormat("0.0##").format(circumference)+" ");
            System.out.print(new DecimalFormat("0.0##").format(a.area()+b.area()));
            return;
        }
        else{
            System.out.print("false ");
            System.out.print(new DecimalFormat("0.0##").format(circumference)+" ");
            if(a.area()+b.area()>c.area()+d.area()){
                System.out.print(new DecimalFormat("0.0##").format(c.area()+d.area()));
            }
            else{
                System.out.print(new DecimalFormat("0.0##").format(a.area()+b.area()));
            }
            return;
        }
    }

    public static void Piontnumber(String[] arr) {
        if (arr.length != 13) {
            System.out.print("wrong number of points");
            return;
        }
        Point[] num = new Point[6];
        int k = 0;
        for (int i = 1; i < arr.length; i = i + 2) {
            Point p = new Point(Double.valueOf(arr[i]), Double.valueOf(arr[i + 1]));
            num[k] = p;
            k++;
        }
        if (num[0].pointsCoincideError(num[1])) {
            System.out.print("points coincide");
            return;
        }
        Point p=new Point(65536.0,65536.0);
        if (!ISQuadrilateral(num[2], num[3], num[4], num[5])){
            Point[] length = IStriangle(num[2], num[3], num[4], num[5]);
            if (length[0].x == 65536.0) {
                System.out.print("not a quadrilateral or triangle");
                return;
            } else {
                Line l1 = new Line(length[0], length[1]);
                Line l2 = new Line(length[1], length[2]);
                Line l3 = new Line(length[0], length[2]);
                Line l4 = new Line(num[0], num[1]);
                if ((l1.iscoincideline(num[0]) && l1.iscoincideline(num[1])) || (l2.iscoincideline(num[0]) && l2.iscoincideline(num[1])) || (l3.iscoincideline(num[0]) && l3.iscoincideline(num[1]))) {
                    System.out.print("The line is coincide with one of the lines");
                    return;
                }
                else if(l1.getIntersectionpoint(l4).equals(p)&&l2.getIntersectionpoint(l4).equals(p)&&l3.getIntersectionpoint(l4).equals(p)){
                    System.out.print("0");
                    return;
                }
                else if((l1.getIntersectionpoint(l4).equals(l2.getIntersectionpoint(l4))&&l3.getIntersectionpoint(l4).equals(p))||(l2.getIntersectionpoint(l4).equals(l3.getIntersectionpoint(l4))&&l1.getIntersectionpoint(l4).equals(p))||(l1.getIntersectionpoint(l4).equals(l3.getIntersectionpoint(l4))&&l2.getIntersectionpoint(l4).equals(p))){
                    System.out.print("1");
                    return;
                }
                else{
                    trianglepro tri=new trianglepro(l1,l2,l3);
                    Line ll1=new Line();
                    Line ll2=new Line();
                    Line ll3=new Line();
                    if(l3.getIntersectionpoint(l4).equals(p)){
                        ll1.getpoints(l1.getIntersectionpoint(l2),l1.getIntersectionpoint(l4));
                        ll2.getpoints(l1.getIntersectionpoint(l2),l2.getIntersectionpoint(l4));
                        ll3.getpoints(l1.getIntersectionpoint(l4),l2.getIntersectionpoint(l4));
                    }
                    else if(l2.getIntersectionpoint(l4).equals(p)){
                        ll1.getpoints(l1.getIntersectionpoint(l3),l1.getIntersectionpoint(l4));
                        ll2.getpoints(l1.getIntersectionpoint(l3),l3.getIntersectionpoint(l4));
                        ll3.getpoints(l1.getIntersectionpoint(l4),l3.getIntersectionpoint(l4));
                    }
                    else if(l1.getIntersectionpoint(l4).equals(p)){
                        ll1.getpoints(l2.getIntersectionpoint(l3),l2.getIntersectionpoint(l4));
                        ll2.getpoints(l2.getIntersectionpoint(l3),l3.getIntersectionpoint(l4));
                        ll3.getpoints(l2.getIntersectionpoint(l4),l3.getIntersectionpoint(l4));
                    }
                    else if(l1.getIntersectionpoint(l4).equals(l2.getIntersectionpoint(l4))){
                        ll1.getpoints(l1.p1,l1.p2);
                        ll2.getpoints(l1.getIntersectionpoint(l3),l3.getIntersectionpoint(l4));
                        ll3.getpoints(l1.getIntersectionpoint(l2),l3.getIntersectionpoint(l4));
                    }
                    else if(l1.getIntersectionpoint(l4).equals(l3.getIntersectionpoint(l4))){
                        ll1.getpoints(l1.p1,l1.p2);
                        ll2.getpoints(l1.getIntersectionpoint(l3),l2.getIntersectionpoint(l4));
                        ll3.getpoints(l1.getIntersectionpoint(l2),l2.getIntersectionpoint(l4));
                    }
                    else if(l2.getIntersectionpoint(l4).equals(l3.getIntersectionpoint(l4))){
                        ll1.getpoints(l2.p1,l2.p2);
                        ll2.getpoints(l2.getIntersectionpoint(l3),l1.getIntersectionpoint(l4));
                        ll3.getpoints(l1.getIntersectionpoint(l4),l1.getIntersectionpoint(l2));
                    }
                    trianglepro ntri=new trianglepro(ll1,ll2,ll3);
                    double area1=ntri.area();
                    double area2=tri.area()-ntri.area();
                    if(area2<area1){
                        double temp = area1;
                        area1 = area2;
                        area2 = temp;
                    }
                    System.out.print("2 "+new DecimalFormat("0.0##").format(area1) +" "+new DecimalFormat("0.0##").format(area2));
                    return;
                }
            }
        } else {
            Line l1 = new Line(num[2], num[3]);
            Line l2 = new Line(num[3], num[4]);
            Line l3 = new Line(num[4], num[5]);
            Line l4 = new Line(num[2], num[5]);
            Line l5 = new Line(num[0], num[1]);
            if((l1.iscoincideline(num[0]) && l1.iscoincideline(num[1])) || (l2.iscoincideline(num[0]) && l2.iscoincideline(num[1])) || (l3.iscoincideline(num[0]) && l3.iscoincideline(num[1])) || (l4.iscoincideline(num[0]) && l4.iscoincideline(num[1]))) {
                System.out.print("The line is coincide with one of the lines");
                return;
            }
            else if(l1.getIntersectionpoint(l5).equals(p)&&l2.getIntersectionpoint(l5).equals(p)&&l3.getIntersectionpoint(l5).equals(p)&&l4.getIntersectionpoint(l5).equals(p)){
                System.out.print("0");
                return;
            }
            else if((l1.getIntersectionpoint(l5).equals(l2.getIntersectionpoint(l5))&&l3.getIntersectionpoint(l5).equals(p)&&l4.getIntersectionpoint(l5).equals(p))
                    ||(l2.getIntersectionpoint(l5).equals(l3.getIntersectionpoint(l5))&&l1.getIntersectionpoint(l5).equals(p)&&l4.getIntersectionpoint(l5).equals(p))
                    ||(l3.getIntersectionpoint(l5).equals(l4.getIntersectionpoint(l5))&&l2.getIntersectionpoint(l5).equals(p)&&l4.getIntersectionpoint(l5).equals(p))
                    ||(l1.getIntersectionpoint(l5).equals(l4.getIntersectionpoint(l5))&&l2.getIntersectionpoint(l5).equals(p)&&l3.getIntersectionpoint(l5).equals(p))){
                System.out.print("1");
                return;
            }
            else{
                Line l6=new Line(num[2],num[4]);
                Line ll1=new Line();
                Line ll2=new Line();
                Line ll3=new Line();
                Line ll4=new Line();
                trianglepro a=new trianglepro(l1,l6,l2);
                trianglepro b=new trianglepro(l3,l6,l4);
                double area1=0;
                double area=a.area()+b.area();
                if((l5.isOnline(num[2])&&l5.isOnline(num[4]))||(l5.isOnline(num[3])&&l5.isOnline(num[5]))){
                    area1=0.5*area;
                }
                else if(!l1.getIntersectionpoint(l5).equals(p)&&!l2.getIntersectionpoint(l5).equals(p)){
                    ll1.getpoints(l1.getIntersectionpoint(l5),num[3]);
                    ll2.getpoints(l2.getIntersectionpoint(l5),num[3]);
                    ll3.getpoints(l1.getIntersectionpoint(l5),l2.getIntersectionpoint(l5));
                    trianglepro c=new trianglepro(ll1,ll2,ll3);
                    area1=c.area();
                }
                else if(!l1.getIntersectionpoint(l5).equals(p)&&!l3.getIntersectionpoint(l5).equals(p)){
                    ll1.getpoints(l1.getIntersectionpoint(l5),num[3]);
                    ll2.getpoints(l3.getIntersectionpoint(l5),num[3]);
                    ll3.getpoints(l3.getIntersectionpoint(l5),num[4]);
                    ll4.getpoints(l1.getIntersectionpoint(l5),l3.getIntersectionpoint(l5));
                    trianglepro c=new trianglepro(ll1,ll2,ll4);
                    trianglepro d=new trianglepro(l2,ll2,ll3);
                    area1=c.area()+d.area();
                }
                else if(!l1.getIntersectionpoint(l5).equals(p)&&!l4.getIntersectionpoint(l5).equals(p)){
                    ll1.getpoints(l1.getIntersectionpoint(l5),num[2]);
                    ll2.getpoints(l4.getIntersectionpoint(l5),num[2]);
                    ll3.getpoints(l1.getIntersectionpoint(l5),l4.getIntersectionpoint(l5));
                    trianglepro c=new trianglepro(ll1,ll2,ll3);
                    area1=c.area();
                }
                else if(!l2.getIntersectionpoint(l5).equals(p)&&!l3.getIntersectionpoint(l5).equals(p)){
                    ll1.getpoints(l2.getIntersectionpoint(l5),num[4]);
                    ll2.getpoints(l3.getIntersectionpoint(l5),num[4]);
                    ll3.getpoints(l2.getIntersectionpoint(l5),l3.getIntersectionpoint(l5));
                    trianglepro c=new trianglepro(ll1,ll2,ll3);
                    area1=c.area();
                }
                else if(!l2.getIntersectionpoint(l5).equals(p)&&!l4.getIntersectionpoint(l5).equals(p)){
                    ll1.getpoints(l2.getIntersectionpoint(l5),num[4]);
                    ll2.getpoints(l4.getIntersectionpoint(l5),num[4]);
                    ll3.getpoints(l4.getIntersectionpoint(l5),num[5]);
                    ll4.getpoints(l2.getIntersectionpoint(l5),l4.getIntersectionpoint(l5));
                    trianglepro c=new trianglepro(ll1,ll2,ll4);
                    trianglepro d=new trianglepro(l3,ll2,ll3);
                    area1=c.area()+d.area();
                }
                else if(!l3.getIntersectionpoint(l5).equals(p)&&!l4.getIntersectionpoint(l5).equals(p)){
                    ll1.getpoints(l3.getIntersectionpoint(l5),num[5]);
                    ll2.getpoints(l4.getIntersectionpoint(l5),num[5]);
                    ll3.getpoints(l3.getIntersectionpoint(l5),l4.getIntersectionpoint(l5));
                    trianglepro c=new trianglepro(ll1,ll2,ll3);
                    area1=c.area();
                }
                double area2=area-area1;
                if(area2<area1){
                    double temp = area1;
                    area1 = area2;
                    area2 = temp;
                }
                System.out.print("2 "+new DecimalFormat("0.0##").format(area1) +" "+new DecimalFormat("0.0##").format(area2));
                return;
            }
        }
    }

    public static void Isoutside(String[] arr) {
        if(arr.length!= 11){
            System.out.print("wrong number of points");
            return;
        }
        Point[] num = new Point[5];
        int k=0;
        for(int i = 1; i <arr.length; i =i+2){
            Point p=new Point(Double.valueOf(arr[i]),Double.valueOf(arr[i+1]));
            num[k]=p;
            k++;
        }
        if(!ISQuadrilateral(num[1],num[2],num[3],num[4])){
            Point[] length=IStriangle(num[1],num[2],num[3],num[4]);
            if(length[0].x==65536.0){
                System.out.print("not a quadrilateral or triangle");
                return;
            }
            else{
                Line l1=new Line(length[0],length[1]);
                Line l2=new Line(length[1],length[2]);
                Line l3=new Line(length[0],length[2]);
                int count=0;
                if(l1.isOnline(num[0])||l2.isOnline(num[0])||l3.isOnline(num[0])){
                    System.out.print("on the triangle");
                    return;
                }
                count+=l1.numpoint(num[0]);
                count+=l2.numpoint(num[0]);
                count+=l3.numpoint(num[0]);
                if(count%2==0){
                    System.out.print("outof the triangle");
                }
                else{
                    System.out.print("in the triangle");
                }
                return;
            }
        }
        else{
            Line l1=new Line(num[1],num[2]);
            Line l2=new Line(num[2],num[3]);
            Line l3=new Line(num[3],num[4]);
            Line l4=new Line(num[1],num[4]);
            if(l1.isOnline(num[0])||l2.isOnline(num[0])||l3.isOnline(num[0])||l4.isOnline(num[0])){
                System.out.print("on the quadrilateral");
                return;
            }
            int count=0;
            count+=l1.numpoint(num[0]);
            count+=l2.numpoint(num[0]);
            count+=l3.numpoint(num[0]);
            count+=l4.numpoint(num[0]);
            if(count%2==0){
                System.out.print("outof the quadrilateral");
            }
            else{
                System.out.print("in the quadrilateral");
            }
            return;
        }
    }
}


class Point{
    public double x;
    public double y;
    public Point(){}//构造函数
    public Point(double x, double y){
        this.x = x;
        this.y = y;
    }
    public void getPoint(double x, double y){
        this.x = x;
        this.y = y;
    }
    public boolean pointsCoincideError(Point p) {
        if (this.x== p.x && this.y == p.y) {
            return true;
        }
        else{
            return false;
        }
    }
    public boolean equals(Point p){
        boolean flag = false;
        if (this.x == p.x && this.y == p.y){
            flag = true;
        }
        return flag;
    }
    public double getDistance(Point p){
        return Math.sqrt((Math.pow((p.x-this.x),2)+Math.pow((p.y-this.y),2)));
    }
}

class Line {
    public Point p1;
    public Point p2;

    public Line() {
    }

    public Line(Point p1, Point p2) {
        this.p1 = p1;
        this.p2 = p2;
    }

    public double segment() {
        return p1.getDistance(p2);
    }

    public void getpoints(Point p1, Point p2) {
        this.p1 = p1;
        this.p2 = p2;
    }

    public double getSlope() {
        if (p1.x == p2.x) {
            return Double.POSITIVE_INFINITY;
        } else {
            return (p2.y - p1.y) / (p2.x - p1.x);
        }
    }

    public int numpoint(Point p){
        int count=0;
        double a= this.p2.y - this.p1.y;
        double b= this.p1.x - this.p2.x;
        double c= this.p2.x*this.p1.y-this.p1.x *this.p2.y;
        if(a==0){
            return count;
        }
        if(b==0){
            if(p.x>this.p1.x){
                count++;
            }
        }
        else{
            double px=(b*p.y+c)/(-a);
            if((px<this.p1.x&&px>this.p2.x&&px<p.x)||(px>this.p1.x&&px<this.p2.x&&px<p.x)){
                count++;
            }
        }
        return count;
    }

    public boolean iscoincideline(Point p){
        double a=this.p2.y-this.p1.y;
        double b=this.p1.x-this.p2.x;
        double c=this.p2.x*this.p1.y-this.p1.x*this.p2.y;
        if(a*p.x+b*p.y+c==0){
            return true;
        }
        return false;
    }

    public boolean isOnline(Point p){
        double a=this.p2.y-this.p1.y;
        double b=this.p1.x-this.p2.x;
        double c=this.p2.x*this.p1.y-this.p1.x*this.p2.y;
        double x1=Math.max(this.p1.x, this.p2.x);
        double x2=Math.min(this.p1.x, this.p2.x);
        double y1=Math.max(this.p1.y, this.p2.y);
        double y2=Math.min(this.p1.y, this.p2.y);
        if((a*p.x+b*p.y+c==0)&&(p.x <=x1&&p.x>=x2)&&(p.y<=y1&&p.y>=y2)){
            return true;
        }
        return false;
    }

    public double getDistance(Point x) {
        // 求得点到直线的距离
        // 直线方程x(y2-y1)-y(x2-x1)-x1(y2-y1)+y1(x2-x1)=0
        double distY = this.p2.y - this.p1.y;
        double distX = this.p2.x - this.p1.x;
        return Math.abs(x.x * distY - x.y * distX - p1.x * distY + p1.y * distX) / this.p1.getDistance(this.p2);
    }

    public boolean isVertical(Line l) {
        double ax = l.p2.x - l.p1.x;
        double ay = l.p2.y - l.p1.y;
        double bx = this.p2.x - this.p1.x;
        double by = this.p2.y - this.p1.y;
        if (ax * bx + ay * by == 0) {
            return true;
        } else {
            return false;
        }
    }

    public boolean isParallel(Line l) {
        double ax = l.p2.x - l.p1.x;
        double ay = l.p2.y - l.p1.y;
        double bx = this.p2.x - this.p1.x;
        double by = this.p2.y - this.p1.y;
        if (ax * by - bx * ay == 0) {
            return true;
        } else {
            return false;
        }
    }

    public Point getIntersectionpoint(Line l){
        Point p=new Point(65536.0,65536.0);
        double A= this.p2.y - this.p1.y;
        double B= this.p1.x - this.p2.x;
        double C= this.p2.x*this.p1.y-this.p1.x *this.p2.y;
        double a = l.p2.y - l.p1.y;
        double b = l.p1.x - l.p2.x;
        double c = l.p2.x * l.p1.y - l.p1.x * l.p2.y;
        if(this.isParallel(l)){
            return p;
        }
        if (A == 0) {
            if (a == 0) {
                return p;
            } else if (b == 0) {
                if ((l.p1.x <= this.p1.x && l.p1.x >= this.p2.x) || (l.p1.x >= this.p1.x && l.p1.x <= this.p2.x)) {
                    p.getPoint(l.p1.x,this.p1.y);
                    //System.out.println(p.x+","+p.y);
                   return p;
                }
            } else {
                double px = (b * this.p1.y + c) / (-a);
                if ((px <= this.p1.x && px >= this.p2.x) || (px >= this.p1.x && px <= this.p2.x)) {
                    p.getPoint(px,this.p1.y);
                    //System.out.println(p.x+","+p.y);
                    return p;
                }
            }
        }
        else if (B == 0) {
            if (a == 0) {
                if ((l.p1.y <= this.p1.y && l.p1.y>=this.p2.y) || (l.p1.y>=this.p1.y &&l.p1.y<=this.p2.y)) {
                    p.getPoint(this.p1.x,l.p1.y);
                    //System.out.println(p.x+","+p.y);
                  return p;
                }
            } else if (b == 0) {
                return p;
            } else {
                double py = (a * this.p1.x + c) / (-b);
                if ((py <= this.p1.y && py >= this.p2.y) || (py >= this.p1.y && py <= this.p2.y)) {
                    p.getPoint(this.p1.x,py);
                   // System.out.println(p.x+","+p.y);
                  return p;
                }
            }
        } else {
            if (a == 0) {
                double px = (B * l.p1.y + C) / (-A);
                if((px <= this.p1.x && px >=this.p2.x) || (px >= this.p1.x && px <=this.p2.x)) {
                    p.getPoint(px,l.p1.y);
                    //System.out.println(p.x+","+p.y);
                  return p;
                }
            } else if (b == 0) {
                double py = (A *l.p1.x+ C) / (-B);
                if ((py <= this.p1.y && py >= this.p2.y) || (py >= this.p1.y && py <= this.p2.y)) {
                    p.getPoint(l.p1.x,py);
                   // System.out.println(p.x+","+p.y);
                   return p;
                }
            } else {
                double px = (b * C - B * c) / (a * B - A * b);
                if ((px <= this.p1.x && px >=this.p2.x) || (px >= this.p1.x && px <= this.p2.x)) {
                    double py=(A * px + C) / (-B);
                    p.getPoint(px,py);
                    //System.out.println(p.x+","+p.y);
                    return p;
                }
            }
        }
        return p;
    }

    public Point getIntersection(Line l) {
        if (this.isParallel(l)) {
            return null;
        }
        if (this.p1.equals(l.p1) || this.p1.equals(l.p2)) {
            return p1;
        }
        if (this.p2.equals(l.p1) || this.p2.equals(l.p2)) {
            return p2;
        }
        Point cross_point = new Point();
        double x, y;
        double a1 = this.p2.y - this.p1.y;
        double b1 = this.p1.x - this.p2.x;
        double a2 = l.p2.y - l.p1.y;
        double b2 = l.p1.x - l.p2.x;
        double c1 = this.p2.x * this.p1.y - this.p1.x * this.p2.y;
        double c2 = l.p2.x * l.p1.y - l.p1.x * l.p2.y;
        cross_point.x = (b2 * c1 - b1 * c2) / (a2 * b1 - a1 * b2);
        cross_point.y = (a1 * c2 - a2 * c1) / (a2 * b1 - a1 * b2);
        return cross_point;
    }

    public boolean Intersection(Line l) {
        Point p = this.getIntersection(l);
        double x=p.x;
        double y=p.y;
        double x1 = Math.max(this.p1.x,this.p2.x);
        double x2 = Math.max(l.p1.x,l.p2.x);
        double x3 = Math.min(this.p1.x,this.p2.x);
        double x4 = Math.min(l.p1.x,l.p2.x);
        if ((x >=x3 && x<= x1) && ( x >=x4 &&x <= x2)) {
            return true;
        } else {
            return false;
        }
    }
}

class trianglepro{
    public Line l1;
    public Line l2;
    public Line l3;
    public trianglepro(){}
    public trianglepro(Line l1, Line l2, Line l3){
        this.l1 =l1;
        this.l2 =l2;
        this.l3=l3;
    }

    public boolean IStriangle(){
        double[] lines={this.l1.segment(),this.l2.segment(),this.l3.segment()};
        Arrays.sort(lines);
        if (lines[0]+ lines[1] > lines[2]) {
            return true;
        } else {
            return false;
        }
    }

    public double circumference(){
        double circumference=this.l1.segment()+this.l2.segment()+this.l3.segment();
        return circumference;
    }

    public double area(){
        double p = 0.5 * this.circumference();;
        double area = Math.sqrt(p * (p - this.l1.segment()) * (p - this.l2.segment()) * (p -this.l3.segment()));
        return area;
    }
}

 代码分析与处理：

1.输入的判断，输入中有空格和字符","的出现，对输入判断不方便。

2.输入数据第一位必须是数字且为1-5，第二位必须为":"(可作为先行判断的条件）

3.输入的点的坐标必须和输入的第一位数字的对应情况对应。

4.两个点的坐标之间以空格分隔,每个点的x,y坐标以英文“,”分隔。

5.每个数字前"+","-"只能有一个,必须符合基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。

6.定义一个字符串，将输入数据存入其中,同时对字符串中的","和空格数量进行对比,对所给数据进行字符串进行切割。

7.之后可对所给数据进行是否符合正则表达式判断，看其是否符合基本格式。

8.再运用switch语句，根据所读入的数字确定为何种情况，根据不同的情况判断输入数据的点数以及坐标是否重合，判断是否点的数量符合要求，输入的数据是否能够构成正常四边形（三角形）等等。

9.若为情况1则断是否是四边形、平行四边形，运用判断邻边不能平行，对边不能相交（或交点不能在两对边线段范围内）。

10.若为情况2则判断是否是菱形（平行四边形的基础上判断邻边是否相等）、矩形（平行四边形的基础上判断是否有直角）、正方形（长方形的基础上判断领边是否相等）。

11.若为情况3则将原四边形按不同的对角线连接得到的不同的两个三角形的面积和进行计算，若结果相差无几为凸四边形，反之为凹四边形，然后计算输出四边形周长、面积。

12.为情况4或5时，需要对输入的四个点进行判断判断（点是否重合以及点是否在其相邻领边上，去除冗余点后），判断构成一个四边形或三角形，

13.若为情况4则计算两个点所在的直线与所构成的四边形（三角形）相交的交点数量，如果交点有两个，则按面积大小依次输出四边形（三角形）被直线分割成两部分的面积，否则直接输出交点的个数。若直线与四边形（三角形）一条线重合，输出"The line is coincide with one of the lines"。

14.若为情况5则使用射线法，水平做一条射线计算出与与四边形（三角形）交点数量，在其左端的个数，判断是否奇数以此判断是否在后三个点所构成的四边形（三角形）的内部。

类图：

 分析报告：

7-1 点线形系列5-凸五边形的计算-1

import java.text.DecimalFormat;
import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int count = 0, cnt = 0;
        String point = sc.nextLine();
        String[] data = null;
        if (point.charAt(0) >= '1' && point.charAt(0) <= '6' && point.charAt(1) == ':') {
            for (int i = 2; i < point.length(); i++) {
                if (point.charAt(i) == ' ') {
                    cnt++;
                }
                if (point.charAt(i) == ',') {
                    count++;
                }
            }
            if (point.charAt(point.length() - 1) == ' ') {
                cnt--;
            }
            if (count - 1 != cnt) {
                System.out.print("Wrong Format");
                return;
            }
            data = point.split(":|,| ");
            for (int i = 1; i < data.length; i++) {
                if (!data[i].matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$")) {
                    System.out.print("Wrong Format");
                    return;
                }
            }
        } else {
            System.out.print("Wrong Format");
            return;
        }
        switch (data[0]) {
            case "1":
                Ifpentagon(data);
                break;
            case "2":
                ISConcavepentagon(data);
                break;
            case "3":
                Piontnumber(data);
                break;
        }
    }
    public static void Ifpentagon(String[] arr) {
        if (arr.length != 11) {
            System.out.print("wrong number of points");
            return;
        }
        int k = 0;
        Point[] num = new Point[5];
        for (int i = 1; i < arr.length; i = i + 2) {
            Point p = new Point(Double.valueOf(arr[i]), Double.valueOf(arr[i + 1]));
            num[k] = p;
            k++;
        }
        pentagon pe=new pentagon(num[0], num[1], num[2], num[3], num[4]);
        if (pe.ISpentagon()){
            System.out.print("true");
        } else {
            System.out.print("false");
        }
    }
    public static boolean onside(Line l, Point a, Point b, Point c) {
        if ((l.side(a) && l.side(b) && l.side(c)) || (!l.side(a) && !l.side(b) && !l.side(c))) {
            return true;
        } else {
            return false;
        }
    }
    public static boolean IfConcavepentagon(Point a,Point b,Point c,Point d,Point e) {
        pentagon pe=new pentagon(a,b,c,d,e);
        if (onside(pe.l1, c, d, e) && onside(pe.l2, a, d, e) && onside(pe.l3, a, b, e)&&
                onside(pe.l4, a, b, c) && onside(pe.l5, b, c, d)) {
            return true;
        } else {
            return false;
        }
    }
    public static int ISpolygon(Point[] num){
        if(num.length==5){
            pentagon pe=new pentagon(num[0],num[1],num[2],num[3],num[4]);
            if(pe.ISpentagon()){
                return 5;
            }
        }else if(num.length==4){
            quadrilateral qu=new quadrilateral(num[0],num[1],num[2],num[3]);
            if(qu.ISQuadrilateral()){
                return 4;
            }
        }else if(num.length==3){
            triangle tr=new triangle(num[0],num[1],num[2]);
            if(tr.IStriangle()){
                return 3;
            }
        }
        return 0;
    }
    public static Point[] caculatepoint(Point[] res1, Point[] res2){
        ArrayList<Point> num=new ArrayList();
        if(res1.length==5&&res2.length==5){
                pentagon a=new pentagon(res1[0],res1[1],res1[2],res1[3],res1[4]);
                pentagon b=new pentagon(res2[0],res2[1],res2[2],res2[3],res2[4]);
                for(int i=0;i<res1.length;i++){
                    if(!b.outpentagon(res1[i])){
                        num.add(res1[i]);
                    }
                    if(!a.outpentagon(res2[i])){
                        num.add(res2[i]);
                    }
                    for(int j=0;j<res2.length;j++){
                        if(a.ls[i].Intersection(b.ls[j])){
                            num.add(a.ls[i].getIntersection(b.ls[j]));
                        }
                    }
                }
            }
        else if(res1.length==5&&res2.length==4||res1.length==4&&res2.length==5){
            if(res1.length<res2.length) {
                Point[] temp = res1.clone();
                res1=res2;
                res2=temp;
            }
            pentagon a=new pentagon(res1[0],res1[1],res1[2],res1[3],res1[4]);
            quadrilateral b=new quadrilateral(res2[0],res2[1],res2[2],res2[3]);
            for(int i=0;i<res1.length;i++){
                if(!b.outquadrilateral(res1[i])){
                    num.add(res1[i]);
                }
            }
            for(int i=0;i<res2.length;i++) {
                if (!a.outpentagon(res2[i])) {
                        num.add(res2[i]);
                    }
                }
                for(int i=0;i<res1.length;i++){
                    for(int j=0;j<res2.length;j++) {
                        if (a.ls[i].Intersection(b.ls[j])) {
                            num.add(a.ls[i].getIntersection(b.ls[j]));
                        }
                    }
                }
        }
        else if(res1.length==5&&res2.length==3||res1.length==3&&res2.length==5){
            if(res1.length<res2.length){
                Point[] temp = res1.clone();
                res1=res2;
                res2=temp;
            }
            pentagon a=new pentagon(res1[0],res1[1],res1[2],res1[3],res1[4]);
            triangle b=new triangle(res2[0],res2[1],res2[2]);
            for(int i=0;i<res1.length;i++){
                if(!b.outtriangle(res1[i])){
                    num.add(res1[i]);
                }
            }
            for(int i=0;i<res2.length;i++) {
                if (!a.outpentagon(res2[i])) {
                    num.add(res2[i]);
                }
            }
            for(int i=0;i<res1.length;i++){
                for(int j=0;j<res2.length;j++) {
                    if (a.ls[i].Intersection(b.ls[j])) {
                        num.add(a.ls[i].getIntersection(b.ls[j]));
                    }
                }
            }
        }
        else if(res1.length==4&&res2.length==4){
            quadrilateral a=new quadrilateral(res1[0],res1[1],res1[2],res1[3]);
            quadrilateral b=new quadrilateral(res2[0],res2[1],res2[2],res2[3]);
            for(int i=0;i<res1.length;i++){
                if(!b.outquadrilateral(res1[i])){
                    num.add(res1[i]);
                }
                if(!a.outquadrilateral(res2[i])){
                    num.add(res2[i]);
                }
                for(int j=0;j<res2.length;j++){
                    if(a.ls[i].Intersection(b.ls[j])){
                        num.add(a.ls[i].getIntersection(b.ls[j]));
                    }
                }
            }
        }
        else if(res1.length==4&&res2.length==3||res1.length==3&&res2.length==4){
            if(res1.length<res2.length){
                Point[] temp = res1.clone();
                res1=res2;
                res2=temp;
            }
            quadrilateral a=new quadrilateral(res1[0],res1[1],res1[2],res1[3]);
            triangle b=new triangle(res2[0],res2[1],res2[2]);
            for(int i=0;i<res1.length;i++){
                if(!b.outtriangle(res1[i])){
                    num.add(res1[i]);
                }
            }
            for(int i=0;i<res2.length;) {
                if (!a.outquadrilateral(res2[i])) {
                    num.add(res2[i]);
                }
            }
            for(int i=0;i<res1.length;i++){
                for(int j=0;j<res2.length;j++) {
                    if (a.ls[i].Intersection(b.ls[j])) {
                        num.add(a.ls[i].getIntersection(b.ls[j]));
                    }
                }
            }
        }
        else if(res1.length==3&&res2.length==3){
            triangle a=new triangle(res1[0],res1[1],res1[2]);
            triangle b=new triangle(res2[0],res2[1],res2[2]);
            for(int i=0;i<res1.length;i++){
                if(!b.outtriangle(res1[i])){
                    num.add(res1[i]);
                }
                if(!a.outtriangle(res2[i])){
                    num.add(res2[i]);
                }
                for(int j=0;j<res2.length;j++){
                    if(a.ls[i].Intersection(b.ls[j])){
                        num.add(a.ls[i].getIntersection(b.ls[j]));
                    }
                }
            }
        }
        return num.toArray(new Point[num.size()]);
    }
    public static void ISConcavepentagon(String[] arr) {
        if (arr.length != 11) {
            System.out.print("wrong number of points");
            return;
        }
        int k = 0;
        Point[] num = new Point[5];
        for (int i = 1; i < arr.length; i = i + 2) {
            Point p = new Point(Double.valueOf(arr[i]), Double.valueOf(arr[i + 1]));
            num[k] = p;
            k++;
        }
        pentagon pe=new pentagon(num[0], num[1], num[2], num[3], num[4]);
        if (!pe.ISpentagon()) {
            System.out.print("not a pentagon");
            return;
        }
        if (IfConcavepentagon(num[0], num[1], num[2], num[3], num[4])) {
            System.out.print("true" + " ");
            System.out.print(new DecimalFormat("0.0##").format(pe.circumference())+" ");
            System.out.print(new DecimalFormat("0.0##").format(pe.area(pe.ps)));
        } else {
            System.out.print("false");
        }
    }
    public static void Piontnumber(String[] arr) {
        if (arr.length != 15) {
            System.out.print("wrong number of points");
            return;
        }
        Point[] num = new Point[8];
        int k = 0;
        for (int i = 1; i < arr.length; i = i + 2) {
            Point p = new Point(Double.valueOf(arr[i]), Double.valueOf(arr[i + 1]));
            num[k] = p;
            k++;
        }
        if (num[0].equals(num[1])) {
            System.out.print("points coincide");
            return;
        }
        Point[] nums=new Point[]{num[2], num[3], num[4], num[5], num[6]};
        polygon po=new polygon(nums);
        Point[] res= po.simplypolygon(po.simplypoints());
        switch(ISpolygon(res)){
            case 3:
                triangle tr = new triangle(res[0],res[1],res[2]);
                tr.pointnumber(num[0],num[1]);
                break;
            case 4:
                quadrilateral qu=new quadrilateral(res[0],res[1],res[2],res[3]);
                qu.pointnumber(num[0],num[1]);
                break;
            case 5:
                 pentagon pe=new pentagon(res[0], res[1], res[2], res[3], res[4]);
                 pe.pointnumber(num[0],num[1]);
                 break;
            default:
                System.out.print("not a polygon");
                break;
        }
    }
}

class Point {
    public double x;
    public double y;
    public Point() {
    }//构造函数
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public void getPoint(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public boolean equals(Point p){
        boolean flag = false;
        if (Math.abs(this.x-p.x)<1e-6&&Math.abs(this.y-p.y)<1e-6){
            flag = true;
        }
        return flag;
    }
    public double getDistance(Point p) {
        return Math.sqrt((Math.pow((Math.abs(p.x - this.x)), 2) + Math.pow((Math.abs(p.y - this.y)), 2)));
    }
}

class Line {
    public Point p1;
    public Point p2;
    public Line() {
    }
    public Line(Point p1, Point p2) {
        this.p1 = p1;
        this.p2 = p2;
    }
    public double segment() {
        return p1.getDistance(p2);
    }
    public void getpoints(Point p1, Point p2) {
        this.p1 = p1;
        this.p2 = p2;
    }
    public boolean side(Point p) {
        double a = this.p2.y - this.p1.y;
        double b = this.p1.x - this.p2.x;
        double c = this.p2.x * this.p1.y - this.p1.x * this.p2.y;
        if (a * p.x + b * p.y + c > 0) {
            /*在下方*/
            return true;
        } else {
            /*在上方*/
            return false;
        }
    }
    public double getSlope() {
        if (p1.x == p2.x) {
            return Double.POSITIVE_INFINITY;
        } else {
            return (p2.y - p1.y) / (p2.x - p1.x);
        }
    }
    public boolean iscoincideline(Point p) {
        double a = this.p2.y - this.p1.y;
        double b = this.p1.x - this.p2.x;
        double c = this.p2.x * this.p1.y - this.p1.x * this.p2.y;
        if (a * p.x + b * p.y + c == 0) {
            return true;
        }
        return false;
    }
    public boolean isOnline(Point p) {
        double a = this.p2.y - this.p1.y;
        double b = this.p1.x - this.p2.x;
        double c = this.p2.x * this.p1.y - this.p1.x * this.p2.y;
        double x1 = Math.max(this.p1.x, this.p2.x);
        double x2 = Math.min(this.p1.x, this.p2.x);
        double y1 = Math.max(this.p1.y, this.p2.y);
        double y2 = Math.min(this.p1.y, this.p2.y);
        if ((a * p.x + b * p.y + c == 0) && (p.x <= x1 && p.x >= x2) && (p.y <= y1 && p.y >= y2)) {
            return true;
        }
        return false;
    }
    public boolean isParallel(Line l) {
        double ax = l.p2.x - l.p1.x;
        double ay = l.p2.y - l.p1.y;
        double bx = this.p2.x - this.p1.x;
        double by = this.p2.y - this.p1.y;
        if (ax * by - bx * ay == 0) {
            return true;
        } else {
            return false;
        }
    }
    public Point getIntersectionpoint(Line l) {
        Point p = new Point(65536.0, 65536.0);
        double A = this.p2.y - this.p1.y;
        double B = this.p1.x - this.p2.x;
        double C = this.p2.x * this.p1.y - this.p1.x * this.p2.y;
        double a = l.p2.y - l.p1.y;
        double b = l.p1.x - l.p2.x;
        double c = l.p2.x * l.p1.y - l.p1.x * l.p2.y;
        if (this.isParallel(l)) {
            return p;
        }
        if (A == 0) {
            if (a == 0) {
                return p;
            } else if (b == 0) {
                if ((l.p1.x <this.p1.x && l.p1.x >this.p2.x) || (l.p1.x > this.p1.x && l.p1.x <this.p2.x)||(Math.abs(l.p1.x-this.p1.x)<1e-6)||(Math.abs(l.p1.x-this.p2.x)<1e-6)) {
                    p.getPoint(l.p1.x, this.p1.y);
                    return p;
                }
            } else {
                double px = (b * this.p1.y + c) / (-a);
                if ((px < this.p1.x && px > this.p2.x) || (px > this.p1.x && px < this.p2.x)||(Math.abs(px-this.p1.x)<1e-6)||(Math.abs(px-this.p2.x)<1e-6)) {
                    p.getPoint(px, this.p1.y);
                    return p;
                }
            }
        } else if (B == 0) {
            if (a == 0) {
                if ((l.p1.y < this.p1.y && l.p1.y > this.p2.y) || (l.p1.y > this.p1.y && l.p1.y < this.p2.y)||(Math.abs(l.p1.y-this.p1.y)<1e-6)||(Math.abs(l.p1.y-this.p2.y)<1e-6)) {
                    p.getPoint(this.p1.x, l.p1.y);
                    return p;
                }
            } else if (b == 0) {
                return p;
            } else {
                double py = (a * this.p1.x + c) / (-b);
                if ((py < this.p1.y && py > this.p2.y) || (py > this.p1.y && py < this.p2.y)||(Math.abs(py-this.p1.y)<1e-6)||(Math.abs(py-this.p2.y)<1e-6)) {
                    p.getPoint(this.p1.x, py);
                    return p;
                }
            }
        } else {
            if (a == 0) {
                double px = (B * l.p1.y + C) / (-A);
                if ((px <this.p1.x && px > this.p2.x) || (px > this.p1.x && px < this.p2.x)||(Math.abs(px-this.p1.x)<1e-6)||(Math.abs(px-this.p2.x)<1e-6)) {
                    p.getPoint(px, l.p1.y);
                    return p;
                }
            } else if (b == 0) {
                double py = (A * l.p1.x + C) / (-B);
                if ((py < this.p1.y && py > this.p2.y) || (py > this.p1.y && py < this.p2.y)||(Math.abs(py-this.p1.y)<1e-6)||(Math.abs(py-this.p2.y)<1e-6)) {
                    p.getPoint(l.p1.x, py);
                    return p;
                }
            } else {
                double px = (b * C - B * c) / (a * B - A * b);
                if ((px < this.p1.x && px > this.p2.x) || (px > this.p1.x && px < this.p2.x)||(Math.abs(px-this.p1.x)<1e-6)||(Math.abs(px-this.p2.x)<1e-6)) {
                    double py = (A * px + C) / (-B);
                    p.getPoint(px, py);
                    return p;
                }
            }
        }
        return p;
    }

    public Point getIntersection(Line l) {
        Point p = new Point(65536.0, 65536.0);
        if (this.isParallel(l)) {
            return p;
        }
        if (this.p1.equals(l.p1) || this.p1.equals(l.p2)) {
            return p1;
        }
        if (this.p2.equals(l.p1) || this.p2.equals(l.p2)) {
            return p2;
        }
        Point cross_point = new Point();
        double x, y;
        double a1 = this.p2.y - this.p1.y;
        double b1 = this.p1.x - this.p2.x;
        double a2 = l.p2.y - l.p1.y;
        double b2 = l.p1.x - l.p2.x;
        double c1 = this.p2.x * this.p1.y - this.p1.x * this.p2.y;
        double c2 = l.p2.x * l.p1.y - l.p1.x * l.p2.y;
        cross_point.x = (b2 * c1 - b1 * c2) / (a2 * b1 - a1 * b2);
        cross_point.y = (a1 * c2 - a2 * c1) / (a2 * b1 - a1 * b2);
        return cross_point;
    }

    public boolean Intersection(Line l) {
        Point p = this.getIntersection(l);
        double x = p.x;
        double y = p.y;
        double x1 = Math.max(this.p1.x, this.p2.x);
        double x2 = Math.max(l.p1.x, l.p2.x);
        double x3 = Math.min(this.p1.x, this.p2.x);
        double x4 = Math.min(l.p1.x, l.p2.x);
        if ((x >= x3 && x <= x1) && (x >= x4 && x <= x2)) {
            return true;
        } else {
            return false;
        }
    }
}

class polygon {
    public Point[] ps;
    public polygon() {
    }
    public polygon(Point[] num) {
        this.ps = num;
    }
    public ArrayList<Point> simplypoints() {
        ArrayList<Point> nums = new ArrayList();
        nums.add(this.ps[0]);
        for (int i = 0; i < this.ps.length; i++) {
            boolean flag = true;
            for (int j = 0; j < nums.size(); j++) {
                if (this.ps[i].equals(nums.get(j))) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                nums.add(this.ps[i]);
            }
        }
        return nums;
    }

    public Point[] sortpoints(ArrayList<Point> num){
        double x=0,y=0;
        Point temp=new Point();
        for (int i=0;i< num.size();i++){
            x+=num.get(i).x;
            y+=num.get(i).y;
        }
        Point p=new Point(x/ num.size(),y/ num.size());
            for (int i = 0; i < num.size()-1; i++) {  //排序的趟数 n-1趟
                for (int j = 0; j < num.size() - 1 - i; j++) { //两两排序 走完一遍最大的放后面
                    if (Math.atan2(num.get(j).y - p.y, num.get(j).x - p.x) > Math.atan2(num.get(j + 1).y - p.y, num.get(j + 1).x - p.x)) {
                        Collections.swap(num,j,j+1);
                    }
                }
            }
         return num.toArray(new Point[num.size()]);
    }
    public Point[] simplypolygon(ArrayList<Point> nums){
      for(int i=0;i<nums.size();){
          Line ll=new Line();
          if(i==nums.size()-1){
              ll.getpoints(nums.get(i-1),nums.get(0));
          }
          else if(i==0){
              ll.getpoints(nums.get(i+1),nums.get(nums.size()-1));
          }else{
              ll.getpoints(nums.get(i - 1), nums.get(i + 1));
          }
          if(ll.isOnline(nums.get(i))){
              nums.remove(i);
          }else{
              i++;
          }
        }
        return nums.toArray(new Point[nums.size()]);
    }
    public double area(Point[] num){
        double area = 0;
        for (int i = 0; i < num.length; i++) {
            if (i != num.length - 1) {
                area += num[i].x * num[i + 1].y - num[i].y * num[i + 1].x;
            } else {
                area += num[i].x * num[0].y - num[i].y * num[0].x;
            }
        }
        return Math.abs(area) / 2;
    }
}

class triangle extends polygon{
    public Point a;public Point b;public Point c;
    public Line l1;public Line l2;public Line l3;
    public Point[] ps;
    public Line[] ls;

    public triangle() {
    }

    public triangle(Point a, Point b, Point c) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.ps=new Point[]{a,b,c};
        this.length();
    }

    public void length() {
        this.l1 = new Line(this.a, this.b);
        this.l2 = new Line(this.b, this.c);
        this.l3 = new Line(this.c, this.a);
        this.ls=new Line[]{this.l1,this.l2,this.l3};
    }

    public boolean IStriangle() {
        double[] lines = {l1.segment(), l2.segment(), l3.segment()};
        Arrays.sort(lines);
        if (lines[0] + lines[1] > lines[2]) {
            return true;
        } else {
            return false;
        }
    }

    public double circumference() {
        return l1.segment() + l2.segment() + l3.segment();
    }

    public void pointnumber(Point a,Point b){
        Line ll=new Line(a,b);
        Point p=new Point(65536.0,65536.0);
        if((l1.iscoincideline(a) && l1.iscoincideline(b)) || (l2.iscoincideline(a) && l2.iscoincideline(b)) || (l3.iscoincideline(a) && l3.iscoincideline(b))) {
            System.out.print("The line is coincide with one of the lines");
            return;
        } else if (l1.getIntersectionpoint(ll).equals(p) && l2.getIntersectionpoint(ll).equals(p) && l3.getIntersectionpoint(ll).equals(p)) {
            System.out.print("0");
            return;
        } else if ((l1.getIntersectionpoint(ll).equals(l2.getIntersectionpoint(ll)) && l3.getIntersectionpoint(ll).equals(p))
                || (l2.getIntersectionpoint(ll).equals(l3.getIntersectionpoint(ll)) && l1.getIntersectionpoint(ll).equals(p))
                || (l1.getIntersectionpoint(ll).equals(l3.getIntersectionpoint(ll)) && l2.getIntersectionpoint(ll).equals(p))) {
            System.out.print("1");
            return;
        } else {
            double area1 = 0, area2 = 0;
            if (!l1.getIntersectionpoint(ll).equals(p) && !l2.getIntersectionpoint(ll).equals(p)&&!l1.getIntersectionpoint(ll).equals(l2.getIntersectionpoint(ll))) {
                triangle small=new triangle(l1.getIntersectionpoint(ll),this.b,l2.getIntersectionpoint(ll));
                area1 =small.area(small.ps);
            } else if (!l1.getIntersectionpoint(ll).equals(p) && !l3.getIntersectionpoint(ll).equals(p)&&!l1.getIntersectionpoint(ll).equals(l3.getIntersectionpoint(ll))) {
                triangle small=new triangle(l1.getIntersectionpoint(ll),l3.getIntersectionpoint(ll),this.a);
                area1 =small.area(small.ps);
            } else if (!l2.getIntersectionpoint(ll).equals(p) && !l3.getIntersectionpoint(ll).equals(p)&&!l2.getIntersectionpoint(ll).equals(l3.getIntersectionpoint(ll))) {
                triangle small=new triangle(l2.getIntersectionpoint(ll),this.c,l3.getIntersectionpoint(ll));
                area1 =small.area(small.ps);
            }
            area2 = this.area(this.ps) - area1;
            if (area2 < area1) {
                double temp = area1;
                area1 = area2;
                area2 = temp;
            }
            System.out.print("2 " + new DecimalFormat("0.0##").format(area1) + " " + new DecimalFormat("0.0##").format(area2));
            return;
        }
    }

    public boolean outtriangle(Point p){
        double sum=0;
        triangle x=new triangle(this.a,this.b,p);
        triangle y=new triangle(this.b,this.c,p);
        triangle z=new triangle(this.a,p,this.c);
        sum=x.area(x.ps)+y.area(y.ps)+z.area(z.ps);
        if(Math.abs(this.area(this.ps)-sum)<1e-6){
            return false;
        }
        else {
            return true;
        }
    }
}

class quadrilateral extends polygon {
    public Point a;public Point b;
    public Point c;public Point d;
    public Line l1;public Line l2;
    public Line l3;public Line l4;
    public Line ll1;public Line ll2;
    public Point[] ps;
    public Line[] ls;

    public quadrilateral(){
    }
    public quadrilateral(Point a, Point b, Point c, Point d) {
        this.a=a;this.b=b;
        this.c=c;this.d=d;
        this.ps=new Point[]{a,b,c,d};
        this.length();
    }

    public void length(){
        this.l1=new Line(this.a,this.b);
        this.l2=new Line(this.b,this.c);
        this.l3=new Line(this.c,this.d);
        this.l4=new Line(this.d,this.a);
        this.ls=new Line[]{this.l1,this.l2,this.l3,this.l4};
        this.ll1=new Line(this.a,this.c);
        this.ll2=new Line(this.b,this.d);
    }

    public boolean ISQuadrilateral() {//是否为四边形
        if ((l1.getSlope() == l2.getSlope()) || (l2.getSlope() == l3.getSlope())||(l3.getSlope() == l4.getSlope()) || (l1.getSlope() == l4.getSlope()) ) {
            return false;
        }
        if (!l1.isParallel(l3)) {
            if (l1.Intersection(l3)) {
                return false;
            }
        }
        if (!l2.isParallel(l4)) {
            if (l2.Intersection(l4)) {
                return false;
            }
        }
        return true;
    }

    public double circumference() {
        return l1.segment() + l2.segment() + l3.segment() + l4.segment();
    }

    public void soutarea(double area1){
        double area2=this.area(this.ps)-area1;
        if(area2<area1){
            double temp = area1;
            area1 = area2;
            area2 = temp;
        }
        System.out.print("2 "+new DecimalFormat("0.0##").format(area1) +" "+new DecimalFormat("0.0##").format(area2));
    }

    public void pointnumber(Point a,Point b){
        Line ll=new Line(a,b);
        Point p=new Point(65536.0,65536.0);
        if ((l1.iscoincideline(a) && l1.iscoincideline(b))|| (l2.iscoincideline(a) && l2.iscoincideline(b))
                || (l3.iscoincideline(a) && l3.iscoincideline(b))||(l4.iscoincideline(a) && l4.iscoincideline(b))) {
            System.out.print("The line is coincide with one of the lines");
            return;
        }
        else if(l1.getIntersectionpoint(ll).equals(p)&&l2.getIntersectionpoint(ll).equals(p)&&l3.getIntersectionpoint(ll).equals(p)&&l4.getIntersectionpoint(ll).equals(p)){
            System.out.print("0");
            return;
        }
        else if((l1.getIntersectionpoint(ll).equals(l2.getIntersectionpoint(ll))&&l3.getIntersectionpoint(ll).equals(p)&&l4.getIntersectionpoint(ll).equals(p))
                ||(l2.getIntersectionpoint(ll).equals(l3.getIntersectionpoint(ll))&&l1.getIntersectionpoint(ll).equals(p)&&l4.getIntersectionpoint(ll).equals(p))
                ||(l3.getIntersectionpoint(ll).equals(l4.getIntersectionpoint(ll))&&l1.getIntersectionpoint(ll).equals(p)&&l2.getIntersectionpoint(ll).equals(p))
                ||(l1.getIntersectionpoint(ll).equals(l4.getIntersectionpoint(ll))&&l2.getIntersectionpoint(ll).equals(p)&&l3.getIntersectionpoint(ll).equals(p))){
            System.out.print("1");
            return;
        }
        else{
            if(ll.isOnline(this.a)&&ll.isOnline(this.c)){
                triangle small=new triangle(this.a,this.b,this.c);
                this.soutarea(small.area(small.ps));
                return;
            }
            else if(ll.isOnline(this.b)&&ll.isOnline(this.d)){
                triangle small=new triangle(this.a,this.b,this.d);
                this.soutarea(small.area(small.ps));
                return;
            }
            else if(!l1.getIntersectionpoint(ll).equals(p)&&!l2.getIntersectionpoint(ll).equals(p)&&!l1.getIntersectionpoint(ll).equals(l2.getIntersectionpoint(ll))){
                triangle small=new triangle(l1.getIntersectionpoint(ll),this.b,l2.getIntersectionpoint(ll));
                this.soutarea(small.area(small.ps));
                return;
            }
            else if(!l1.getIntersectionpoint(ll).equals(p)&&!l3.getIntersectionpoint(ll).equals(p)&&!l1.getIntersectionpoint(ll).equals(l3.getIntersectionpoint(ll))){
                if(ll.isOnline(this.b)||ll.isOnline(this.c)){
                    quadrilateral small=new quadrilateral(l1.getIntersectionpoint(ll),l3.getIntersectionpoint(ll),this.d,this.a);
                    this.soutarea(small.area(small.ps));
                    return;
                }
                else{
                    quadrilateral small=new quadrilateral(l1.getIntersectionpoint(ll),this.b,this.c,l3.getIntersectionpoint(ll));
                    this.soutarea(small.area(small.ps));
                    return;
                }
            }
            else if(!l1.getIntersectionpoint(ll).equals(p)&&!l4.getIntersectionpoint(ll).equals(p)&&!l1.getIntersectionpoint(ll).equals(l4.getIntersectionpoint(ll))){
                triangle small=new triangle(l1.getIntersectionpoint(ll),l4.getIntersectionpoint(ll),this.a);
                this.soutarea(small.area(small.ps));
                return;
            }
            else if(!l2.getIntersectionpoint(ll).equals(p)&&!l3.getIntersectionpoint(ll).equals(p)&&!l2.getIntersectionpoint(ll).equals(l3.getIntersectionpoint(ll))){
                triangle small=new triangle(l2.getIntersectionpoint(ll),this.c,l3.getIntersectionpoint(ll));
                this.soutarea(small.area(small.ps));
                return;
            }
            else if(!l2.getIntersectionpoint(ll).equals(p)&&!l4.getIntersectionpoint(ll).equals(p)&&!l2.getIntersectionpoint(ll).equals(l4.getIntersectionpoint(ll))){
                if(ll.isOnline(this.d)||ll.isOnline(this.c)){
                    quadrilateral small=new quadrilateral(l2.getIntersectionpoint(ll),l4.getIntersectionpoint(ll),this.a,this.b);
                    this.soutarea(small.area(small.ps));
                    return;
                }
                else{
                    quadrilateral small=new quadrilateral(l2.getIntersectionpoint(ll),this.c,this.d,l4.getIntersectionpoint(ll));
                    this.soutarea(small.area(small.ps));
                    return;
                }
            }
            else if(!l3.getIntersectionpoint(ll).equals(p)&&!l4.getIntersectionpoint(ll).equals(p)&&!l3.getIntersectionpoint(ll).equals(l4.getIntersectionpoint(ll))){
                triangle small=new triangle(l3.getIntersectionpoint(ll),this.d,l4.getIntersectionpoint(ll));
                this.soutarea(small.area(small.ps));
                return;
            }
        }
    }

    public boolean outquadrilateral(Point p){
        double sum=0;
        triangle x=new triangle(this.a,this.b,p);
        triangle y=new triangle(this.b,this.c,p);
        triangle z=new triangle(this.c,this.d,p);
        triangle a=new triangle(this.d,this.a,p);
        sum=x.area(x.ps)+y.area(y.ps)+z.area(z.ps)+a.area(a.ps);
        if(Math.abs(this.area(this.ps)-sum)<1e-6){
            return false;
        }
        else {
            return true;
        }
    }
}

class pentagon extends polygon{
    public Point a;public Point b;
    public Point c;public Point d;
    public Point e;public Line l1;
    public Line l2;public Line l3;
    public Line l4;public Line l5;
    public Line ll1;public Line ll2;
    public Line ll3;public Line ll4;
    public Line ll5;public Point[] ps;
    public Line[] ls;
    public pentagon(){}
    public pentagon(Point a,Point b,Point c,Point d,Point e){
        this.a=a;this.b=b;
        this.c=c;this.d=d;
        this.e=e;
        this.length();
        this.ps=new Point[]{a,b,c,d,e};
    }

    public void length(){
        this.l1=new Line(this.a,this.b);
        this.l2=new Line(this.b,this.c);
        this.l3=new Line(this.c,this.d);
        this.l4=new Line(this.d,this.e);
        this.l5=new Line(this.e,this.a);
        this.ls=new Line[]{this.l1,this.l2,this.l3,this.l4,this.l5};
        this.ll1=new Line(this.a,this.c);
        this.ll2=new Line(this.a,this.d);
        this.ll3=new Line(this.b,this.d);
        this.ll4=new Line(this.b,this.e);
        this.ll5=new Line(this.c,this.e);
    }
    public boolean ISpentagon() {
        if (l1.isParallel(l2) || l1.isParallel(l5) || l2.isParallel(l3) || l3.isParallel(l4) || l4.isParallel(l5)) {
            return false;
        } else if (l1.Intersection(l3) || l1.Intersection(l4) || l2.Intersection(l4) || l2.Intersection(l5) || l3.Intersection(l5)) {
            return false;
        } else {
            return true;
        }
    }
    public double circumference() {
        return l1.segment() + l2.segment() + l3.segment() + l4.segment()+l5.segment();
    }

    public void soutarea(double area1){
        double area2=this.area(this.ps)-area1;
        if(area2<area1){
            double temp = area1;
            area1 = area2;
            area2 = temp;
        }
        System.out.print("2 "+new DecimalFormat("0.0##").format(area1) +" "+new DecimalFormat("0.0##").format(area2));
    }
    public void pointnumber(Point a,Point b){
        Line ll=new Line(a,b);
        Point p=new Point(65536.0,65536.0);
        if ((l1.iscoincideline(a) && l1.iscoincideline(b)) || (l2.iscoincideline(a) && l2.iscoincideline(b))
                || (l3.iscoincideline(a) && l3.iscoincideline(b)) || (l4.iscoincideline(a) && l4.iscoincideline(b))
                || (l5.iscoincideline(a) && l5.iscoincideline(b))) {
            System.out.print("The line is coincide with one of the lines");
            return;
        } else if (l1.getIntersectionpoint(ll).equals(p) && l2.getIntersectionpoint(ll).equals(p) && l3.getIntersectionpoint(ll).equals(p)
                && l4.getIntersectionpoint(ll).equals(p) && l5.getIntersectionpoint(ll).equals(p)) {
            System.out.print("0");
            return;
        } else if ((l1.getIntersectionpoint(ll).equals(l2.getIntersectionpoint(ll)) && l3.getIntersectionpoint(ll).equals(p) && l4.getIntersectionpoint(ll).equals(p) && l5.getIntersectionpoint(ll).equals(p))
                || (l2.getIntersectionpoint(ll).equals(l3.getIntersectionpoint(ll)) && l1.getIntersectionpoint(ll).equals(p) && l4.getIntersectionpoint(ll).equals(p) && l5.getIntersectionpoint(ll).equals(p))
                || (l3.getIntersectionpoint(ll).equals(l4.getIntersectionpoint(ll)) && l1.getIntersectionpoint(ll).equals(p) && l2.getIntersectionpoint(ll).equals(p) && l5.getIntersectionpoint(ll).equals(p))
                || (l4.getIntersectionpoint(ll).equals(l5.getIntersectionpoint(ll)) && l1.getIntersectionpoint(ll).equals(p) && l2.getIntersectionpoint(ll).equals(p) && l3.getIntersectionpoint(ll).equals(p))
                || (l1.getIntersectionpoint(ll).equals(l5.getIntersectionpoint(ll)) && l2.getIntersectionpoint(ll).equals(p) && l3.getIntersectionpoint(ll).equals(p) && l4.getIntersectionpoint(ll).equals(p))) {
            System.out.print("1");
            return;
        } else {
            double area1 = 0;
            if(ll.isOnline(this.a)&&ll.isOnline(this.c)){
                triangle small = new triangle(this.a,this.b,this.c);
                this.soutarea(small.area(small.ps));
                return;
            }
            else if(ll.isOnline(this.a)&&ll.isOnline(this.d)){
                triangle small = new triangle(this.a,this.d,this.e);
                this.soutarea(small.area(small.ps));
                return;
            }
            else if(ll.isOnline(this.b)&&ll.isOnline(this.d)){
                triangle small = new triangle(this.b,this.c,this.d);
                this.soutarea(small.area(small.ps));
                return;
            }
            else if(ll.isOnline(this.b)&&ll.isOnline(this.e)){
                triangle small = new triangle(this.b,this.e,this.a);
                this.soutarea(small.area(small.ps));
                return;
            }
            else if(ll.isOnline(this.c)&&ll.isOnline(this.e)){
                triangle small = new triangle(this.c,this.d,this.e);
                this.soutarea(small.area(small.ps));
                return;
            }
            else if (!l1.getIntersectionpoint(ll).equals(p) && !l2.getIntersectionpoint(ll).equals(p)&&!l1.getIntersectionpoint(ll).equals(l2.getIntersectionpoint(ll))) {
                triangle small = new triangle(l1.getIntersectionpoint(ll),this.b,l2.getIntersectionpoint(ll));
                this.soutarea(small.area(small.ps));
                return;
            } else if (!l1.getIntersectionpoint(ll).equals(p) && !l3.getIntersectionpoint(ll).equals(p)&&!l1.getIntersectionpoint(ll).equals(l3.getIntersectionpoint(ll))) {
                if(ll.isOnline(this.b)||ll.isOnline(this.c)){
                    pentagon small=new pentagon(l1.getIntersectionpoint(ll),l3.getIntersectionpoint(ll),this.d,this.e,this.a);
                    this.soutarea(small.area(small.ps));
                    return;
                }
                else{
                    quadrilateral small=new quadrilateral(l1.getIntersectionpoint(ll),this.b,this.c,l3.getIntersectionpoint(ll));
                    this.soutarea(small.area(small.ps));
                    return;
                }
            } else if (!l1.getIntersectionpoint(ll).equals(p) && !l4.getIntersectionpoint(ll).equals(p)&&!l1.getIntersectionpoint(ll).equals(l4.getIntersectionpoint(ll))) {
                if(ll.isOnline(this.a)||ll.isOnline(this.e)){
                    pentagon small=new pentagon(l1.getIntersectionpoint(ll),this.b,this.c,this.d,l4.getIntersectionpoint(ll));
                    this.soutarea(small.area(small.ps));
                    return;
                }
                else{
                    quadrilateral small=new quadrilateral(l1.getIntersectionpoint(ll),l3.getIntersectionpoint(ll),this.e,this.a);
                    this.soutarea(small.area(small.ps));
                    return;
                }
            } else if (!l1.getIntersectionpoint(ll).equals(p) && !l5.getIntersectionpoint(ll).equals(p)&&!l1.getIntersectionpoint(ll).equals(l5.getIntersectionpoint(ll))) {
                triangle small = new triangle(l1.getIntersectionpoint(ll),l5.getIntersectionpoint(ll),this.a);
                this.soutarea(small.area(small.ps));
                return;
            } else if (!l2.getIntersectionpoint(ll).equals(p) && !l3.getIntersectionpoint(ll).equals(p)&&!l2.getIntersectionpoint(ll).equals(l3.getIntersectionpoint(ll))) {
                triangle small = new triangle(l2.getIntersectionpoint(ll),this.c,l3.getIntersectionpoint(ll));
                this.soutarea(small.area(small.ps));
                return;
            } else if (!l2.getIntersectionpoint(ll).equals(p) && !l4.getIntersectionpoint(ll).equals(p)&&!l2.getIntersectionpoint(ll).equals(l4.getIntersectionpoint(ll))) {
                if(ll.isOnline(this.c)||ll.isOnline(this.d)){
                    pentagon small=new pentagon(l2.getIntersectionpoint(ll),l4.getIntersectionpoint(ll),this.e,this.a,this.b);
                    this.soutarea(small.area(small.ps));
                    return;
                }
                else{
                    quadrilateral small=new quadrilateral(l2.getIntersectionpoint(ll),this.c,this.d,l4.getIntersectionpoint(ll));
                    this.soutarea(small.area(small.ps));
                    return;
                }
            } else if (!l2.getIntersectionpoint(ll).equals(p) && !l5.getIntersectionpoint(ll).equals(p)&&!l2.getIntersectionpoint(ll).equals(l5.getIntersectionpoint(ll))) {
                if(ll.isOnline(this.a)||ll.isOnline(this.b)){
                    pentagon small=new pentagon(l2.getIntersectionpoint(ll),this.c,this.d,this.e,l5.getIntersectionpoint(ll));
                    this.soutarea(small.area(small.ps));
                    return;
                }
                else{
                    quadrilateral small=new quadrilateral(l2.getIntersectionpoint(ll),l5.getIntersectionpoint(ll),this.a,this.b);
                    this.soutarea(small.area(small.ps));
                    return;
                }
            } else if (!l3.getIntersectionpoint(ll).equals(p) && !l4.getIntersectionpoint(ll).equals(p)&&!l3.getIntersectionpoint(ll).equals(l4.getIntersectionpoint(ll))) {
                triangle small = new triangle(l3.getIntersectionpoint(ll),this.d,l4.getIntersectionpoint(ll));
                this.soutarea(small.area(small.ps));
                return;
            } else if (!l3.getIntersectionpoint(ll).equals(p) && !l5.getIntersectionpoint(ll).equals(p)&&!l3.getIntersectionpoint(ll).equals(l5.getIntersectionpoint(ll))) {
                if(ll.isOnline(this.e)||ll.isOnline(this.d)){
                    pentagon small=new pentagon(l3.getIntersectionpoint(ll),l5.getIntersectionpoint(ll),this.a,this.b,this.c);
                    this.soutarea(small.area(small.ps));
                    return;
                }
                else{
                    quadrilateral small=new quadrilateral(l3.getIntersectionpoint(ll),this.d,this.e,l5.getIntersectionpoint(ll));
                    this.soutarea(small.area(small.ps));
                    return;
                }
            } else if (!l4.getIntersectionpoint(ll).equals(p) && !l5.getIntersectionpoint(ll).equals(p)&&!l4.getIntersectionpoint(ll).equals(l5.getIntersectionpoint(ll))) {
                triangle small = new triangle(l4.getIntersectionpoint(ll),this.e,l5.getIntersectionpoint(ll));
                this.soutarea(small.area(small.ps));
                return;
            }
        }
    }

    public boolean outpentagon(Point p){
        double sum=0;
        triangle x=new triangle(this.a,this.b,p);
        triangle y=new triangle(this.b,this.c,p);
        triangle z=new triangle(this.c,this.d,p);
        triangle a=new triangle(this.d,this.e,p);
        triangle b=new triangle(this.e,this.a,p);
        sum=x.area(x.ps)+y.area(y.ps)+z.area(z.ps)+a.area(a.ps)+b.area(b.ps);
        if(Math.abs(this.area(this.ps)-sum)<1e-6){
            return false;
        }
        else {
           return true;
       }
    }
  }

7-2 点线形系列5-凸五边形的计算-2

import java.text.DecimalFormat;
import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int count = 0, cnt = 0;
        String point = sc.nextLine();
        String[] data = null;
        if (point.charAt(0) >= '1' && point.charAt(0) <= '6' && point.charAt(1) == ':') {
            for (int i = 2; i < point.length(); i++) {
                if (point.charAt(i) == ' ') {
                    cnt++;
                }
                if (point.charAt(i) == ',') {
                    count++;
                }
            }
            if (point.charAt(point.length() - 1) == ' ') {
                cnt--;
            }
            if (count - 1 != cnt) {
                System.out.print("Wrong Format");
                return;
            }
            data = point.split(":|,| ");
            for (int i = 1; i < data.length; i++) {
                if (!data[i].matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$")) {
                    System.out.print("Wrong Format");
                    return;
                }
            }
        } else {
            System.out.print("Wrong Format");
            return;
        }
        switch (data[0]) {
            case "4":
                relate(data);
                break;
            case "5":
                Concavearea(data);
                break;
            default:
                outpolygon(data);
                break;
        }
    }
    public static void Ifpentagon(String[] arr) {
        if (arr.length != 11) {
            System.out.print("wrong number of points");
            return;
        }
        int k = 0;
        Point[] num = new Point[5];
        for (int i = 1; i < arr.length; i = i + 2) {
            Point p = new Point(Double.valueOf(arr[i]), Double.valueOf(arr[i + 1]));
            num[k] = p;
            k++;
        }
        pentagon pe=new pentagon(num[0], num[1], num[2], num[3], num[4]);
        if (pe.ISpentagon()){
            System.out.print("true");
        } else {
            System.out.print("false");
        }
    }
    public static boolean onside(Line l, Point a, Point b, Point c) {
        if ((l.side(a) && l.side(b) && l.side(c)) || (!l.side(a) && !l.side(b) && !l.side(c))) {
            return true;
        } else {
            return false;
        }
    }
    public static boolean IfConcavepentagon(Point a,Point b,Point c,Point d,Point e) {
        pentagon pe=new pentagon(a,b,c,d,e);
        if (onside(pe.l1, c, d, e) && onside(pe.l2, a, d, e) && onside(pe.l3, a, b, e)&&
                onside(pe.l4, a, b, c) && onside(pe.l5, b, c, d)) {
            return true;
        } else {
            return false;
        }
    }
    public static int ISpolygon(Point[] num){
        if(num.length==5){
            pentagon pe=new pentagon(num[0],num[1],num[2],num[3],num[4]);
            if(pe.ISpentagon()){
                return 5;
            }
        }else if(num.length==4){
            quadrilateral qu=new quadrilateral(num[0],num[1],num[2],num[3]);
            if(qu.ISQuadrilateral()){
                return 4;
            }
        }else if(num.length==3){
            triangle tr=new triangle(num[0],num[1],num[2]);
            if(tr.IStriangle()){
                return 3;
            }
        }
        return 0;
    }
    public static Point[] caculatepoint(Point[] res1, Point[] res2){
        ArrayList<Point> num=new ArrayList();
        if(res1.length==5&&res2.length==5){
                pentagon a=new pentagon(res1[0],res1[1],res1[2],res1[3],res1[4]);
                pentagon b=new pentagon(res2[0],res2[1],res2[2],res2[3],res2[4]);
                for(int i=0;i<res1.length;i++){
                    if(!b.outpentagon(res1[i])){
                        num.add(res1[i]);
                    }
                    if(!a.outpentagon(res2[i])){
                        num.add(res2[i]);
                    }
                    for(int j=0;j<res2.length;j++){
                        if(a.ls[i].Intersection(b.ls[j])){
                            num.add(a.ls[i].getIntersection(b.ls[j]));
                        }
                    }
                }
            }
        else if(res1.length==5&&res2.length==4||res1.length==4&&res2.length==5){
            if(res1.length<res2.length) {
                Point[] temp = res1.clone();
                res1=res2;
                res2=temp;
            }
            pentagon a=new pentagon(res1[0],res1[1],res1[2],res1[3],res1[4]);
            quadrilateral b=new quadrilateral(res2[0],res2[1],res2[2],res2[3]);
            for(int i=0;i<res1.length;i++){
                if(!b.outquadrilateral(res1[i])){
                    num.add(res1[i]);
                }
            }
            for(int i=0;i<res2.length;i++) {
                if (!a.outpentagon(res2[i])) {
                        num.add(res2[i]);
                    }
                }
                for(int i=0;i<res1.length;i++){
                    for(int j=0;j<res2.length;j++) {
                        if (a.ls[i].Intersection(b.ls[j])) {
                            num.add(a.ls[i].getIntersection(b.ls[j]));
                        }
                    }
                }
        }
        else if(res1.length==5&&res2.length==3||res1.length==3&&res2.length==5){
            if(res1.length<res2.length){
                Point[] temp = res1.clone();
                res1=res2;
                res2=temp;
            }
            pentagon a=new pentagon(res1[0],res1[1],res1[2],res1[3],res1[4]);
            triangle b=new triangle(res2[0],res2[1],res2[2]);
            for(int i=0;i<res1.length;i++){
                if(!b.outtriangle(res1[i])){
                    num.add(res1[i]);
                }
            }
            for(int i=0;i<res2.length;i++) {
                if (!a.outpentagon(res2[i])) {
                    num.add(res2[i]);
                }
            }
            for(int i=0;i<res1.length;i++){
                for(int j=0;j<res2.length;j++) {
                    if (a.ls[i].Intersection(b.ls[j])) {
                        num.add(a.ls[i].getIntersection(b.ls[j]));
                    }
                }
            }
        }
        else if(res1.length==4&&res2.length==4){
            quadrilateral a=new quadrilateral(res1[0],res1[1],res1[2],res1[3]);
            quadrilateral b=new quadrilateral(res2[0],res2[1],res2[2],res2[3]);
            for(int i=0;i<res1.length;i++){
                if(!b.outquadrilateral(res1[i])){
                    num.add(res1[i]);
                }
                if(!a.outquadrilateral(res2[i])){
                    num.add(res2[i]);
                }
                for(int j=0;j<res2.length;j++){
                    if(a.ls[i].Intersection(b.ls[j])){
                        num.add(a.ls[i].getIntersection(b.ls[j]));
                    }
                }
            }
        }
        else if(res1.length==4&&res2.length==3||res1.length==3&&res2.length==4){
            if(res1.length<res2.length){
                Point[] temp = res1.clone();
                res1=res2;
                res2=temp;
            }
            quadrilateral a=new quadrilateral(res1[0],res1[1],res1[2],res1[3]);
            triangle b=new triangle(res2[0],res2[1],res2[2]);
            for(int i=0;i<res1.length;i++){
                if(!b.outtriangle(res1[i])){
                    num.add(res1[i]);
                }
            }
            for(int i=0;i<res2.length;) {
                if (!a.outquadrilateral(res2[i])) {
                    num.add(res2[i]);
                }
            }
            for(int i=0;i<res1.length;i++){
                for(int j=0;j<res2.length;j++) {
                    if (a.ls[i].Intersection(b.ls[j])) {
                        num.add(a.ls[i].getIntersection(b.ls[j]));
                    }
                }
            }
        }
        else if(res1.length==3&&res2.length==3){
            triangle a=new triangle(res1[0],res1[1],res1[2]);
            triangle b=new triangle(res2[0],res2[1],res2[2]);
            for(int i=0;i<res1.length;i++){
                if(!b.outtriangle(res1[i])){
                    num.add(res1[i]);
                }
                if(!a.outtriangle(res2[i])){
                    num.add(res2[i]);
                }
                for(int j=0;j<res2.length;j++){
                    if(a.ls[i].Intersection(b.ls[j])){
                        num.add(a.ls[i].getIntersection(b.ls[j]));
                    }
                }
            }
        }
        return num.toArray(new Point[num.size()]);
    }
    public static void ISConcavepentagon(String[] arr) {
        if (arr.length != 11) {
            System.out.print("wrong number of points");
            return;
        }
        int k = 0;
        Point[] num = new Point[5];
        for (int i = 1; i < arr.length; i = i + 2) {
            Point p = new Point(Double.valueOf(arr[i]), Double.valueOf(arr[i + 1]));
            num[k] = p;
            k++;
        }
        pentagon pe=new pentagon(num[0], num[1], num[2], num[3], num[4]);
        if (!pe.ISpentagon()) {
            System.out.print("not a pentagon");
            return;
        }
        if (IfConcavepentagon(num[0], num[1], num[2], num[3], num[4])) {
            System.out.print("true" + " ");
            System.out.print(new DecimalFormat("0.0##").format(pe.circumference())+" ");
            System.out.print(new DecimalFormat("0.0##").format(pe.area(pe.ps)));
        } else {
            System.out.print("false");
        }
    }
  
    public static void relate(String[] arr) {
        if (arr.length != 21) {
            System.out.print("wrong number of points");
            return;
        }
        Point[] num = new Point[10];
        int k = 0;
        for (int i = 1; i < arr.length; i = i + 2) {
            Point p = new Point(Double.valueOf(arr[i]), Double.valueOf(arr[i + 1]));
            num[k] = p;
            k++;
        }
        Point[] nums1 = new Point[]{num[0], num[1], num[2], num[3], num[4]};
        polygon po1 = new polygon(nums1);
        Point[] res1 = po1.simplypolygon(po1.simplypoints());
        Point[] nums2 = new Point[]{num[5], num[6], num[7], num[8], num[9]};
        polygon po2 = new polygon(nums2);
        Point[] res2 = po2.simplypolygon(po2.simplypoints());
        if (ISpolygon(res1) == 0 || ISpolygon(res2) == 0) {
            System.out.print("not a polygon");
        } else {
            polygon po = new polygon(caculatepoint(res1, res2));
            if (res1.length == 5 && res2.length == 5) {
                pentagon a = new pentagon(res1[0], res1[1], res1[2], res1[3], res1[4]);
                pentagon b = new pentagon(res2[0], res2[1], res2[2], res2[3], res2[4]);
                if (!a.outpentagon(res2[0])&&!a.outpentagon(res2[1])&&!a.outpentagon(res2[2])&&!a.outpentagon(res2[3])&&!a.outpentagon(res2[4])){
                    if(Math.abs(a.area(res1) - b.area(res2)) < 1e-6) {
                        System.out.print("the previous pentagon coincides with the following pentagon");
                    }else if(b.outpentagon(res1[0])&&b.outpentagon(res1[1])&&b.outpentagon(res1[2])&&b.outpentagon(res1[3])&&b.outpentagon(res1[4])){
                        System.out.print("the previous pentagon contains the following pentagon");
                    }
                } else if(!b.outpentagon(res1[0])&&!b.outpentagon(res1[1])&&!b.outpentagon(res1[2])&&!b.outpentagon(res1[3])&&!b.outpentagon(res1[4])) {
                    if(a.outpentagon(res2[0])&&a.outpentagon(res2[1])&&a.outpentagon(res2[2])&&a.outpentagon(res2[3])&&a.outpentagon(res2[4])) {
                        System.out.print("the previous pentagon is inside the following pentagon");
                    }
                } else if(a.outpentagon(res2[0])&&a.outpentagon(res2[1])&&a.outpentagon(res2[2])&&a.outpentagon(res2[3])&&a.outpentagon(res2[4])){
                       if(b.outpentagon(res1[0])&&b.outpentagon(res1[1])&&b.outpentagon(res1[2])&&b.outpentagon(res1[3])&&b.outpentagon(res1[4])) {
                           System.out.print("no overlapping area between the previous pentagon and the following pentagon");
                       }
                } else if (po.simplypoints().size() == 1 || po.simplypoints().size() == 2) {
                        System.out.print("the previous pentagon is connected to the following pentagon");
                } else{
                    System.out.print("the previous pentagon is interlaced with the following pentagon");
                }
            } else if (res1.length == 5 && res2.length == 4) {
                pentagon a = new pentagon(res1[0], res1[1], res1[2], res1[3], res1[4]);
                quadrilateral b = new quadrilateral(res2[0], res2[1], res2[2], res2[3]);
                if (!a.outpentagon(res2[0])&&!a.outpentagon(res2[1])&&!a.outpentagon(res2[2])&&!a.outpentagon(res2[3])){
                        if(b.outquadrilateral(res1[0])&&b.outquadrilateral(res1[1])&&b.outquadrilateral(res1[2])&&b.outquadrilateral(res1[3])&&b.outquadrilateral(res1[4])) {
                            System.out.print("the previous pentagon contains the following quadrilateral");
                        }
                    } else if (!b.outquadrilateral(res1[0])&&!b.outquadrilateral(res1[1])&&!b.outquadrilateral(res1[2])&&!b.outquadrilateral(res1[3])&&!b.outquadrilateral(res1[4])) {
                        if(a.outpentagon(res2[0])&&a.outpentagon(res2[1])&&a.outpentagon(res2[2])&&a.outpentagon(res2[3])) {
                            System.out.print("the previous pentagon is inside the following quadrilateral");
                        }
                    } else if(a.outpentagon(res2[0])&&a.outpentagon(res2[1])&&a.outpentagon(res2[2])&&a.outpentagon(res2[3])){
                        if(b.outquadrilateral(res1[0])&&b.outquadrilateral(res1[1])&&b.outquadrilateral(res1[2])&&b.outquadrilateral(res1[3])&&b.outquadrilateral(res1[4])) {
                            System.out.print("no overlapping area between the previous pentagon and the following quadrilateral");
                        }
                    } else if (po.simplypoints().size() == 1 || po.simplypoints().size() == 2) {
                        System.out.print("the previous pentagon is connected to the following quadrilateral");
                    } else {
                    System.out.print("the previous pentagon is interlaced with the following quadrilateral");
                }
            } else if (res1.length == 5 && res2.length == 3) {
                pentagon a = new pentagon(res1[0], res1[1], res1[2], res1[3], res1[4]);
                triangle b = new triangle(res2[0], res2[1], res2[2]);
                 if (!a.outpentagon(res2[0])&&!a.outpentagon(res2[1])&&!a.outpentagon(res2[2])) {
                     if(b.outtriangle(res1[0])&&b.outtriangle(res1[1])&&b.outtriangle(res1[2])&&b.outtriangle(res1[3])&&b.outtriangle(res1[4])) {
                         System.out.print("the previous pentagon contains the following triangle");
                     }
                 } else if (!b.outtriangle(res1[0])&&!b.outtriangle(res1[1])&&!b.outtriangle(res1[2])&&!b.outtriangle(res1[3])&&!b.outtriangle(res1[4])){
                        if(a.outpentagon(res2[0])&&a.outpentagon(res2[1])&&a.outpentagon(res2[2])) {
                            System.out.print("the previous pentagon is inside the following triangle");
                        }
                    } else if(a.outpentagon(res2[0])&&a.outpentagon(res2[1])&&a.outpentagon(res2[2])){
                        if(b.outtriangle(res1[0])&&b.outtriangle(res1[1])&&b.outtriangle(res1[2])&&b.outtriangle(res1[3])&&b.outtriangle(res1[4])) {
                            System.out.print("no overlapping area between the previous pentagon and the following triangle");
                        }
                    }else if (po.simplypoints().size() == 1 || po.simplypoints().size() == 2) {
                        System.out.print("the previous pentagon is connected to the following triangle");
                    } else {
                    System.out.print("the previous pentagon is interlaced with the following triangle");
                }
            } else if (res1.length == 4 && res2.length == 5) {
                quadrilateral a = new quadrilateral(res1[0], res1[1], res1[2], res1[3]);
                pentagon b = new pentagon(res2[0], res2[1], res2[2], res2[3], res2[4]);
                if(!a.outquadrilateral(res2[0])&&!a.outquadrilateral(res2[1])&&!a.outquadrilateral(res2[2])&&!a.outquadrilateral(res2[3])&&!a.outquadrilateral(res2[4])) {
                        if(b.outpentagon(res1[0])&&b.outpentagon(res1[1])&&b.outpentagon(res1[2])&&b.outpentagon(res1[3])) {
                            System.out.print("the previous quadrilateral contains the following pentagon");
                        }
                    } else if (!b.outpentagon(res1[0])&&!b.outpentagon(res1[1])&&!b.outpentagon(res1[2])&&!b.outpentagon(res1[3])) {
                        if(a.outquadrilateral(res2[0])&&a.outquadrilateral(res2[1])&&a.outquadrilateral(res2[2])&&a.outquadrilateral(res2[3])&&a.outquadrilateral(res2[4])) {
                            System.out.print("the previous quadrilateral is inside the following pentagon");
                        }
                    } else if(a.outquadrilateral(res2[0])&&a.outquadrilateral(res2[1])&&a.outquadrilateral(res2[2])&&a.outquadrilateral(res2[3])&&a.outquadrilateral(res2[4])){
                        if(b.outpentagon(res1[0])&&b.outpentagon(res1[1])&&b.outpentagon(res1[2])&&b.outpentagon(res1[3])&&po.simplypoints().isEmpty()) {
                            System.out.print("no overlapping area between the previous quadrilateral and the following pentagon");
                        }
                    } else if (po.simplypoints().size() == 1 || po.simplypoints().size() == 2) {
                        System.out.print("the previous quadrilateral is connected to the following pentagon");
                    } else {
                    System.out.print("the previous quadrilateral is interlaced with the following pentagon");
                }
            } else if (res1.length == 4 && res2.length == 4) {
                quadrilateral a = new quadrilateral(res1[0], res1[1], res1[2], res1[3]);
                quadrilateral b = new quadrilateral(res2[0], res2[1], res2[2], res2[3]);
                if(!a.outquadrilateral(res2[0])&&!a.outquadrilateral(res2[1])&&!a.outquadrilateral(res1[2])&&!a.outquadrilateral(res2[3])) {
                       if(Math.abs(a.area(res1) - b.area(res2)) < 1e-6){
                           System.out.print("the previous quadrilateral coincides with the following quadrilateral");
                       } else if(b.outquadrilateral(res1[0])&&b.outquadrilateral(res1[1])&&b.outquadrilateral(res1[2])&&b.outquadrilateral(res1[3])){
                           System.out.print("the previous quadrilateral contains the following quadrilateral");
                       }
                    } else if (!b.outquadrilateral(res1[0])&&!b.outquadrilateral(res1[1])&&!b.outquadrilateral(res1[2])&&!b.outquadrilateral(res1[3])) {
                        if(a.outquadrilateral(res2[0])&&a.outquadrilateral(res2[1])&&a.outquadrilateral(res2[2])&&a.outquadrilateral(res2[3])) {
                            System.out.print("the previous quadrilateral is inside the following quadrilateral");
                        }
                    } else if(a.outquadrilateral(res2[0])&&a.outquadrilateral(res2[1])&&a.outquadrilateral(res2[2])&&a.outquadrilateral(res2[3])){
                        if(b.outquadrilateral(res1[0])&&b.outquadrilateral(res1[1])&&b.outquadrilateral(res1[2])&&b.outquadrilateral(res1[3])&&po.simplypoints().isEmpty()) {
                            System.out.print("no overlapping area between the previous quadrilateral and the following quadrilateral");
                        }
                    } else if (po.simplypoints().size() == 1 || po.simplypoints().size() == 2) {
                        System.out.print("the previous quadrilateral is connected to the following quadrilateral");
                    } else {
                    System.out.print("the previous quadrilateral is interlaced with the following quadrilateral");
                }
            } else if (res1.length == 4 && res2.length == 3) {
                quadrilateral a = new quadrilateral(res1[0], res1[1], res1[2], res1[3]);
                triangle b = new triangle(res2[0], res2[1], res2[2]);
                    if (!a.outquadrilateral(res2[0])&&!a.outquadrilateral(res2[1])&&!a.outquadrilateral(res2[2])) {
                        if(b.outtriangle(res1[0])&&b.outtriangle(res1[1])&&b.outtriangle(res1[2])&&b.outtriangle(res1[3])) {
                            System.out.print("the previous quadrilateral contains the following triangle");
                        }
                    } else if (!b.outtriangle(res1[0])&&!b.outtriangle(res1[1])&&!b.outtriangle(res1[2])&&!b.outtriangle(res1[3])) {
                        if(a.outquadrilateral(res2[0])&&a.outquadrilateral(res2[1])&&a.outquadrilateral(res2[2])) {
                            System.out.print("the previous quadrilateral is inside the following triangle");
                        }
                    } else if(a.outquadrilateral(res2[0])&&a.outquadrilateral(res2[1])&&a.outquadrilateral(res2[2])){
                        if(b.outtriangle(res1[0])&&b.outtriangle(res1[1])&&b.outtriangle(res1[2])&&b.outtriangle(res1[3])&&po.simplypoints().isEmpty()) {
                            System.out.print("no overlapping area between the previous quadrilateral and the following triangle");
                        }
                    }else if (po.simplypoints().size() == 1 || po.simplypoints().size() == 2) {
                            System.out.print("the previous quadrilateral is connected to the following triangle");
                    }else{
                        System.out.print("the previous quadrilateral is interlaced with the following triangle");
                    }
                }else if (res1.length == 3 && res2.length == 5) {
                triangle a = new triangle(res1[0], res1[1], res1[2]);
                pentagon b = new pentagon(res2[0], res2[1], res2[2],res2[3],res2[4]);
                    if (!a.outtriangle(res2[0])&&!a.outtriangle(res2[1])&&!a.outtriangle(res2[2])&&!a.outtriangle(res2[3])&&!a.outtriangle(res2[4])){
                        if(b.outpentagon(res1[0])&&b.outpentagon(res1[1])&&b.outpentagon(res1[2])) {
                            System.out.print("the previous triangle contains the following pentagon");
                        }
                    } else if (!b.outpentagon(res1[0])&&!b.outpentagon(res1[1])&&!b.outpentagon(res1[2])) {
                        if(a.outtriangle(res2[0])&&a.outtriangle(res2[1])&&a.outtriangle(res2[2])&&a.outtriangle(res2[3])&&a.outtriangle(res2[4])) {
                            System.out.print("the previous triangle is inside the following pentagon");
                        }
                    } else if(a.outtriangle(res2[0])&&a.outtriangle(res2[1])&&a.outtriangle(res2[2])&&a.outtriangle(res2[3])&&a.outtriangle(res2[4])){
                        if(b.outpentagon(res1[0])&&b.outpentagon(res1[1])&&b.outpentagon(res1[2])&&po.simplypoints().isEmpty()) {
                            System.out.print("no overlapping area between the previous triangle and the following pentagon");
                        }
                    }else if (po.simplypoints().size() == 1 || po.simplypoints().size() == 2) {
                        System.out.print("the previous triangle is connected to the following pentagon");
                    } else {
                        System.out.print("the previous triangle is interlaced with the following pentagon");
                    }
                }else if (res1.length == 3 && res2.length == 4) {
                triangle a = new triangle(res1[0], res1[1], res1[2]);
                quadrilateral b = new quadrilateral(res2[0], res2[1], res2[2],res2[3]);
                    if(!a.outtriangle(res2[0])&&!a.outtriangle(res2[1])&&!a.outtriangle(res2[2])&&!a.outtriangle(res2[3])) {
                        if(b.outquadrilateral(res1[0])&&b.outquadrilateral(res1[1])&&b.outquadrilateral(res1[2])) {
                            System.out.print("the previous triangle contains the following quadrilateral");
                        }
                    }else if (!b.outquadrilateral(res1[0])&&!b.outquadrilateral(res1[1])&&!b.outquadrilateral(res1[2])) {
                        if(a.outtriangle(res2[0])&&a.outtriangle(res2[1])&&a.outtriangle(res2[2])&&a.outtriangle(res2[3])) {
                            System.out.print("the previous triangle is inside the following quadrilateral");
                        }
                    }else if(b.outquadrilateral(res1[0])&&b.outquadrilateral(res1[1])&&b.outquadrilateral(res1[2])){
                        if(a.outtriangle(res2[0])&&a.outtriangle(res2[1])&&a.outtriangle(res2[2])&&a.outtriangle(res2[3])&&po.simplypoints().isEmpty()) {
                            System.out.print("no overlapping area between the previous triangle and the following quadrilateral");
                        }
                    }else if (po.simplypoints().size() == 1 || po.simplypoints().size() == 2) {
                            System.out.print("the previous triangle is connected to the following quadrilateral");
                    } else {
                        System.out.print("the previous triangle is interlaced with the following quadrilateral");
                    }
            } else if (res1.length == 3 && res2.length == 3) {
                triangle a = new triangle(res1[0], res1[1], res1[2]);
                triangle b = new triangle(res2[0], res2[1], res2[2]);
                if (!a.outtriangle(res2[0])&&!a.outtriangle(res2[1])&&!a.outtriangle(res2[2])) {
                    if(Math.abs(a.area(res1) - b.area(res2)) < 1e-6){
                        System.out.print("the previous triangle coincides with the following triangle");
                    } else if(b.outtriangle(res1[0])&&b.outtriangle(res1[1])&&b.outtriangle(res1[2])){
                        System.out.print("the previous triangle contains the following triangle");
                    }
                } else if (!b.outtriangle(res1[0])&&!b.outtriangle(res1[1])&&!b.outtriangle(res1[2])) {
                    if(a.outtriangle(res2[0])&&a.outtriangle(res2[1])&&a.outtriangle(res2[2])) {
                        System.out.print("the previous triangle is inside the following triangle");
                    }
                } else if(a.outtriangle(res2[0])&&a.outtriangle(res2[1])&&a.outtriangle(res2[2])){
                    if(b.outtriangle(res1[0])&&b.outtriangle(res1[1])&&b.outtriangle(res1[2])&&po.simplypoints().isEmpty()) {
                        System.out.print("no overlapping area between the previous triangle and the following triangle");
                    }
                } else if (po.simplypoints().size() == 1 || po.simplypoints().size() == 2) {
                        System.out.print("the previous triangle is connected to the following triangle");
                } else{
                    System.out.print("the previous triangle is interlaced with the following triangle");
                }
            }
        }
    }
    
    public static void Concavearea(String[] arr) {
        if (arr.length != 21) {
            System.out.print("wrong number of points");
            return;
        }
        Point[] num = new Point[10];
        int k = 0;
        for (int i = 1; i < arr.length; i = i + 2) {
            Point p = new Point(Double.valueOf(arr[i]), Double.valueOf(arr[i + 1]));
            num[k] = p;
            k++;
        }
        Point[] nums1 = new Point[]{num[0], num[1], num[2], num[3], num[4]};
        polygon po1 = new polygon(nums1);
        Point[] res1 = po1.simplypolygon(po1.simplypoints());
        Point[] nums2 = new Point[]{num[5], num[6], num[7], num[8], num[9]};
        polygon po2 = new polygon(nums2);
        Point[] res2 = po2.simplypolygon(po2.simplypoints());
        if (ISpolygon(res1) == 0 || ISpolygon(res2) == 0) {
            System.out.print("not a polygon");
        } else{
            polygon po = new polygon(caculatepoint(res1, res2));
            double area=po.area(po.sortpoints(po.simplypoints()));
            System.out.print(new DecimalFormat("0.0##").format(area));
        }
    }

    public static void  outpolygon(String[] arr) {
        if (arr.length != 13) {
            System.out.print("wrong number of points");
            return;
        }
        Point[] num = new Point[6];
        int k = 0;
        for (int i = 1; i < arr.length; i = i + 2) {
            Point p = new Point(Double.valueOf(arr[i]), Double.valueOf(arr[i + 1]));
            num[k] = p;
            k++;
        }
        Point[] nums = new Point[]{num[1], num[2], num[3], num[4], num[5]};
        polygon po = new polygon(nums);
        Point[] res = po.simplypolygon(po.simplypoints());
        switch (ISpolygon(res)) {
            case 3:
                triangle tr = new triangle(res[0], res[1], res[2]);
                if (tr.l1.isOnline(num[0]) || tr.l2.isOnline(num[0]) || tr.l3.isOnline(num[0])) {
                    System.out.print("on the triangle");
                } else if (tr.outtriangle(num[0])) {
                    System.out.print("outof the triangle");
                } else {
                    System.out.print("in the triangle");
                }
                break;
            case 4:
                quadrilateral qu = new quadrilateral(res[0], res[1], res[2], res[3]);
                if (qu.l1.isOnline(num[0]) || qu.l2.isOnline(num[0]) || qu.l3.isOnline(num[0]) || qu.l4.isOnline(num[0])) {
                    System.out.print("on the quadrilateral");
                    return;
                } else if (qu.outquadrilateral(num[0])) {
                    System.out.print("outof the quadrilateral");
                } else {
                    System.out.print("in the quadrilateral");
                }
                break;
            case 5:
                pentagon pe = new pentagon(res[0], res[1], res[2], res[3], res[4]);
                if (pe.l1.isOnline(num[0]) || pe.l2.isOnline(num[0]) || pe.l3.isOnline(num[0]) || pe.l4.isOnline(num[0]) || pe.l5.isOnline(num[0])) {
                    System.out.print("on the pentagon");
                    return;
                } else if (pe.outpentagon(num[0])) {
                    System.out.print("outof the pentagon");
                } else {
                    System.out.print("in the pentagon");
                }
                break;
            default:
                System.out.print("not a polygon");
                break;
        }
    }
}

class Point {
    public double x;
    public double y;
    public Point() {
    }//构造函数
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public void getPoint(double x, double y) {
        this.x = x;
        this.y = y;
    }
    public boolean equals(Point p){
        boolean flag = false;
        if (Math.abs(this.x-p.x)<1e-6&&Math.abs(this.y-p.y)<1e-6){
            flag = true;
        }
        return flag;
    }
    public double getDistance(Point p) {
        return Math.sqrt((Math.pow((Math.abs(p.x - this.x)), 2) + Math.pow((Math.abs(p.y - this.y)), 2)));
    }
}

class Line {
    public Point p1;
    public Point p2;
    public Line() {
    }
    public Line(Point p1, Point p2) {
        this.p1 = p1;
        this.p2 = p2;
    }
    public double segment() {
        return p1.getDistance(p2);
    }
    public void getpoints(Point p1, Point p2) {
        this.p1 = p1;
        this.p2 = p2;
    }
    public boolean side(Point p) {
        double a = this.p2.y - this.p1.y;
        double b = this.p1.x - this.p2.x;
        double c = this.p2.x * this.p1.y - this.p1.x * this.p2.y;
        if (a * p.x + b * p.y + c > 0) {
            /*在下方*/
            return true;
        } else {
            /*在上方*/
            return false;
        }
    }
    public double getSlope() {
        if (p1.x == p2.x) {
            return Double.POSITIVE_INFINITY;
        } else {
            return (p2.y - p1.y) / (p2.x - p1.x);
        }
    }
    public boolean iscoincideline(Point p) {
        double a = this.p2.y - this.p1.y;
        double b = this.p1.x - this.p2.x;
        double c = this.p2.x * this.p1.y - this.p1.x * this.p2.y;
        if (a * p.x + b * p.y + c == 0) {
            return true;
        }
        return false;
    }
    public boolean isOnline(Point p) {
        double a = this.p2.y - this.p1.y;
        double b = this.p1.x - this.p2.x;
        double c = this.p2.x * this.p1.y - this.p1.x * this.p2.y;
        double x1 = Math.max(this.p1.x, this.p2.x);
        double x2 = Math.min(this.p1.x, this.p2.x);
        double y1 = Math.max(this.p1.y, this.p2.y);
        double y2 = Math.min(this.p1.y, this.p2.y);
        if(p.equals(this.p1)||p.equals(this.p2)){
            return true;
        }else if ((a * p.x + b * p.y + c == 0) && (p.x <= x1 && p.x >= x2) && (p.y <= y1 && p.y >= y2)) {
            return true;
        }
        return false;
    }
    public boolean isParallel(Line l) {
        double ax = l.p2.x - l.p1.x;
        double ay = l.p2.y - l.p1.y;
        double bx = this.p2.x - this.p1.x;
        double by = this.p2.y - this.p1.y;
        if (ax * by - bx * ay == 0) {
            return true;
        } else {
            return false;
        }
    }
    public Point getIntersectionpoint(Line l) {
        Point p = new Point(65536.0, 65536.0);
        double A = this.p2.y - this.p1.y;
        double B = this.p1.x - this.p2.x;
        double C = this.p2.x * this.p1.y - this.p1.x * this.p2.y;
        double a = l.p2.y - l.p1.y;
        double b = l.p1.x - l.p2.x;
        double c = l.p2.x * l.p1.y - l.p1.x * l.p2.y;
        if (this.isParallel(l)) {
            return p;
        }
        if (A == 0) {
            if (a == 0) {
                return p;
            } else if (b == 0) {
                if ((l.p1.x <this.p1.x && l.p1.x >this.p2.x) || (l.p1.x > this.p1.x && l.p1.x <this.p2.x)||(Math.abs(l.p1.x-this.p1.x)<1e-6)||(Math.abs(l.p1.x-this.p2.x)<1e-6)) {
                    p.getPoint(l.p1.x, this.p1.y);
                    return p;
                }
            } else {
                double px = (b * this.p1.y + c) / (-a);
                if ((px < this.p1.x && px > this.p2.x) || (px > this.p1.x && px < this.p2.x)||(Math.abs(px-this.p1.x)<1e-6)||(Math.abs(px-this.p2.x)<1e-6)) {
                    p.getPoint(px, this.p1.y);
                    return p;
                }
            }
        } else if (B == 0) {
            if (a == 0) {
                if ((l.p1.y < this.p1.y && l.p1.y > this.p2.y) || (l.p1.y > this.p1.y && l.p1.y < this.p2.y)||(Math.abs(l.p1.y-this.p1.y)<1e-6)||(Math.abs(l.p1.y-this.p2.y)<1e-6)) {
                    p.getPoint(this.p1.x, l.p1.y);
                    return p;
                }
            } else if (b == 0) {
                return p;
            } else {
                double py = (a * this.p1.x + c) / (-b);
                if ((py < this.p1.y && py > this.p2.y) || (py > this.p1.y && py < this.p2.y)||(Math.abs(py-this.p1.y)<1e-6)||(Math.abs(py-this.p2.y)<1e-6)) {
                    p.getPoint(this.p1.x, py);
                    return p;
                }
            }
        } else {
            if (a == 0) {
                double px = (B * l.p1.y + C) / (-A);
                if ((px <this.p1.x && px > this.p2.x) || (px > this.p1.x && px < this.p2.x)||(Math.abs(px-this.p1.x)<1e-6)||(Math.abs(px-this.p2.x)<1e-6)) {
                    p.getPoint(px, l.p1.y);
                    return p;
                }
            } else if (b == 0) {
                double py = (A * l.p1.x + C) / (-B);
                if ((py < this.p1.y && py > this.p2.y) || (py > this.p1.y && py < this.p2.y)||(Math.abs(py-this.p1.y)<1e-6)||(Math.abs(py-this.p2.y)<1e-6)) {
                    p.getPoint(l.p1.x, py);
                    return p;
                }
            } else {
                double px = (b * C - B * c) / (a * B - A * b);
                if ((px < this.p1.x && px > this.p2.x) || (px > this.p1.x && px < this.p2.x)||(Math.abs(px-this.p1.x)<1e-6)||(Math.abs(px-this.p2.x)<1e-6)) {
                    double py = (A * px + C) / (-B);
                    p.getPoint(px, py);
                    return p;
                }
            }
        }
        return p;
    }

    public Point getIntersection(Line l) {
        Point p = new Point(65536.0, 65536.0);
        if (this.isParallel(l)) {
            return p;
        }
        if (this.p1.equals(l.p1) || this.p1.equals(l.p2)) {
            return p1;
        }
        if (this.p2.equals(l.p1) || this.p2.equals(l.p2)) {
            return p2;
        }
        Point cross_point = new Point();
        double x, y;
        double a1 = this.p2.y - this.p1.y;
        double b1 = this.p1.x - this.p2.x;
        double a2 = l.p2.y - l.p1.y;
        double b2 = l.p1.x - l.p2.x;
        double c1 = this.p2.x * this.p1.y - this.p1.x * this.p2.y;
        double c2 = l.p2.x * l.p1.y - l.p1.x * l.p2.y;
        cross_point.x = (b2 * c1 - b1 * c2) / (a2 * b1 - a1 * b2);
        cross_point.y = (a1 * c2 - a2 * c1) / (a2 * b1 - a1 * b2);
        return cross_point;
    }

    public boolean Intersection(Line l) {
        Point p = this.getIntersection(l);
        double x = p.x;
        double y = p.y;
        double x1 = Math.max(this.p1.x, this.p2.x);
        double x2 = Math.max(l.p1.x, l.p2.x);
        double x3 = Math.min(this.p1.x, this.p2.x);
        double x4 = Math.min(l.p1.x, l.p2.x);
        if ((x >= x3 && x <= x1) && (x >= x4 && x <= x2)) {
            return true;
        } else {
            return false;
        }
    }
}

class polygon {
    public Point[] ps;
    public polygon() {
    }
    public polygon(Point[] num) {
        this.ps = num;
    }
    public ArrayList<Point> simplypoints() {
        ArrayList<Point> nums = new ArrayList();
        nums.add(this.ps[0]);
        for (int i = 0; i < this.ps.length; i++) {
            boolean flag = true;
            for (int j = 0; j < nums.size(); j++) {
                if (this.ps[i].equals(nums.get(j))) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                nums.add(this.ps[i]);
            }
        }
        return nums;
    }

    public Point[] sortpoints(ArrayList<Point> num){
        double x=0,y=0;
        Point temp=new Point();
        for (int i=0;i< num.size();i++){
            x+=num.get(i).x;
            y+=num.get(i).y;
        }
        Point p=new Point(x/ num.size(),y/ num.size());
            for (int i = 0; i < num.size()-1; i++) {  //排序的趟数 n-1趟
                for (int j = 0; j < num.size() - 1 - i; j++) { //两两排序 走完一遍最大的放后面
                    if (Math.atan2(num.get(j).y - p.y, num.get(j).x - p.x) > Math.atan2(num.get(j + 1).y - p.y, num.get(j + 1).x - p.x)) {
                        Collections.swap(num,j,j+1);
                    }
                }
            }
         return num.toArray(new Point[num.size()]);
    }
    public Point[] simplypolygon(ArrayList<Point> nums){
      for(int i=0;i<nums.size();){
          Line ll=new Line();
          if(i==nums.size()-1){
              ll.getpoints(nums.get(i-1),nums.get(0));
          }
          else if(i==0){
              ll.getpoints(nums.get(i+1),nums.get(nums.size()-1));
          }else{
              ll.getpoints(nums.get(i - 1), nums.get(i + 1));
          }
          if(ll.isOnline(nums.get(i))){
              nums.remove(i);
          }else{
              i++;
          }
        }
        return nums.toArray(new Point[nums.size()]);
    }
    public double area(Point[] num){
        double area = 0;
        for (int i = 0; i < num.length; i++) {
            if (i != num.length - 1) {
                area += num[i].x * num[i + 1].y - num[i].y * num[i + 1].x;
            } else {
                area += num[i].x * num[0].y - num[i].y * num[0].x;
            }
        }
        return Math.abs(area) / 2;
    }
}

class triangle extends polygon{
    public Point a;public Point b;public Point c;
    public Line l1;public Line l2;public Line l3;
    public Point[] ps;
    public Line[] ls;

    public triangle() {
    }

    public triangle(Point a, Point b, Point c) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.ps=new Point[]{a,b,c};
        this.length();
    }

    public void length() {
        this.l1 = new Line(this.a, this.b);
        this.l2 = new Line(this.b, this.c);
        this.l3 = new Line(this.c, this.a);
        this.ls=new Line[]{this.l1,this.l2,this.l3};
    }

    public boolean IStriangle() {
        double[] lines = {l1.segment(), l2.segment(), l3.segment()};
        Arrays.sort(lines);
        if (lines[0] + lines[1] > lines[2]) {
            return true;
        } else {
            return false;
        }
    }

    public double circumference() {
        return l1.segment() + l2.segment() + l3.segment();
    }

    public boolean outtriangle(Point p){
        double sum=0;
        if(this.l1.isOnline(p)||this.l2.isOnline(p)||this.l3.isOnline(p)){
            return false;
        }else{
            triangle x=new triangle(this.a,this.b,p);
            triangle y=new triangle(this.b,this.c,p);
            triangle z=new triangle(this.a,p,this.c);
            sum=x.area(x.ps)+y.area(y.ps)+z.area(z.ps);
            if(Math.abs(this.area(this.ps)-sum)<1e-6){
                return false;
            } else {
                return true;
            }
        }
    }
}

class quadrilateral extends polygon {
    public Point a;public Point b;
    public Point c;public Point d;
    public Line l1;public Line l2;
    public Line l3;public Line l4;
    public Line ll1;public Line ll2;
    public Point[] ps;
    public Line[] ls;

    public quadrilateral(){
    }
    public quadrilateral(Point a, Point b, Point c, Point d) {
        this.a=a;this.b=b;
        this.c=c;this.d=d;
        this.ps=new Point[]{a,b,c,d};
        this.length();
    }

    public void length(){
        this.l1=new Line(this.a,this.b);
        this.l2=new Line(this.b,this.c);
        this.l3=new Line(this.c,this.d);
        this.l4=new Line(this.d,this.a);
        this.ls=new Line[]{this.l1,this.l2,this.l3,this.l4};
        this.ll1=new Line(this.a,this.c);
        this.ll2=new Line(this.b,this.d);
    }

    public boolean ISQuadrilateral() {//是否为四边形
        if ((l1.getSlope() == l2.getSlope()) || (l2.getSlope() == l3.getSlope())||(l3.getSlope() == l4.getSlope()) || (l1.getSlope() == l4.getSlope()) ) {
            return false;
        }
        if (!l1.isParallel(l3)) {
            if (l1.Intersection(l3)) {
                return false;
            }
        }
        if (!l2.isParallel(l4)) {
            if (l2.Intersection(l4)) {
                return false;
            }
        }
        return true;
    }

    public double circumference() {
        return l1.segment() + l2.segment() + l3.segment() + l4.segment();
    }

    public void soutarea(double area1){
        double area2=this.area(this.ps)-area1;
        if(area2<area1){
            double temp = area1;
            area1 = area2;
            area2 = temp;
        }
        System.out.print("2 "+new DecimalFormat("0.0##").format(area1) +" "+new DecimalFormat("0.0##").format(area2));
    }

    public boolean outquadrilateral(Point p){
        double sum=0;
        if(this.l1.isOnline(p)||this.l2.isOnline(p)||this.l3.isOnline(p)||this.l4.isOnline(p)){
            return false;
        } else{
            triangle x=new triangle(this.a,this.b,p);
            triangle y=new triangle(this.b,this.c,p);
            triangle z=new triangle(this.c,this.d,p);
            triangle a=new triangle(this.d,this.a,p);
            sum=x.area(x.ps)+y.area(y.ps)+z.area(z.ps)+a.area(a.ps);
            if(Math.abs(this.area(this.ps)-sum)<1e-6){
                return false;
            }
            else {
                return true;
            }
        }
    }
}

class pentagon extends polygon{
    public Point a;public Point b;
    public Point c;public Point d;
    public Point e;public Line l1;
    public Line l2;public Line l3;
    public Line l4;public Line l5;
    public Line ll1;public Line ll2;
    public Line ll3;public Line ll4;
    public Line ll5;public Point[] ps;
    public Line[] ls;
    public pentagon(){}
    public pentagon(Point a,Point b,Point c,Point d,Point e){
        this.a=a;this.b=b;
        this.c=c;this.d=d;
        this.e=e;
        this.length();
        this.ps=new Point[]{a,b,c,d,e};
    }

    public void length(){
        this.l1=new Line(this.a,this.b);
        this.l2=new Line(this.b,this.c);
        this.l3=new Line(this.c,this.d);
        this.l4=new Line(this.d,this.e);
        this.l5=new Line(this.e,this.a);
        this.ls=new Line[]{this.l1,this.l2,this.l3,this.l4,this.l5};
        this.ll1=new Line(this.a,this.c);
        this.ll2=new Line(this.a,this.d);
        this.ll3=new Line(this.b,this.d);
        this.ll4=new Line(this.b,this.e);
        this.ll5=new Line(this.c,this.e);
    }
    public boolean ISpentagon() {
        if (l1.isParallel(l2) || l1.isParallel(l5) || l2.isParallel(l3) || l3.isParallel(l4) || l4.isParallel(l5)) {
            return false;
        } else if (l1.Intersection(l3) || l1.Intersection(l4) || l2.Intersection(l4) || l2.Intersection(l5) || l3.Intersection(l5)) {
            return false;
        } else {
            return true;
        }
    }
    public double circumference() {
        return l1.segment() + l2.segment() + l3.segment() + l4.segment()+l5.segment();
    }

    public void soutarea(double area1){
        double area2=this.area(this.ps)-area1;
        if(area2<area1){
            double temp = area1;
            area1 = area2;
            area2 = temp;
        }
        System.out.print("2 "+new DecimalFormat("0.0##").format(area1) +" "+new DecimalFormat("0.0##").format(area2));
    }

    public boolean outpentagon(Point p){
        double sum=0;
        if(this.l1.isOnline(p)||this.l2.isOnline(p)||this.l3.isOnline(p)||this.l4.isOnline(p)||this.l5.isOnline(p)){
            return false;
        }else {
            triangle x = new triangle(this.a, this.b, p);
            triangle y = new triangle(this.b, this.c, p);
            triangle z = new triangle(this.c, this.d, p);
            triangle a = new triangle(this.d, this.e, p);
            triangle b = new triangle(this.e, this.a, p);
            sum = x.area(x.ps) + y.area(y.ps) + z.area(z.ps) + a.area(a.ps) + b.area(b.ps);
            if (Math.abs(this.area(this.ps) - sum) < 1e-6) {
                return false;
            } else {
                return true;
            }
        }
    }
}

类图：

分析报告：

 代码分析与处理：

1.有关输入的判断与题目集四边形基本无差（详情可参考上面）。

2.运用switch语句，根据所读入的数字确定为何种情况，根据不同的情况判断输入数据的点数以及坐标是否重合，判断是否点的数量符合要求，输入的数据是否能够构成正常的多边形等等。

3.若为情况1则断是否是五边形，方法与判断四边形类似，运用判断邻边不能平行，对边不能相交（或交点不能在两对边线段范围内）。

4.若为情况2则判断是凹五边形（false）还是凸五边形(true)，可通过判断五边形的任意一条边，其余所有点是否都在同一侧，若均满足为凸五边形，反之为凹五边形，通过多边形类的面积计算方法计算。

5.为情况3或4或5或6时，需要对输入的点进行判断判断（点是否重合以及点是否在其相邻领边上，去除冗余点后），判断是否构成多边形以及具体为（五边形或四边形或三角形），以便于后续做题。

6.若为情况3则计算两个点所在的直线与所构成的多边形（五边形或四边形或三角形）相交的交点数量，如果交点有两个，则按面积大小依次输出多边形（五边形或四边形或三角形）被直线分割成两部分的面积，否则直接输出交点的个数。若直线与多边形（五边形或四边形或三角形）一条线重合，输出"the line is coincide with one of the lines",注意细心考虑，两对边交点重合的情况。

7.若为情况4则输入十个点坐标，前、后五个点分别构成一个凸多边形（三角形、四边形、五边形），判断它们两个之间的关系，根据得出的不同关系情况输出不同的结果语句。若为：

1.分离（完全无重合点）通过判断两多边形双方所有点均不在对方内部。

2.连接（只有一个点或一条边重合）通过判断若只有俩交点且只有一线相交或只有一交点只有一顶点重合。

3.完全重合，通过判断两多边形的所有点是否重合（在此基础上其实也可加上判断它们面积是否相等，不过加不加好像没啥影响。。。）。

4.被包含（前一个多边形在后一个多边形的内部）判断前一多边形的所有点是否在后一多边形内部。

5.交错，情况太多多多了。。。直接else吧。

6.包含（后一个多边形在前一个多边形的内部）判断后一多边形的所有点是否在前一多边形内部。

8.若为情况5则，前、后五个点分别构成一个凸多边形（三角形、四边形、五边形），输出两个多边形公共区域的面积。统计两多边形所有点还有线与线的交点，计算所构成的多边形的面积即为公共区域面积。

9.若为情况6则使用面积法，将该点连接多边形各个顶点，计算出所构成的所有三角形的面积和与原多边形的面积关系，判断是否在多边形内部。

期中考试

7-1 点与线（类设计）& 7-2 点线面问题重构（继承与多态）&7-3 点线面问题再重构（容器类）

import java.util.ArrayList;
import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        GeometryObject ge=new GeometryObject();
        int choice=sc.nextInt();
        while (choice!=0){
            switch (choice){
                case 1:
                    double x=sc.nextDouble();double y=sc.nextDouble();
                    if(!judge(x)&&!judge(y)){
                        System.out.println("Wrong Format");
                        return;
                    }
                    Point p=new Point(x,y);
                    ge.add(p);
                    break;
                case 2:
                    double a=sc.nextDouble();double b=sc.nextDouble();
                    double c=sc.nextDouble();double d=sc.nextDouble();
                    String color = sc.next();
                    if(!judge(a)&&!judge(b)&&!judge(c)&&!judge(d)){
                        System.out.println("Wrong Format");
                        return;
                    }
                    Point p1 = new Point(a, b);
                    Point p2 = new Point(c, d);
                    Line l=new Line(p1,p2,color);
                    ge.add(l);
                    break;
                case 3:
                    String colour = sc.next();
                    Plane pl = new Plane(colour);
                    ge.add(pl);
                    break;
                case 4:
                    int index = sc.nextInt();
                    ge.remove(index);
                    break;
            }
            //System.out.println(ge.getList().size());
            choice=sc.nextInt();
        }
        for(int i=0;i<ge.getList().size();i++){
            ge.getList().get(i).display();
        }
    }
    public static boolean judge(double x){
        if(x>0&&x<=200){
            return true;
        }else{
            return false;
        }
    }
}

abstract class Element{
    public abstract void display();
}

class Point extends Element {
    private double x;
    private double y;
    public Point() {}
    public Point(double x , double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

    public void display(){
        System.out.printf("(%.2f,%.2f)\n",this.x,this.y);
    }
}

class Line extends Element {
    private Point p1;
    private Point p2;
    private String color;
    public Line() {}
    public Line(Point p1, Point p2, String color) {
        this.p1 = p1;
        this.p2 = p2;
        this.color=color;
    }

    public Point getP1() {
        return p1;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void setP1(Point p1) {
        this.p1 = p1;
    }

    public Point getP2() {
        return p2;
    }

    public void setP2(Point p2) {
        this.p2 = p2;
    }

    public double getDistance() {
        return Math.sqrt((Math.pow((Math.abs(p2.getX() - p1.getX())), 2) + Math.pow((Math.abs(p2.getY() - p1.getY())), 2)));
    }
    public void display(){
        System.out.println("The line's color is:"+this.color);
        System.out.println("The line's begin point's Coordinate is:");
        this.p1.display();
        System.out.println("The line's end point's Coordinate is:");
        this.p2.display();
        System.out.printf("The line's length is:%.2f\n",this.getDistance());
    }
}

class Plane extends Element{
    private String color;
    public Plane(){};
    public Plane(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void display() {
        System.out.println("The Plane's color is:"+this.color);
    }
}

class GeometryObject{
    private ArrayList<Element> list = new ArrayList<Element>();
    public GeometryObject() {}
    public void add(Element element) {
         list.add(element);
    }
    public void remove(int index) {
        if(index>=1 && index<=list.size()) {
            list.remove(index - 1);
        }
    }
    public ArrayList<Element> getList() {return list;}
}

类图：

代码分析与处理：

1.本题输入采用while循环输入，循环条件为输入不为0时，执行循环，否则进程结束即可。对于容器类的添加以及删除方法，只需要遍历容器，索引到相应位置，调用Array List的add()和remove()方法即可。前面两题的基础上层层递进，一步步完善，考察了类，方法的设计，继承，多态方面，arraylist以及容器方面的知识。

2.注意在设置index的范围判断须在【1 ，list.size()】之间，以及直接为空等等，防止出现非零返回的情况。

采坑心得： 

　　1.在7-2 点线形系列4-凸四边形的计算过程中，注意选择合适是否为四边形的判断方法，以及在输出数据方面可以使用DecimalFormat()方法来实现符合要求的数据格式，对冗余点判断可以封装为一个方法，来判断四边形（三边形）。

　　2.7-1 点线形系列5-凸五边形的计算-1&7-2 点线形系列5-凸五边形的计算-2中，完完全全体会到合适的代码结构的好处，之前一直将所有类方法的应用还是写入在主函数内，并没有对其做细致的类的划分，导致后面的解题寸步难行，不得不花费大把的时间进行代码的重构工作，基本算是又重写了一遍（一开始选定构造合适的类与类间的关系真的太重要了。。。）然后是在对求直线与多边形的交点的问题上，疏忽考虑对边与直线交点重合的状况，导致一直有几个点过不去。。。。而在后面的解题过程中，选择合适的结构引入了点集和线集对问题解决提供了很大的帮助，但是同样有部分地方的方法判断出现问题，导致卡了部分点。在对冗杂点去重和删除时，尽量考虑可能出现的情况以及对公共区域面积求解时，对取得的点可先进行排序，然后再利用鞋带定理计算求得所需面积，多边形关系方面多利用点与点、点与线、点与多边形间的关系。

　　3.关于期中考试的相关题目主要考察了这目前以来类，方法的设计，继承，多态方面，arraylist以及容器方面的知识。

改进建议：

　　关于点线形系列的题目确切的来说，一步步递进在一开始就要尽量设计合适的结构，然后灵活运用继承与多态类的关系，例如关于求直线与多边形的交点数量可基于三角形基础上，利用将四边形简化为两个三角形，将五边形简化为四边形和三角形，乃至运用到多边形，依次来简化问题的解决方式，不至于考虑的不清不楚把自己给绕晕，清晰合适的结构，再有就是对于一些情况的判断选择更加合适的一些数学方法对结题会有很大的帮助。学习弥补类设计的缺陷，学会灵活运用类与类之间的多种关系，使代码简洁清晰。 直接判断解决完成，会使得题目复杂度过高，并且对于一些BUG修改和测试比较难以发现和修改，如果不去创建新的类，单单在main里一路写下来，代码将又长又复杂。不仅仅将目光放在实现结果上，同时关注代码的总体结构，结构清晰分工明确，对我们未来的学习也会带来更大的帮助。

总结：

　　通过本阶段的题目集学习，以及之后的总结，更好了理解了java中类、方法的设计，以及java中自带的各种方法，继承多态容器正则表达式类设计原则等，对于面向对象程序设计的概念理解又加深了许多，了解到很多新知识，对于Java语言的各种特性，逐渐熟练掌握，对于面向对象设计的各种原则以及各种设计模式也有了更深的了解和接触，可以说初步打开了面向对象程序设计的大门。但是同时还存在许多不足之处，面向对象的过程还不甚熟练，很多时候还是保持着惯性思维，需要多加练习、学习以及研究。Java语言的各种库以及方法给我们提供了很大便利，但同时我们也要学会合适的利用以及掌握，期望在今后的学习中，能够更加深入体会Java语言的魅力。