PTA第二次总结
目录1. 前言：
第四次作业和第五次作业主要还是延续了多边形的计算，在三角形之上又新增了对四边形和五边形的讨论，但总体思路还是和之前的三角形大致相同，可以延用写三角形的一些思路。期中考试主要是测试我们对多态的理解，并不是很难。
2. 设计与分析:
第四次作业
第四次作业有三道题，第一道题用Patten和Matcher就可以很简单地完成，第三题按照题目要求建类即可，这两题不多做分析，主要分析第二题，对四边形的一系列问题。
7-2 点线形系列4-凸四边形的计算
题目： 用户输入一组选项和数据，进行与四边形有关的计算。
以下四边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
1：输入四个点坐标，判断是否是四边形、平行四边形，判断结果输出true/false，结果之间以一个英文空格符分隔。
2：输入四个点坐标，判断是否是菱形、矩形、正方形，判断结果输出true/false，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
3：输入四个点坐标，判断是凹四边形（false）还是凸四边形(true)，输出四边形周长、面积，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
4：输入六个点坐标，前两个点构成一条直线，后四个点构成一个四边形或三角形，输出直线与四边形（也可能是三角形）相交的交点数量。如果交点有两个，再按面积从小到大输出四边形(或三角形)被直线分割成两部分的面积（不换行）。若直线与四边形或三角形的一条边线重合，输出"The line is coincide with one of the lines"。若后四个点不符合四边形或三角形的输入，输出"not a quadrilateral or triangle"。
后四个点构成三角形的情况：假设三角形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z 不与xy都相邻，如z x y s、x z s y、x s z y
5：输入五个点坐标，输出第一个是否在后四个点所构成的四边形（限定为凸四边形，不考虑凹四边形）或三角形（判定方法见选项4）的内部（若是四边形输出in the quadrilateral/outof the quadrilateral，若是三角形输出in the triangle/outof the triangle）。如果点在多边形的某条边上，输出"on the triangle或者on the quadrilateral"。若后四个点不符合四边形或三角形，输出"not a quadrilateral or triangle"。
输入格式:
基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。
输出格式:
基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
注意：输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333，1.0按格式输出为1.0
选项1、2、3中，若四边形四个点中有重合点，输出"points coincide"。
选项4中，若前两个输入线的点重合，输出"points coincide"。
输入样例1:
选项1，点重合。例如：
1:-1,-1 -1,-1 1,2 1,-2
输出样例:
在这里给出相应的输出。例如：
points coincide
输入样例2:
不符合基本格式。例如：
1:-1,-1 1,2 -1,1 ++1,0
输出样例:
在这里给出相应的输出。例如：
Wrong Format
输入样例3:
选项1，输入点数量不对。例如：
1:-1,-1 -1,2
输出样例:
在这里给出相应的输出。例如：
wrong number of points
输入样例4:
选项1，正确输入判断。例如：
1:-1,-1 -1,1 1,2 1,-2
输出样例:
在这里给出相应的输出。例如：
true false
输入样例5:
选项2，输入点不构成四边形。例如：
2:10,10 1,1 0,0 1,20
输出样例:
在这里给出相应的输出。例如：
not a quadrilateral
输入样例6:
选项2，正方形。例如：
2:0,0 0,80 80,80 80,0
输出样例:
在这里给出相应的输出。例如：
true true true
输入样例7:
选项2。例如：
2:0,0 -10,80 0,160 -10,80
输出样例:
在这里给出相应的输出。例如：
not a quadrilateral
输入样例8:
选项3，凸四边形。例如：
3:-1,-1 -1,1 1,2 1,-2
输出样例:
在这里给出相应的输出。例如：
true 10.472 6.0
输入样例9:
选项3，。例如：
3:0,0 -10,100 0,99 10,100
输出样例:
在这里给出相应的输出。例如：
false 221.097 990.0
试题分析： 首先case1要求判断是否是四边形，判断是否是多边形其实都差不多，只要做到相邻边不平行（共线），第i条边与第i+2条边不线段相交即可，这两个条件只要用循环判断即可（利用取余）。判断平行四边形在四边形的基础上对是否两对边都平行即可。case2判断三种特殊的四边形，首先菱形最简单，只要是平行四边形且邻边相等即可，矩形可用线段垂直判断是否有邻边垂直确定。前两个写好了，正方形只要是菱形且是矩形就可以确定是正方形。case3判断四边形的凹凸性，我利用的是凸多边形的每一条边，其他的所有点都在同一侧的特性，通过循环判断点是否在边的同侧，若不则为凹四边形，反之为凸，此方法可以沿用到五边形，求四边形面积可以把四边形拆成三角形来求，注意凹凸不同即可，不多赘述。case4是直线和四边形的问题，主要要理清有两个交点的有多少种情况。首先需要对传进来的点去重去余，去重简单，去余就是循环对第i和第i+2个点构成的直线判断第i+1个点是否在之上，在则去除即可，然后若剩三个点就是三角形。求交点个数的办法就是拿四边形的每一条边（直线形式）先与线L求得一个交点，然后再去掉不在边（线段）和线L（线段）上的点与重复的点，所得的就是交点，0个交点和1个交点不多讨论，主要说2个交点的情况。其实就是C42，6种情况，2个交点，所以从4条边中任选两条边（无需考虑顶点情况，顶点其实也是在边上）一共6种情况。如落在1，2上，落在2，3上...知道落在哪条边上有什么用呢？其实就是确定直线和哪个顶点那组成三角形（或是四边形），由此可求得已知三角形（四边形）的面积，再用总四边形面积一减即可求得剩余部分面积。case6判断一个点是否在四边形内用面积法即可，同三角形。
源代码展示：
查看代码
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import static java.lang.Double.POSITIVE_INFINITY;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String input = in.nextLine();
String s = input.substring(2);
//if(!check.CheckFormat()) return;
if (input.charAt(0) == '1' && input.charAt(1) == ':') {
Case1(s);
} else if (input.charAt(0) == '2' && input.charAt(1) == ':') {
Case2(s);
} else if (input.charAt(0) == '3' && input.charAt(1) == ':') {
Case3(s);
} else if (input.charAt(0) == '4' && input.charAt(1) == ':') {
Case4(s);
} else if (input.charAt(0) == '5' && input.charAt(1) == ':') {
Case5(s);
} else {
System.out.println("Wrong Format");
}
}
public static void Case1(String s) {//判断是不是四边形，平行四边形
Check check = new Check();
check.setInput(s);
if (!check.CheckFormat(4)) return;//判断格式
List<Points> PointsList = check.GetStingPointsList();
List<Points> pointsList = PointsList.subList(0, 4);
if (Check.IsRepeatPoints(pointsList)) {//有重复点
System.out.println("points coincide");
return;
}
Quadrilateral quadrilateral = new Quadrilateral(pointsList);
System.out.println(quadrilateral.IsQuadrilateral() + " " + quadrilateral.IsParallelogram());
}
public static void Case2(String s) {
Check check = new Check();
check.setInput(s);
if (!check.CheckFormat(4)) return;//判断格式
List<Points> PointsList = check.GetStingPointsList();
List<Points> pointsList = PointsList.subList(0, 4);
Quadrilateral quadrilateral = new Quadrilateral(pointsList);
if (!quadrilateral.IsQuadrilateral()) {//判断是否能构成四边形
System.out.println("not a quadrilateral");
return;
}
System.out.println(quadrilateral.IsDiamond() + " " + quadrilateral.IsRectangle() + " " + quadrilateral.IsSquare());
}
public static void Case3(String s) {
Check check = new Check();
check.setInput(s);
if (!check.CheckFormat(4)) return;//判断格式
List<Points> PointsList = check.GetStingPointsList();
List<Points> pointsList = PointsList.subList(0, 4);
Quadrilateral quadrilateral = new Quadrilateral(pointsList);
if (!quadrilateral.IsQuadrilateral()) {//判断是否能构成四边形
System.out.println("not a quadrilateral");
return;
}
System.out.println(quadrilateral.IsConvexQuadrilateral() + " " + Check.sswr(quadrilateral.getPerimeter(), 3) + " " + Check.sswr(quadrilateral.getArea(), 3));
}
public static void Case4(String s) {
Check check = new Check();
check.setInput(s);
if (!check.CheckFormat(6)) return;//判断格式
List<Points> PointsList = check.GetStingPointsList();
List<Points> pointsList = PointsList.subList(2, 6);
Line line = new Line(PointsList.get(0), PointsList.get(1));
pointsList = Check.DelRepeatPoints(pointsList);//去重复点
if (Quadrilateral.IsQuadrilateral(pointsList) != null) {
Quadrilateral quadrilateral = new Quadrilateral(pointsList);
//System.out.println(quadrilateral.getArea());
if (quadrilateral.IsLineCoincide(line)) {
System.out.println("The line is coincide with one of the lines");
return;
}
double area = quadrilateral.getArea();
//System.out.println(area);
quadrilateral.twoPointsOneQuadrilateral(line);
} else if (Triangle.IsTriangle(pointsList) != null) {
pointsList = Triangle.IsTriangle(pointsList);
Triangle triangle = new Triangle(pointsList.get(0), pointsList.get(1), pointsList.get(2));
if (triangle.IsLineCoincide(line)) {
System.out.println("The line is coincide with one of the lines");
return;
}
triangle.twoPointsOneTriangle(line);
} else {
System.out.println("not a quadrilateral or triangle");
}
}
public static void Case5(String s) {
Check check = new Check();
check.setInput(s);
if (!check.CheckFormat(5)) return;//判断格式
List<Points> PointsList = check.GetStingPointsList();
List<Points> pointsList = PointsList.subList(1, 5);
Points p = new Points(PointsList.get(0));
pointsList = Check.DelRepeatPoints(pointsList);
//System.out.println((Quadrilateral.IsQuadrilateral(pointsList)!=null));
if (Quadrilateral.IsQuadrilateral(pointsList) != null) {
pointsList = Quadrilateral.IsQuadrilateral(pointsList);
Quadrilateral quadrilateral = new Quadrilateral(pointsList);
quadrilateral.IsInQuadrilateral(p);
} else if (Triangle.IsTriangle(pointsList) != null) {
//for (Points po : pointsList){
// System.out.println(po.getX()+","+po.getY());
//}
pointsList = Triangle.IsTriangle(pointsList);
Triangle triangle = new Triangle(pointsList.get(0), pointsList.get(1), pointsList.get(2));
//System.out.println(triangle.getArea());
//System.out.println(triangle.getLab().getM().getX()+","+triangle.getLab().getM().getY()+" "+triangle.getLab().getN().getX()+","+triangle.getLab().getN().getY());
//System.out.println(triangle.getLac().getM().getX()+","+triangle.getLac().getM().getY()+" "+triangle.getLac().getN().getX()+","+triangle.getLac().getN().getY());
//System.out.println(triangle.getLbc().getM().getX()+","+triangle.getLbc().getM().getY()+" "+triangle.getLbc().getN().getX()+","+triangle.getLbc().getN().getY());
triangle.IsInTriangle(p);
} else {
System.out.println("not a quadrilateral or triangle");
}
}
}
class Check {
private String input;
public static boolean IsRepeatPoints(List<Points> pointsList) {
for (Points p : pointsList) {
for (Points points : pointsList) {
if (p.CheckPoints(points) && points != p) {
return true;
}
}
}
return false;
}
public static List<Points> DelRepeatPoints(List<Points> pointsList) {//去除重复顶点
List<Points> points = new ArrayList<>();
for (Points p1 : pointsList) {
boolean flag = true;
for (Points p2 : points) {
if (p1.CheckPoints(p2))
flag = false;
}
if (flag)
points.add(p1);
}
//for(Points p : points)
//System.out.println(p.getX()+","+p.getY());
return points;
}
public static double sswr(double s, int index) {
String str = String.valueOf(s);
String substring = str.substring(str.indexOf(".") + 1);
int str_len;
if (substring.length() > index) {
str_len = index;
} else {
str_len = substring.length();
}
String formats = "%." + str_len + "f";
String out = String.format(formats, s);
return Double.parseDouble(out);
}
public String getInput() {
return input;
}
public void setInput(String input) {
this.input = input;
}
public boolean CheckFormat(int index) {
boolean flag = true;
int cnt = 0;
String p[] = input.split(" ");
for (String x : p) {
String num[] = x.split(",");
if (num.length != 2) {
System.out.println("Wrong Format");
return false;
}
for (String y : num) {
if (!y.matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$"))
flag = false;
}
cnt++;
}
//System.out.println(input);
if (!flag) {
System.out.println("Wrong Format");
return false;
}
if (cnt > index || cnt < index) {
System.out.println("wrong number of points");
return false;
}
return true;
}
public Points GetStingPoints(int index) {
Points a = new Points();
String p[] = input.split(" ");
String num[] = p[index].split(",");
a.setX(Double.valueOf(num[0]));
a.setY(Double.valueOf(num[1]));
return a;
}
public List GetStingPointsList() {
List<Points> pointsList = new ArrayList<>();
String[] p = input.split(" ");
for (int i = 0; i < p.length; i++) {
String[] num = p[i].split(",");
Points a = new Points(Double.valueOf(num[0]), Double.valueOf(num[1]));
pointsList.add(a);
}
return pointsList;
}
}
class Quadrilateral {
private List<Points> pointsList = new ArrayList<>();
private List<Line> lineList = new ArrayList<>();
public Quadrilateral() {
}
public Quadrilateral(List pointsList) {
this.pointsList = pointsList;
setPolygon();
}
public Quadrilateral(Points a, Points b, Points c, Points d) {
pointsList.add(a);
pointsList.add(b);
pointsList.add(c);
pointsList.add(c);
setPolygon();
}
public static List<Points> IsQuadrilateral(List<Points> pointsList) {//判断点是否能构成四边形
if (pointsList.size() < 4)//不足4个点
return null;
else if (pointsList.size() == 4) {//4个点情况
Quadrilateral quadrilateral = new Quadrilateral(pointsList);
if (quadrilateral.IsQuadrilateral()) {
return pointsList;
} else
return null;
}
return null;
}
public void setPolygon() {
for (int i = 0; i < pointsList.size(); i++) {
if (i == pointsList.size() - 1) {
Line line = new Line(pointsList.get(i), pointsList.get(0));
lineList.add(line);
} else {
Line line = new Line(pointsList.get(i), pointsList.get(i + 1));
lineList.add(line);
}
}
}
public List<Line> getLineList() {
return lineList;
}
public void setLineList(List<Line> lineList) {
this.lineList = lineList;
}
public List<Points> getPointsList() {
return pointsList;
}
public void setPointsList(List<Points> pointsList) {
this.pointsList = pointsList;
}
public double getPerimeter() {
double perimeter = 0;
for (Line l : lineList) {
perimeter += l.getLength();
}
return perimeter;
}
public double getArea() {
if (IsConvexQuadrilateral()) {
Triangle triangle1 = new Triangle(pointsList.get(0),pointsList.get(1),pointsList.get(2));
Triangle triangle2 = new Triangle(pointsList.get(0),pointsList.get(3),pointsList.get(2));
return triangle1.getArea()+triangle2.getArea();
}
else {
Line l1 = new Line(pointsList.get(0), pointsList.get(2));
if (l1.whichSide(pointsList.get(1)) != l1.whichSide(pointsList.get(3))) {
Triangle triangle1 = new Triangle(pointsList.get(0), pointsList.get(1), pointsList.get(2));
Triangle triangle2 = new Triangle(pointsList.get(0), pointsList.get(2), pointsList.get(3));
return triangle1.getArea() + triangle2.getArea();
} else {
Triangle triangle1 = new Triangle(pointsList.get(0), pointsList.get(1), pointsList.get(3));
Triangle triangle2 = new Triangle(pointsList.get(1), pointsList.get(2), pointsList.get(3));
return triangle1.getArea() + triangle2.getArea();
}
}
}
public boolean IsQuadrilateral() {//判断是不是四边形
for (int i = 0; i < lineList.size(); i++) {//邻边不能平行
Line line1 = lineList.get(i);
if (i == lineList.size() - 1) {
Line line2 = lineList.get(0);
if (line1.IsParallel(line2))
return false;
} else {
Line line2 = lineList.get(i + 1);
if (line1.IsParallel(line2))
return false;
}
}
for (int i = 0; i < lineList.size() / 2; i++) {//对边（线段）不能相交
if (lineList.get(i).IsReallyCrossover(lineList.get(i + 2)))
return false;
}
return true;
}
public boolean IsParallelogram() {//判断是不是平行四边形
if (IsQuadrilateral() && lineList.get(0).IsParallel(lineList.get(2)) && lineList.get(1).IsParallel(lineList.get(3)))
return true;
else
return false;
}
public boolean IsDiamond() {//判断是否是菱形
if (IsParallelogram() && lineList.get(0).getLength() == lineList.get(1).getLength())//相邻边相等
return true;
return false;
}
public boolean IsRectangle() {//判断是否是矩形
if (IsParallelogram() && lineList.get(0).IsPerpendicular(lineList.get(1)))//相邻边垂直
return true;
return false;
}
public boolean IsSquare() {//判断是否是正方形
if (IsDiamond() && IsRectangle())//既是矩形又是菱形
return true;
return false;
}
public boolean IsConvexQuadrilateral() {//判断凹凸性
int flag = 0;
for (Line l : lineList) {
for (Points p : pointsList) {
if (l.getM().CheckPoints(p) || l.getN().CheckPoints(p))
continue;
if (flag == 0) {
flag = l.whichSide(p);
} else if (flag != l.whichSide(p))
return false;
}
}
return true;
}
public boolean IsLineCoincide(Line line) {//判断直线与四边形是否重合
for (Line l : lineList) {
if (line.IsCoincide(l))
return true;
}
return false;
}
public void IsInQuadrilateral(Points u) {//判断点与四边形的关系
double area = getArea();
double s = 0;
for (Points p : pointsList) {
if (p.CheckPoints(u)) {
System.out.println("on the quadrilateral");
return;
}
}
for (Line l : lineList) {
if (l.IsReallyCollinear(u) && l.IsCollinear(u)) {
System.out.println("on the quadrilateral");
return;
}
}
for (int i = 0; i < lineList.size(); i++) {
Triangle triangle = new Triangle(u, lineList.get(i).getM(), lineList.get(i).getN());
s += triangle.getArea();
}
if ( Math.abs(s - area)<0.0001 ) {
System.out.println("in the quadrilateral");
return;
}
System.out.println("outof the quadrilateral");
}
public void twoPointsOneQuadrilateral(Line line) {//直线与四边形相交问题
List<Points> list = new ArrayList<>();
Points u;
for (Line l : lineList) {
u = l.CrossoverPoint(line);
boolean flag = false;
if (u != null) {
for (Line line1 : lineList) {
if (line1.IsReallyCollinearInclude(u)) {
flag = true;
}
}
for (Points p : list) {
if (p.CheckPoints(u)) {
flag = false;
break;
}
}
if (flag) {
list.add(u);
}
}
}
if (list.size() != 2) {
System.out.println(list.size());
} else {
Points m = list.get(0);
Points n = list.get(1);
//System.out.println(m.getX()+","+m.getY()+" "+n.getX()+","+n.getY());
Line line1 = lineList.get(0);
Line line2 = lineList.get(1);
Line line3 = lineList.get(2);
Line line4 = lineList.get(3);
//System.out.println(line1.IsCollinear(m) && line3.IsCollinear(n));
Points k = null, v = null;
double s1 = 0, s2 = 0;
// System.out.println( );
//System.out.println((line4.IsCollinear(m) && line1.IsCollinear(n)));
if ((line1.IsCollinear(m) && line2.IsCollinear(n)) )
k = pointsList.get(1);
else if ((line2.IsCollinear(m) && line3.IsCollinear(n)) )
k = pointsList.get(2);
else if ((line3.IsCollinear(m) && line4.IsCollinear(n)) )
k = pointsList.get(3);
else if ((line1.IsCollinear(m) && line4.IsCollinear(n)) )
k = pointsList.get(0);
else if ((line1.IsCollinear(m) && line3.IsCollinear(n)) ) {
k = pointsList.get(0);
v = pointsList.get(3);
} else if ((line2.IsCollinear(m) && line4.IsCollinear(n)) ) {
k = pointsList.get(0);
v = pointsList.get(1);
}
if (v == null) {
Triangle triangle = new Triangle(m, n, k);
s1 = triangle.getArea();
} else {
Triangle triangle1 = new Triangle(k, v, m);
Triangle triangle2 = new Triangle(m, v, n);
s1 = triangle1.getArea() + triangle2.getArea();
}
double area = getArea();
s1 = Check.sswr(s1, 3);
area = Check.sswr(area, 3);
s2 = area - s1;
s2 = Check.sswr(s2, 3);
//System.out.println("s1 = " + s1 + " s2 = " + s2 + " area = " + area);
System.out.println("2 " + Math.min(s1, s2) + " " + Math.max(s1, s2));
}
}
}
class Triangle {
private Points a;
private Points b;
private Points c;
private Line lab;
private Line lbc;
private Line lac;
public Triangle() {
}
public Triangle(Points a, Points b, Points c) {
this.a = a;
this.b = b;
this.c = c;
Line l1 = new Line(a, b);
Line l2 = new Line(a, c);
Line l3 = new Line(b, c);
lab = l1;
lac = l2;
lbc = l3;
SetTriangle();
}
public static List<Points> IsTriangle(List<Points> pointsList) {//判断点是否能构成三角形
//pointsList = Check.DelRepeatPoints(pointsList);
if (pointsList.size() > 3) {//4个点情况，去除冗余
for (int i = 0; i < pointsList.size(); i++) {
Line l = new Line(pointsList.get(i), pointsList.get((i + 2) % pointsList.size()));
if (l.IsReallyCollinear(pointsList.get((i + 1) % pointsList.size()))) {
//System.out.println((i+1)%pointsList.size());
pointsList.remove((i+1)%pointsList.size());
break;
}
}
}
if (pointsList.size() == 3) {//去除重复有3个点情况
//System.out.println(pointsList.get(2).getX()+","+pointsList.get(2).getY());
Triangle triangle = new Triangle(pointsList.get(0), pointsList.get(1), pointsList.get(2));
if (triangle.IsTriangle())
return pointsList;
else
return null;
}
return null;
}
public Points getA() {
return a;
}
public void setA(Points a) {
this.a = a;
}
public Points getB() {
return b;
}
public void setB(Points b) {
this.b = b;
}
public Points getC() {
return c;
}
public void setC(Points c) {
this.c = c;
}
public Line getLac() {
return lac;
}
public void setLac(Line lac) {
this.lac = lac;
}
public Line getLbc() {
return lbc;
}
public void setLbc(Line lbc) {
this.lbc = lbc;
}
public Line getLab() {
return lab;
}
public void setLab(Line lab) {
this.lab = lab;
}
public void SetTriangle() {
lab.SetLine();
lbc.SetLine();
lac.SetLine();
}
/*public double getArea(){
double p = (getPerimeter()/ 2.0) ;
//System.out.println("p = " + p + " lab = "+lab.getLength()+ " lac = "+lac.getLength()+ " lbc = "+lbc.getLength());
return Math.sqrt( p * (p - lab.getLength()) * (p - lac.getLength()) * (p - lbc.getLength()) );
}*/
public double getPerimeter() {
return lab.getLength() + lbc.getLength() + lac.getLength();
}
public double getArea() {
return lac.distance(b) * lac.getLength() / 2.0;
}
/*
public double getArea(){
double cos = (lab.getLength() * lab.getLength() + lac.getLength() * lac.getLength() - lbc.getLength() * lbc.getLength()) / (2.0 * lac.getLength() * lab.getLength() );
return Math.sqrt(1 - Math.pow(cos, 2)) * lab.getLength() * lac.getLength() * 0.5;
}*/
public Points getCentrePoint() {
Points CentrePoint = new Points();
double x1 = (a.getX() + b.getX() + c.getX()) / 3;
double y1 = (a.getY() + b.getY() + c.getY()) / 3;
CentrePoint.setX(x1);
CentrePoint.setY(y1);
return CentrePoint;
}
public void whichTriangle() {
double l1 = -1, l2 = -1, l3 = -1;
l1 = Math.min(lab.getLength(), Math.min(lbc.getLength(), lac.getLength()));
l3 = Math.max(lab.getLength(), Math.max(lbc.getLength(), lac.getLength()));
if (lab.getLength() == lbc.getLength() || lac.getLength() == lbc.getLength() || lab.getLength() == lac.getLength())
l2 = l1;
else {
if (lab.getLength() != l1 && lab.getLength() != l3)
l2 = lab.getLength();
else if (lac.getLength() != l1 && lac.getLength() != l3)
l2 = lac.getLength();
else
l3 = lbc.getLength();
}
int type = -1;
if (Math.abs(l1 * l1 + l2 * l2 - l3 * l3) < 2)
type = 2;
else if (l1 * l1 + l2 * l2 > l3 * l3)
type = 3;
else
type = 1;
if (type == 1)
System.out.println("true false false");
else if (type == 2)
System.out.println("false true false");
else
System.out.println("false false true");
}
public boolean IsTriangle() {
if (lab.IsCollinear(c) || lac.IsCollinear(b) || lbc.IsCollinear(a)) {
return false;
}
if (lab.IsParallel(lac) || lab.IsParallel(lbc) || lbc.IsParallel(lac)) {
return false;
}
return true;
}
public void IsSPTriangle() {
SetTriangle();
if (lab.getLength() == lbc.getLength() || lac.getLength() == lbc.getLength() || lab.getLength() == lac.getLength()) {
System.out.print("true" + " ");
} else
System.out.print("false" + " ");
if (lab.getLength() == lbc.getLength() && lab.getLength() == lac.getLength()) {
System.out.println("true");
} else
System.out.println("false");
}
public boolean IsLineCoincide(Line line) {//判断直线与三角形是否重合
if (line.IsCoincide(lab) || line.IsCoincide(lac) || line.IsCoincide(lbc))
return true;
return false;
}
public void IsInTriangle(Points u) {
double s1, s2, s3, s = 0;
Triangle triangle1 = new Triangle(a, b, u);
Triangle triangle2 = new Triangle(a, c, u);
Triangle triangle3 = new Triangle(c, b, u);
s1 = triangle1.getArea();
//System.out.println(s1);
s2 = triangle2.getArea();
//System.out.println(s2);
s3 = triangle3.getArea();
//System.out.println(s3);
s = getArea();
//System.out.println(s);
if ((s1 + s2 + s3) - s > 0.01) {
System.out.println("outof the triangle");
return;
}
List<Points> pointsList = new ArrayList<>();
pointsList.add(a);
pointsList.add(b);
pointsList.add(c);
List<Line> lineList = new ArrayList<>();
lineList.add(lac);
lineList.add(lab);
lineList.add(lbc);
for (Points p : pointsList) {
if (p.CheckPoints(u)) {
System.out.println("on the triangle");
return;
}
}
for (Line l : lineList) {
if (l.IsReallyCollinear(u) && l.IsCollinear(u)) {
System.out.println("on the triangle");
return;
}
}
System.out.println("in the triangle");
}
public void twoPointsOneTriangle(Line line) {
List<Line> lineList = new ArrayList<>();
lineList.add(lac);
lineList.add(lab);
lineList.add(lbc);
List<Points> pointsList = new ArrayList<>();
pointsList.add(a);
pointsList.add(b);
pointsList.add(c);
List<Points> list = new ArrayList<>();
int cnt = 0;
Points u;
for (Line l : lineList) {
u = l.CrossoverPoint(line);
boolean flag = false;
if (u != null) {
for (Line line1 : lineList) {
if (line1.IsReallyCollinearInclude(u)) {
flag = true;
}
}
for (Points p : list) {
if (p.CheckPoints(u)) {
flag = false;
break;
}
}
if (flag) {
list.add(u);
cnt++;
}
}
}
if (cnt != 2) {
System.out.println(cnt);
} else {
double s1, s2, s;
System.out.print("2 ");
Points p1 = list.get(0), p2 = list.get(1);
Points m;
if (lac.IsCollinear(p1) && lab.IsCollinear(p2) || lac.IsCollinear(p2) && lab.IsCollinear(p1))
m = a;
else if (lac.IsCollinear(p1) && lbc.IsCollinear(p2) || lac.IsCollinear(p2) && lbc.IsCollinear(p1))
m = c;
else
m = b;
Triangle triangle1 = new Triangle(m, list.get(0), list.get(1));
s1 = triangle1.getArea();
s1 = Check.sswr(s1, 3);
s = this.getArea();
s = Check.sswr(s, 3);
s2 = s - s1;
s2 = Check.sswr(s2, 3);
System.out.println(Math.min(s1, s2) + " " + Math.max(s1, s2));
}
}
}
class Line {
private Points m;
private Points n;
private double k;
private double b;
private double A;
private double B2;
private double C;
private double length;
public Line() {
}
public Line(Points m, Points n) {
this.m = m;
this.n = n;
SetLine();
}
public void setLength() {
length = m.PointsDistance(n.getX(), n.getY());
}
public double getA() {
return A;
}
public void setA(double a) {
A = a;
}
public double getB2() {
return B2;
}
public void setB2(double b2) {
B2 = b2;
}
public double getC() {
return C;
}
public void setC(double c) {
C = c;
}
public double getB() {
return b;
}
public void setB(double b) {
this.b = b;
}
public double getK() {
return k;
}
public void setK(double k) {
this.k = k;
}
public Points getN() {
return n;
}
public void setN(Points n) {
this.n = n;
// System.out.println("n :"+this.n.getX()+" "+this.n.getY());
}
public Points getM() {
return m;
}
public void setM(Points m) {
this.m = m;
// System.out.println("m :"+this.m.getX()+" "+this.m.getY());
}
public double getLength() {
return length;
}
public boolean CheckLine() {
if (m.getX() == n.getX() && m.getY() == n.getY()) {
System.out.println("points coincide");
return false;
}
return true;
}
public double slope() {
if (m.getX() == n.getX())
return POSITIVE_INFINITY;
else
return (m.getY() - n.getY()) / (m.getX() - n.getX());
}
public void SetLine() {
setK(Check.sswr(slope(), 6));
setB(Check.sswr(m.getY() - m.getX() * getK(), 6));
setA(m.getY() - n.getY());
setB2(n.getX() - m.getX());
setC(m.getX() * n.getY() - n.getX() * m.getY());
setLength();
}
public double distance(Points a) {
return Math.abs(getA() * a.getX() + getB2() * a.getY() + getC()) / Math.sqrt(getA() * getA() + getB2() * getB2());
}
public Points CrossoverPoint(Line l) {
Points CroPoint = new Points();
if (!IsParallel(l)) {
double x1 = (getB2() * l.getC() - l.getB2() * getC()) / (getA() * l.getB2() - l.getA() * getB2());
double y1 = (l.getA() * getC() - getA() * l.getC()) / (getA() * l.getB2() - l.getA() * getB2());
//System.out.println( "crp "+CroPoint.getX()+","+CroPoint.getY() );
CroPoint.setX(x1);
CroPoint.setY(y1);
return CroPoint;
}
// else
return null;
}
public boolean IsCoincide(Line l) {//判断两直线是否重合
if (slope() == l.slope() && IsCollinear(l.getM()) && IsCollinear(l.getN()))
return true;
return false;
}
public boolean IsPerpendicular(Line l) {//判断直线是否垂直
if (slope() == POSITIVE_INFINITY && l.slope() == 0 || slope() == 0 && l.slope() == POSITIVE_INFINITY)//斜率不存在的情况
return true;
if (slope() * l.slope() == -1)//斜率相乘等于-1垂直
return true;
return false;
}
public boolean IsReallyCrossover(Line l) {//判断两线段是否相交
Points m = CrossoverPoint(l);
// System.out.println( (m!=null&&l.IsReallyCollinearInclude(m)));
if (m != null && l.IsReallyCollinearInclude(m) && IsReallyCollinearInclude(m))
return true;
return false;
}
public boolean IsCollinear(Points a) {//判断点是否在直线上
if (m.getX() == n.getX()) {
if (m.getX() == a.getX())
return true;
else
return false;
}
if (Math.abs(getA() * a.getX() + getB2() * a.getY() + getC()) < 0.01)
return true;
return false;
}
public boolean IsReallyCollinear(Points a) {
if(m.getX() == 0 && n.getX() == 0 && a.getX() == 0){
if(a.getY() > Math.min(m.getY(),n.getY() ) && a.getY() < Math.max(m.getY(),n.getY()))
return true;
else
return false;
}
else if(m.getY() == 0 && n.getY() == 0 && a.getY() == 0){
if(a.getX() > Math.min(m.getX(),n.getX() ) && a.getX() < Math.max(m.getX(),n.getX()))
return true;
else
return false;
}
else if (a.getX() > Math.min(m.getX(), n.getX()) && a.getX() < Math.max(m.getX(), n.getX()) && a.getY() > Math.min(m.getY(), n.getY()) && a.getY() < Math.max(m.getY(), n.getY()))
return true;
else
return false;
}
public boolean IsReallyCollinearInclude(Points a) {
if (a.getX() >= Math.min(m.getX(), n.getX()) && a.getX() <= Math.max(m.getX(), n.getX()) && a.getY() >= Math.min(m.getY(), n.getY()) && a.getY() <= Math.max(m.getY(), n.getY()))
return true;
else
return false;
}
public boolean IsParallel(Line l) {
if (this.slope() == l.slope()) {
return true;
} else
return false;
}
public int whichSide(Points p) {//判断点在直线哪一侧，返回0在直线上，小于0右侧，大于0左侧
if (getA() * p.getX() + getB2() * p.getY() + getC() == 0)
return 0;
else if (getA() * p.getX() + getB2() * p.getY() + getC() < 0)
return -1;
else
return 1;
}
}
class Points {
private double x;
private double y;
public Points() {
}
public Points(double x, double y) {
this.x = x;
this.y = y;
}
public Points(Points a) {
this.x = a.getX();
this.y = a.getY();
}
public double getX() {
return this.x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return this.y;
}
public void setY(double y) {
this.y = y;
}
public boolean CheckPoints(Points p) {
if (Math.abs(getX() - p.getX()) < 0.001 && Math.abs(getY() - p.getY()) < 0.001) {
//System.out.println("points coincide");
return true;
} else
return false;
}
public double PointsDistance(double x, double y) {
return Math.sqrt(Math.pow((x - this.x), 2) + Math.pow((y - this.y), 2));
}
}
类图：
SourceMonitor生成的报表内容：
第五次作业
7-1and 7-2 点线形系列5-凸五边形的计算
第五次作业是两道题目，但实际是一道题拆成了两道，在此我放一起来说明。
题目： 用户输入一组选项和数据，进行与五边形有关的计算。
以下五边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
1：输入五个点坐标，判断是否是五边形，判断结果输出true/false。
2：输入五个点坐标，判断是凹五边形（false）还是凸五边形(true)，如果是凸五边形，则再输出五边形周长、面积，结果之间以一个英文空格符分隔。 若五个点坐标无法构成五边形，输出"not a pentagon"
3：输入七个点坐标，前两个点构成一条直线，后五个点构成一个凸五边形、凸四边形或凸三角形，输出直线与五边形、四边形或三角形相交的交点数量。如果交点有两个，再按面积从小到大输出被直线分割成两部分的面积（不换行）。若直线与多边形形的一条边线重合，输出"The line is coincide with one of the lines"。若后五个点不符合五边形输入，若前两点重合，输出"points coincide"。
4：输入十个点坐标，前、后五个点分别构成一个凸多边形（三角形、四边形、五边形），判断它们两个之间是否存在包含关系（一个多边形有一条或多条边与另一个多边形重合，其他部分都包含在另一个多边形内部，也算包含）。
两者存在六种关系：1、分离（完全无重合点） 2、连接（只有一个点或一条边重合） 3、完全重合 4、被包含（前一个多边形在后一个多边形的内部）5、交错 6、包含（后一个多边形在前一个多边形的内部）。
各种关系的输出格式如下：
1、no overlapping area between the previous triangle/quadrilateral/ pentagon and the following triangle/quadrilateral/ pentagon
2、the previous triangle/quadrilateral/ pentagon is connected to the following triangle/quadrilateral/ pentagon
3、the previous triangle/quadrilateral/ pentagon coincides with the following triangle/quadrilateral/ pentagon
4、the previous triangle/quadrilateral/ pentagon is inside the following triangle/quadrilateral/ pentagon
5、the previous triangle/quadrilateral/ pentagon is interlaced with the following triangle/quadrilateral/ pentagon
6、the previous triangle/quadrilateral/ pentagon contains the following triangle/quadrilateral/ pentagon
5：输入十个点坐标，前、后五个点分别构成一个凸多边形（三角形、四边形、五边形），输出两个多边形公共区域的面积。注：只考虑每个多边形被另一个多边形分割成最多两个部分的情况，不考虑一个多边形将另一个分割成超过两个区域的情况。
6：输入六个点坐标，输出第一个是否在后五个点所构成的多边形（限定为凸多边形，不考虑凹多边形），的内部（若是五边形输出in the pentagon/outof the pentagon，若是四边形输出in the quadrilateral/outof the quadrilateral，若是三角形输出in the triangle/outof the triangle）。输入入错存在冗余点要排除，冗余点的判定方法见选项5。如果点在多边形的某条边上，输出"on the triangle/on the quadrilateral/on the pentagon"。
以上4、5、6选项输入的五个点坐标可能存在冗余，假设多边形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如：x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z不与xy都相邻，如：z x y s、x z s y、x s z y
以上3选项中，若输入的点无法构成多边形，则输出"not a polygon"。输入的五个点坐标可能存在冗余，假设多边形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如：x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z不与xy都相邻，如：z x y s、x z s y、x s z y
输入格式:
基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。
输出格式:
基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
注意：输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333，1.0按格式输出为1.0
输入样例1:
选项1，点重合。例如：
1:-1,-1 1,2 -1,1 1,0
输出样例:
在这里给出相应的输出。例如：
wrong number of points
输入样例:
在这里给出一组输入。例如：
4:0,0 6,0 7,1 8,3 6,6 0,0 6,0 7,1 8,3 6,6
输出样例:
在这里给出相应的输出。例如：
the previous pentagon coincides with the following pentagon
试题分析： case1，case2判断是否是五边形以及凹凸性，方法同四边形，不多赘述。case3同四边形也是直线与五边形问题（求交点个数同四，这里只讨论两个交点情况，其余个数交点输出结束即可）。首先传进来的五个点要去重去冗余，方法同四边形，若还剩五个点则有C52,10种情况，循环遍历即可（暴力写10个if,else也行），通过直线与五边形交点落在哪两点边上可以确定构成三角形（四边形）的顶点从而求得一个已知面积，再拿总面积减去已知面积即可。（构成四边形，三角形直接调用之前的四边形类的方法和三角形类的方法即可）case4判断两多边形关系主要以点判断为主，重合即双重循环判断是否有找不到的点，想离即判断是否有在多边形内的点（a对b判断一次，b对a判断一次，防止包含），包含判断是否有在外的点即可,被包含换一下调用顺序即可。连接的话稍复杂一点，需判断只能有一个或两个交点且其他点都在外部，以此法判断两次即可，至于交错直接else即可。csae5是求相交面积，我的方法是按顺序（第一个点，第一条边，第二个点...）对多边形求点是否在内部，边是否相交，将内部点和交点存起来，这就是相交的多边形的点集（有序），然后用多边形求面积即可（分割成若干个三角形）。case6仍然同之前一样，使用面积法判断是否在五边形内即可。
源代码展示：
查看代码
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import static java.lang.Double.POSITIVE_INFINITY;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String input = in.nextLine();
String s = input.substring(2);
//if(!check.CheckFormat()) return;
if (input.charAt(0) == '1' && input.charAt(1) == ':') {
Case1(s);
} else if (input.charAt(0) == '2' && input.charAt(1) == ':') {
Case2(s);
} else if (input.charAt(0) == '3' && input.charAt(1) == ':') {
Case3(s);
} else if (input.charAt(0) == '4' && input.charAt(1) == ':') {
Case4(s);
} else if (input.charAt(0) == '5' && input.charAt(1) == ':') {
Case5(s);
}
else if(input.charAt(0) == '6' && input.charAt(1) == ':'){
Case6(s);
}
else {
System.out.println("Wrong Format");
}
}
public static void Case1(String s) {//判断是不是五边形
Check check = new Check();
check.setInput(s);
if (!check.CheckFormat(5)) return;//判断格式,5坐标
List<Points> PointsList = check.GetStingPointsList();
List<Points> pointsList = PointsList.subList(0, 5);
/* if (Check.IsRepeatPoints(pointsList)) {//有重复点
System.out.println("points coincide");
return;
}*/
Pentagon pentagon = new Pentagon(pointsList);
if(Pentagon.IsPentagon(pointsList) == null){
System.out.println(false);
return;
}
System.out.println(pentagon.IsPentagon());
//System.out.println(false);
}
public static void Case2(String s) {
Check check = new Check();
check.setInput(s);
if (!check.CheckFormat(5)) return;//判断格式
List<Points> PointsList = check.GetStingPointsList();
List<Points> pointsList = PointsList.subList(0, 5);
Pentagon pentagon = new Pentagon(pointsList);
if (!pentagon.IsPentagon()) {//判断是否能构成五边形
System.out.println("not a pentagon");
return;
}
System.out.print(pentagon.IsConvexPentagon());
if(pentagon.IsConvexPentagon())
System.out.println(" "+Check.sswr(pentagon.getPerimeter(),3)+" "+Check.sswr(pentagon.getArea(),3));
}
public static void Case3(String s) {
Check check = new Check();
check.setInput(s);
if (!check.CheckFormat(7)) return;//判断格式
List<Points> PointsList = check.GetStingPointsList();
List<Points> pointsList = PointsList.subList(2, 7);
Line line = new Line(PointsList.get(0),PointsList.get(1));
pointsList = Check.DelRepeatPoints(pointsList);
//System.out.println((Quadrilateral.IsQuadrilateral(pointsList) != null));
Quadrilateral.IsQuadrilateral(pointsList);
if(Pentagon.IsPentagon(pointsList) != null){
Pentagon pentagon = new Pentagon(pointsList);
if(pentagon.IsLineCoincide(line)) {
System.out.println("The line is coincide with one of the lines");
return;
}
pentagon.twoPointsOnePentagon(line);
}
else if (Quadrilateral.IsQuadrilateral(pointsList) != null) {
Quadrilateral quadrilateral = new Quadrilateral(pointsList);
//System.out.println(quadrilateral.getArea());
if (quadrilateral.IsLineCoincide(line)) {
System.out.println("The line is coincide with one of the lines");
return;
}
quadrilateral.twoPointsOneQuadrilateral(line);
}
//System.out.println((Triangle.IsTriangle(pointsList) != null));
else if (Triangle.IsTriangle(pointsList) != null) {
pointsList = Triangle.IsTriangle(pointsList);
Triangle triangle = new Triangle(pointsList.get(0), pointsList.get(1), pointsList.get(2));
if (triangle.IsLineCoincide(line)) {
System.out.println("The line is coincide with one of the lines");
return;
}
triangle.twoPointsOneTriangle(line);
}
else
System.out.println("not a polygon");
}
public static void Case4(String s) {
Check check = new Check();
check.setInput(s);
if (!check.CheckFormat(10)) return;//判断格式
List<Points> PointsList = check.GetStingPointsList();
Polygon.PolygonAndPolygon(PointsList);
}
public static void Case5(String s) {
Check check = new Check();
check.setInput(s);
if (!check.CheckFormat(10)) return;//判断格式
List<Points> PointsList = check.GetStingPointsList();
System.out.println(Check.sswr(Polygon.PolygonCrossPolygon(PointsList),3));
}
public static void Case6(String s) {
Check check = new Check();
check.setInput(s);
if (!check.CheckFormat(6)) return;//判断格式
List<Points> PointsList = check.GetStingPointsList();
List<Points> pointsList = PointsList.subList(1, 6);
Points u = PointsList.get(0);
pointsList = Check.DelRepeatPoints(pointsList);
//System.out.println((Quadrilateral.IsQuadrilateral(pointsList) != null));
Quadrilateral.IsQuadrilateral(pointsList);
if(Pentagon.IsPentagon(pointsList) != null){
Pentagon pentagon = new Pentagon(pointsList);
//pentagon.IsInPentagon(u);
if(Polygon.IsInPolygon(u,pointsList)==0)
System.out.println("on the pentagon");
else if(Polygon.IsInPolygon(u,pointsList)==-1)
System.out.println("in the pentagon");
else
System.out.println("outof the pentagon");
}
else if (Quadrilateral.IsQuadrilateral(pointsList) != null) {
Quadrilateral quadrilateral = new Quadrilateral(pointsList);
//System.out.println(quadrilateral.getArea());
//quadrilateral.IsInQuadrilateral(u);
if(Polygon.IsInPolygon(u,pointsList)==0)
System.out.println("on the quadrilateral");
else if(Polygon.IsInPolygon(u,pointsList)==-1)
System.out.println("in the quadrilateral");
else
System.out.println("outof the quadrilateral");
}
else if (Triangle.IsTriangle(pointsList) != null) {
pointsList = Triangle.IsTriangle(pointsList);
Triangle triangle = new Triangle(pointsList.get(0), pointsList.get(1), pointsList.get(2));
//triangle.IsInTriangle(u);
if(Polygon.IsInPolygon(u,pointsList)==0)
System.out.println("on the triangle");
else if(Polygon.IsInPolygon(u,pointsList)==-1)
System.out.println("in the triangle");
else
System.out.println("outof the triangle");
}
else
System.out.println("not a polygon");
}
}
class Check {
private String input;
public static boolean IsRepeatPoints(List<Points> pointsList) {
for (Points p : pointsList) {
for (Points points : pointsList) {
if (p.CheckPoints(points) && points != p) {
return true;
}
}
}
return false;
}
public static void showPoints(List<Points> pointsList){
for (Points p : pointsList)
System.out.println(p.getX()+","+p.getY());
}
public static List<Points> DelRepeatPoints(List<Points> pointsList) {//去除重复顶点
List<Points> points = new ArrayList<>();
for (Points p1 : pointsList) {
boolean flag = true;
for (Points p2 : points) {
if (p1.CheckPoints(p2))
flag = false;
}
if (flag)
points.add(p1);
}
//for(Points p : points)
//System.out.println(p.getX()+","+p.getY());
return points;
}
public static List<Points> delRedundantPoints(List<Points> pointsList){
for (int i = 0; i < pointsList.size();) {
Line l = new Line(pointsList.get(i), pointsList.get((i + 2) % pointsList.size()));
if (l.IsCollinear(pointsList.get((i + 1) % pointsList.size()))) {
pointsList.remove( (i+1)%pointsList.size() );
i = 0;
}
else i++;
}
//Check.showPoints(pointsList);
return pointsList;
}
public static double sswr(double s, int index) {
String str = String.valueOf(s);
String substring = str.substring(str.indexOf(".") + 1);
int str_len;
if (substring.length() > index) {
str_len = index;
} else {
str_len = substring.length();
}
String formats = "%." + str_len + "f";
String out = String.format(formats, s);
return Double.parseDouble(out);
}
public String getInput() {
return input;
}
public void setInput(String input) {
this.input = input;
}
public boolean CheckFormat(int index) {
boolean flag = true;
int cnt = 0;
String p[] = input.split(" ");
for (String x : p) {
String num[] = x.split(",");
if (num.length != 2) {
System.out.println("Wrong Format");
return false;
}
for (String y : num) {
if (!y.matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$"))
flag = false;
}
cnt++;
}
//System.out.println(input);
if (!flag) {
System.out.println("Wrong Format");
return false;
}
if (cnt > index || cnt < index) {
System.out.println("wrong number of points");
return false;
}
return true;
}
public Points GetStingPoints(int index) {
Points a = new Points();
String p[] = input.split(" ");
String num[] = p[index].split(",");
a.setX(Double.valueOf(num[0]));
a.setY(Double.valueOf(num[1]));
return a;
}
public List GetStingPointsList() {
List<Points> pointsList = new ArrayList<>();
String[] p = input.split(" ");
for (int i = 0; i < p.length; i++) {
String[] num = p[i].split(",");
Points a = new Points(Double.valueOf(num[0]), Double.valueOf(num[1]));
pointsList.add(a);
}
return pointsList;
}
}
class Polygon {
public static List<Line> getLineList(List<Points> pointsList){
List<Line> lineList = new ArrayList<>();
//System.out.println(pointsList.size());
for(int i = 0 ; i < pointsList.size() ; i++){
Line line = new Line(pointsList.get(i),pointsList.get((i+1)%pointsList.size()));
lineList.add(line);
}
return lineList;
}
public static int IsInPolygon(Points u,List<Points> pointsList) {//判断点与多边形的关系
List<Line> lineList = getLineList(pointsList);
double s = 0;
for (Points p : pointsList) {
if (p.CheckPoints(u)) {return 0;}}
for (Line l : lineList) {
if (l.IsReallyCollinear(u) && l.IsCollinear(u)) {return 0;}}
for (int i = 0; i < lineList.size(); i++) {
Triangle triangle = new Triangle(u, lineList.get(i).getM(), lineList.get(i).getN());
s += triangle.getArea();}
if(pointsList.size() == 3){
Triangle polygon = new Triangle(pointsList.get(0),pointsList.get(1),pointsList.get(2));
double area = polygon.getArea();
if ( Math.abs(s - area)<0.0001 )
return -1;
}
else if(pointsList.size() == 4){
Quadrilateral polygon = new Quadrilateral(pointsList);
double area = polygon.getArea();
if ( Math.abs(s - area)<0.0001 )
return -1;
}
else {
Pentagon polygon = new Pentagon(pointsList);
double area = polygon.getArea();
if ( Math.abs(s - area)<0.0001 )
return -1;
}
return 1;
}
public static void PolygonAndPolygon(List<Points> pointsList){
List<Points> pointsList1 = pointsList.subList(0, 5);
List<Points> pointsList2 = pointsList.subList(5, 10);
//System.out.println("p1");Check.showPoints(pointsList1);
//System.out.println("p2");Check.showPoints(pointsList2);
pointsList1 = Check.DelRepeatPoints(pointsList1);
pointsList2 = Check.DelRepeatPoints(pointsList2);
pointsList1 = Check.delRedundantPoints(pointsList1);
pointsList2 = Check.delRedundantPoints(pointsList2);
String[] polygonName = {"triangle","quadrilateral","pentagon"};
//double crossArea = PolygonCrossPolygon(pointsList);
//double s1 = getPolygonArea(pointsList1);
//double s2 = getPolygonArea(pointsList2);
if(IsSeparate(pointsList1,pointsList2))//分离
//if(crossArea == 0)
System.out.println("no overlapping area between the previous "+polygonName[getPolygonNameNum(pointsList1.size())]+" and the following "+polygonName[getPolygonNameNum(pointsList2.size())]);
else if(IsCompleteCoincidence(pointsList1,pointsList2) )//重合
System.out.println("the previous "+polygonName[getPolygonNameNum(pointsList1.size())]+" coincides with the following "+polygonName[getPolygonNameNum(pointsList2.size())]);
else if(IsInclude(pointsList1,pointsList2))//包含
System.out.println("the previous "+polygonName[getPolygonNameNum(pointsList1.size())]+" contains the following "+polygonName[getPolygonNameNum(pointsList2.size())]);
else if(IsInclude(pointsList2,pointsList1))//被包含
System.out.println("the previous "+polygonName[getPolygonNameNum(pointsList1.size())]+" is inside the following "+polygonName[getPolygonNameNum(pointsList2.size())]);
else if(IsConnect(pointsList1,pointsList2) || IsConnect(pointsList2,pointsList1) )//连接
System.out.println("the previous "+polygonName[getPolygonNameNum(pointsList1.size())]+" is connected to the following "+polygonName[getPolygonNameNum(pointsList2.size())]);
else //交错
System.out.println("the previous "+polygonName[getPolygonNameNum(pointsList1.size())]+" is interlaced with the following "+polygonName[getPolygonNameNum(pointsList2.size())]);
//System.out.println("the previous "+polygonName[getPolygonNameNum(pointsList1.size())]+" is interlaced with the following "+polygonName[getPolygonNameNum(pointsList2.size())]);
}
public static double getPolygonArea(List<Points> pointsList){
double s = 0;
List<Line> lineList = getLineList(pointsList);
for(int i = 1 ; i < lineList.size() - 1 ; i++){
Triangle triangle = new Triangle(pointsList.get(0),pointsList.get(i),pointsList.get(i+1));
s += triangle.getArea();
}
return s;
}
public static Points IsLineCrossPolygon(Line l,List<Points> pointsList){
List<Line> lineList = getLineList(pointsList);
for(Line line : lineList){
if(l.IsReallyCrossoverReturnPoint(line) != null)
return l.IsReallyCrossoverReturnPoint(line);
}
return null;
}
public static double PolygonCrossPolygon(List<Points> pointsList){
List<Points> pointsList1 = pointsList.subList(0, 5);
List<Points> pointsList2 = pointsList.subList(5, 10);
List<Points> list = new ArrayList<>();
pointsList1 = Check.DelRepeatPoints(pointsList1);
pointsList2 = Check.DelRepeatPoints(pointsList2);
pointsList1 = Check.delRedundantPoints(pointsList1);
pointsList2 = Check.delRedundantPoints(pointsList2);
List<Line> lineList1 = new ArrayList<>();
List<Line> lineList2 = new ArrayList<>();
for (int i = 0 ; i < pointsList1.size(); i++ ){
if(Polygon.IsInPolygon(pointsList1.get(i),pointsList2) == -1){
list.add(pointsList1.get(i));
}
Line l = new Line( pointsList1.get(i),pointsList1.get( (i+1) % pointsList1.size()) );
if(IsLineCrossPolygon(l,pointsList2) != null){
list.add(IsLineCrossPolygon(l,pointsList2));
}
}
for (int i = 0 ; i < pointsList2.size(); i++ ){
if(Polygon.IsInPolygon(pointsList2.get(i),pointsList1) == -1){
list.add(pointsList2.get(i));
}
Line l = new Line( pointsList2.get(i),pointsList2.get( (i+1) % pointsList2.size()) );
if(IsLineCrossPolygon(l,pointsList1) != null){
list.add(IsLineCrossPolygon(l,pointsList1));
}
}
list = Check.DelRepeatPoints(list);list = Check.DelRepeatPoints(list);
return getPolygonArea(list);
}
public static boolean IsSeparate(List<Points> pointsList1,List<Points> pointsList2){//判断是否分离
for (Points p : pointsList1){
if(IsInPolygon(p,pointsList2)!=1)
return false;
}
for (Points p : pointsList2){
if(IsInPolygon(p,pointsList1)!=1)
return false;
}
return true;
}
public static boolean IsCompleteCoincidence(List<Points> pointsList1,List<Points> pointsList2){//判断是否完全重合
if(pointsList1.size() != pointsList2.size())
return false;
for (Points p : pointsList1){
boolean flag = false;
for (Points u : pointsList2){
if(p.CheckPoints(u)){
flag = true;
break;
}
}
if(!flag) return false;
}
return true;
}
public static boolean IsInclude(List<Points> pointsList1,List<Points> pointsList2) {//判断是否包含
for(Points u : pointsList2){
if(IsInPolygon(u,pointsList1) == 1)
return false;
}
return true;
}
public static boolean IsConnect(List<Points> pointsList1,List<Points> pointsList2) {//判断是否连接，需调用两次
int cntIn = 0, cntOn = 0, cntOut = 0;
for (Points u : pointsList1){
if(IsInPolygon(u,pointsList2)==-1) return false;
else if(IsInPolygon(u,pointsList1) == 0) cntOn++;
}
if(cntOn == 1 || cntOn == 2)
return true;
return false;
}
public static int getPolygonNameNum(int size){
if(size == 3) return 0;
else if(size == 4) return 1;
else return 2;
}
}
class Pentagon {
private List<Points> pointsList = new ArrayList<>();
//线集
private List<Line> lineList = new ArrayList<>();
public void setPointsList(List<Points> pointsList) {
this.pointsList = pointsList;
}
public void setLineList(List<Line> lineList) {
this.lineList = lineList;
}
public List<Points> getPointsList() {
return pointsList;
}
public List<Line> getLineList() {
return lineList;
}
public Pentagon(List<Points> pointsList){
this.pointsList = pointsList;
setPentagon();
}
public void setPentagon(){
for(int i = 0 ; i < pointsList.size() ; i++){
Line line = new Line(pointsList.get(i),pointsList.get((i+1)%pointsList.size()));
lineList.add(line);
}
}
public double getPerimeter() {//求周长
double perimeter = 0;
for (Line l : lineList) {
perimeter += l.getLength();
}
return perimeter;
}
public boolean IsPentagon() {//判断是不是五边形
for (int i = 0; i < lineList.size(); i++) {//邻边不能平行
Line line1 = lineList.get(i);
if (i == lineList.size() - 1) {
Line line2 = lineList.get(0);
if (line1.IsParallel(line2))
return false;
} else {
Line line2 = lineList.get(i + 1);
if (line1.IsParallel(line2))
return false;
}
}
for (int i = 0; i < lineList.size() ; i++) {//对边（线段）不能相交
if (lineList.get(i).IsReallyCrossover(lineList.get((i + 2)%lineList.size())))
return false;
}
return true;
}
public static List<Points> IsPentagon(List<Points> pointsList) {//判断点是否能构成五边形
if (pointsList.size() < 5)//不足5个点
return null;
else if (pointsList.size() == 5) {//5个点情况
Pentagon pentagon = new Pentagon(pointsList);
//System.out.println(pentagon.IsPentagon()+"1");
if (pentagon.IsPentagon()) {
return pointsList;
} else
return null;
}
return null;
}
public boolean IsConvexPentagon() {//判断凹凸性
int flag = 0;
for (Line l : lineList) {
for (Points p : pointsList) {
if (l.getM().CheckPoints(p) || l.getN().CheckPoints(p))
continue;
if (flag == 0) {
flag = l.whichSide(p);
} else if (flag != l.whichSide(p))
return false;
}
}
return true;
}
public double getArea() {//求面积
double s = 0;
if (IsPentagon()) {//凸
for(int i = 1 ; i < lineList.size() - 1 ; i++){
Triangle triangle = new Triangle(pointsList.get(0),pointsList.get(i),pointsList.get(i+1));
//System.out.println(triangle.getArea());
s += triangle.getArea();
}
}
return s;
}
public boolean IsLineCoincide(Line line) {//判断直线与五边形是否重合
for (Line l : lineList) {
if (line.IsCoincide(l))
return true;
}
return false;
}
public void IsInPentagon(Points u) {//判断点与五边形的关系
double area = getArea();
double s = 0;
for (Points p : pointsList) {
if (p.CheckPoints(u)) {
System.out.println("on the pentagon");
return;
}
}
for (Line l : lineList) {
if (l.IsReallyCollinear(u) && l.IsCollinear(u)) {
System.out.println("on the pentagon");
return;
}
}
for (int i = 0; i < lineList.size(); i++) {
Triangle triangle = new Triangle(u, lineList.get(i).getM(), lineList.get(i).getN());
s += triangle.getArea();
}
if ( Math.abs(s - area)<0.0001 ) {
System.out.println("in the pentagon");
return;
}
System.out.println("outof the pentagon");
}
public void twoPointsOnePentagon(Line line) {//直线与五边形相交问题
List<Points> list = new ArrayList<>();
Points u;
for (Line l : lineList) {
u = l.CrossoverPoint(line);
boolean flag = false;
if (u != null) {
for (Line line1 : lineList) {
if (line1.IsReallyCollinearInclude(u)) {
flag = true;
}
}
for (Points p : list) {
if (p.CheckPoints(u)) {
flag = false;
break;
}
}
if (flag) {
list.add(u);
}
}
}
if (list.size() != 2) {
System.out.println(list.size());
}
else {
Points m = list.get(0);
Points n = list.get(1);
//System.out.println(m.getX()+","+m.getY());
//System.out.println(n.getX()+","+n.getY());
Points k = null, v = null;
for(int i = 0 ; i < lineList.size() ; i++){
if(lineList.get(Math.min(i,(i+1)%lineList.size())).IsCollinear(m) && lineList.get(Math.max(i,(i+1)%lineList.size())).IsCollinear(n) )
k = pointsList.get((i+1)%lineList.size());
}
for(int i = 0 ; i < lineList.size() ; i++){
if(k==null && lineList.get(Math.min(i,(i+2)%lineList.size())).IsCollinear(m) && lineList.get(Math.max(i,(i+2)%lineList.size())).IsCollinear(n) ){
k = pointsList.get((i+1)%lineList.size());
v = pointsList.get((i+2)%lineList.size());
}
}
//System.out.println(k.getX()+","+k.getY());
//System.out.println(v.getX()+","+v.getY());
double s1 = 0,s2 = 0,area = Check.sswr(getArea(),3);
if(v == null){
Triangle triangle = new Triangle(k,m,n);
s1 = Check.sswr(triangle.getArea(),3);
}
else {
Triangle triangle1 = new Triangle(k, v, m);
Triangle triangle2 = new Triangle(m, v, n);
s1 = triangle1.getArea() + triangle2.getArea();
}
s2 = Check.sswr(area - s1 , 3);
System.out.println("2 " + Math.min(s1, s2) + " " + Math.max(s1, s2));
}
}
}
class Quadrilateral {
private List<Points> pointsList = new ArrayList<>();
private List<Line> lineList = new ArrayList<>();
public Quadrilateral() {
}
public Quadrilateral(List pointsList) {
this.pointsList = pointsList;
setQuadrilateral();
}
public Quadrilateral(Points a, Points b, Points c, Points d) {
pointsList.add(a);
pointsList.add(b);
pointsList.add(c);
pointsList.add(c);
setQuadrilateral();
}
public static List<Points> IsQuadrilateral(List<Points> pointsList) {//判断点是否能构成四边形
if (pointsList.size() > 4) {//5个点情况，去除冗余
for (int i = 0; i < pointsList.size(); i++) {
Line l = new Line(pointsList.get(i), pointsList.get((i + 2) % pointsList.size()));
if (l.IsCollinear(pointsList.get((i + 1) % pointsList.size()))) {
pointsList.remove((i+1)%pointsList.size());
i = 0;
}
}
//Check.showPoints(pointsList);
}
else if (pointsList.size() < 4)//不足4个点
return null;
else if (pointsList.size() == 4) {//4个点情况
Quadrilateral quadrilateral = new Quadrilateral(pointsList);
if (quadrilateral.IsQuadrilateral()) {
return pointsList;
} else
return null;
}
return null;
}
public void setQuadrilateral() {
for (int i = 0; i < pointsList.size(); i++) {
if (i == pointsList.size() - 1) {
Line line = new Line(pointsList.get(i), pointsList.get(0));
lineList.add(line);
} else {
Line line = new Line(pointsList.get(i), pointsList.get(i + 1));
lineList.add(line);
}
}
}
public List<Line> getLineList() {
return lineList;
}
public void setLineList(List<Line> lineList) {
this.lineList = lineList;
}
public List<Points> getPointsList() {
return pointsList;
}
public void setPointsList(List<Points> pointsList) {
this.pointsList = pointsList;
}
public double getPerimeter() {
double perimeter = 0;
for (Line l : lineList) {
perimeter += l.getLength();
}
return perimeter;
}
public double getArea() {
if (IsConvexQuadrilateral()) {
Triangle triangle1 = new Triangle(pointsList.get(0),pointsList.get(1),pointsList.get(2));
Triangle triangle2 = new Triangle(pointsList.get(0),pointsList.get(3),pointsList.get(2));
return triangle1.getArea()+triangle2.getArea();
}
else {
Line l1 = new Line(pointsList.get(0), pointsList.get(2));
if (l1.whichSide(pointsList.get(1)) != l1.whichSide(pointsList.get(3))) {
Triangle triangle1 = new Triangle(pointsList.get(0), pointsList.get(1), pointsList.get(2));
Triangle triangle2 = new Triangle(pointsList.get(0), pointsList.get(2), pointsList.get(3));
return triangle1.getArea() + triangle2.getArea();
} else {
Triangle triangle1 = new Triangle(pointsList.get(0), pointsList.get(1), pointsList.get(3));
Triangle triangle2 = new Triangle(pointsList.get(1), pointsList.get(2), pointsList.get(3));
return triangle1.getArea() + triangle2.getArea();
}
}
}
public boolean IsQuadrilateral() {//判断是不是四边形
for (int i = 0; i < lineList.size(); i++) {//邻边不能平行
Line line1 = lineList.get(i);
if (i == lineList.size() - 1) {
Line line2 = lineList.get(0);
if (line1.IsParallel(line2))
return false;
} else {
Line line2 = lineList.get(i + 1);
if (line1.IsParallel(line2))
return false;
}
}
for (int i = 0; i < lineList.size() / 2; i++) {//对边（线段）不能相交
if (lineList.get(i).IsReallyCrossover(lineList.get(i + 2)))
return false;
}
return true;
}
public boolean IsParallelogram() {//判断是不是平行四边形
if (IsQuadrilateral() && lineList.get(0).IsParallel(lineList.get(2)) && lineList.get(1).IsParallel(lineList.get(3)))
return true;
else
return false;
}
public boolean IsDiamond() {//判断是否是菱形
if (IsParallelogram() && lineList.get(0).getLength() == lineList.get(1).getLength())//相邻边相等
return true;
return false;
}
public boolean IsRectangle() {//判断是否是矩形
if (IsParallelogram() && lineList.get(0).IsPerpendicular(lineList.get(1)))//相邻边垂直
return true;
return false;
}
public boolean IsSquare() {//判断是否是正方形
if (IsDiamond() && IsRectangle())//既是矩形又是菱形
return true;
return false;
}
public boolean IsConvexQuadrilateral() {//判断凹凸性
int flag = 0;
for (Line l : lineList) {
for (Points p : pointsList) {
if (l.getM().CheckPoints(p) || l.getN().CheckPoints(p))
continue;
if (flag == 0) {
flag = l.whichSide(p);
} else if (flag != l.whichSide(p))
return false;
}
}
return true;
}
public boolean IsLineCoincide(Line line) {//判断直线与四边形是否重合
for (Line l : lineList) {
if (line.IsCoincide(l))
return true;
}
return false;
}
public void IsInQuadrilateral(Points u) {//判断点与四边形的关系
double area = getArea();
double s = 0;
for (Points p : pointsList) {
if (p.CheckPoints(u)) {
System.out.println("on the quadrilateral");
return;
}
}
for (Line l : lineList) {
if (l.IsReallyCollinear(u) && l.IsCollinear(u)) {
System.out.println("on the quadrilateral");
return;
}
}
for (int i = 0; i < lineList.size(); i++) {
Triangle triangle = new Triangle(u, lineList.get(i).getM(), lineList.get(i).getN());
s += triangle.getArea();
}
if ( Math.abs(s - area)<0.0001 ) {
System.out.println("in the quadrilateral");
return;
}
System.out.println("outof the quadrilateral");
}
public void twoPointsOneQuadrilateral(Line line) {//直线与四边形相交问题
List<Points> list = new ArrayList<>();
Points u;
for (Line l : lineList) {
u = l.CrossoverPoint(line);
boolean flag = false;
if (u != null) {
for (Line line1 : lineList) {
if (line1.IsReallyCollinearInclude(u)) {
flag = true;
}
}
for (Points p : list) {
if (p.CheckPoints(u)) {
flag = false;
break;
}
}
if (flag) {
list.add(u);
}
}
}
if (list.size() != 2) {
System.out.println(list.size());
} else {
Points m = list.get(0);
Points n = list.get(1);
//System.out.println(m.getX()+","+m.getY()+" "+n.getX()+","+n.getY());
Line line1 = lineList.get(0);
Line line2 = lineList.get(1);
Line line3 = lineList.get(2);
Line line4 = lineList.get(3);
//System.out.println(line1.IsCollinear(m) && line3.IsCollinear(n));
Points k = null, v = null;
double s1 = 0, s2 = 0;
// System.out.println( );
//System.out.println((line4.IsCollinear(m) && line1.IsCollinear(n)));
if ((line1.IsCollinear(m) && line2.IsCollinear(n)) )
k = pointsList.get(1);
else if ((line2.IsCollinear(m) && line3.IsCollinear(n)) )
k = pointsList.get(2);
else if ((line3.IsCollinear(m) && line4.IsCollinear(n)) )
k = pointsList.get(3);
else if ((line1.IsCollinear(m) && line4.IsCollinear(n)) )
k = pointsList.get(0);
else if ((line1.IsCollinear(m) && line3.IsCollinear(n)) ) {
k = pointsList.get(0);
v = pointsList.get(3);
} else if ((line2.IsCollinear(m) && line4.IsCollinear(n)) ) {
k = pointsList.get(0);
v = pointsList.get(1);
}
if (v == null) {
Triangle triangle = new Triangle(m, n, k);
s1 = triangle.getArea();
} else {
Triangle triangle1 = new Triangle(k, v, m);
Triangle triangle2 = new Triangle(m, v, n);
s1 = triangle1.getArea() + triangle2.getArea();
}
double area = getArea();
s1 = Check.sswr(s1, 3);
area = Check.sswr(area, 3);
s2 = area - s1;
s2 = Check.sswr(s2, 3);
//System.out.println("s1 = " + s1 + " s2 = " + s2 + " area = " + area);
System.out.println("2 " + Math.min(s1, s2) + " " + Math.max(s1, s2));
}
}
}
class Triangle {
private Points a;
private Points b;
private Points c;
private Line lab;
private Line lbc;
private Line lac;
public Triangle() {
}
public Triangle(Points a, Points b, Points c) {
this.a = a;
this.b = b;
this.c = c;
Line l1 = new Line(a, b);
Line l2 = new Line(a, c);
Line l3 = new Line(b, c);
lab = l1;
lac = l2;
lbc = l3;
SetTriangle();
}
public static List<Points> IsTriangle(List<Points> pointsList) {//判断点是否能构成三角形
//pointsList = Check.DelRepeatPoints(pointsList);
if (pointsList.size() > 3) {//4个点情况，去除冗余
for (int i = 0; i < pointsList.size(); i++) {
Line l = new Line(pointsList.get(i), pointsList.get((i + 2) % pointsList.size()));
if (l.IsCollinear(pointsList.get((i + 1) % pointsList.size()))) {
//System.out.println((i+1)%pointsList.size());
pointsList.remove((i+1)%pointsList.size());
i = 0;
}
}
}
if (pointsList.size() == 3) {//去除重复有3个点情况
//System.out.println(pointsList.get(2).getX()+","+pointsList.get(2).getY());
Triangle triangle = new Triangle(pointsList.get(0), pointsList.get(1), pointsList.get(2));
if (triangle.IsTriangle())
return pointsList;
else
return null;
}
return null;
}
public Points getA() {
return a;
}
public void setA(Points a) {
this.a = a;
}
public Points getB() {
return b;
}
public void setB(Points b) {
this.b = b;
}
public Points getC() {
return c;
}
public void setC(Points c) {
this.c = c;
}
public Line getLac() {
return lac;
}
public void setLac(Line lac) {
this.lac = lac;
}
public Line getLbc() {
return lbc;
}
public void setLbc(Line lbc) {
this.lbc = lbc;
}
public Line getLab() {
return lab;
}
public void setLab(Line lab) {
this.lab = lab;
}
public void SetTriangle() {
lab.SetLine();
lbc.SetLine();
lac.SetLine();
}
/*public double getArea(){
double p = (getPerimeter()/ 2.0) ;
//System.out.println("p = " + p + " lab = "+lab.getLength()+ " lac = "+lac.getLength()+ " lbc = "+lbc.getLength());
return Math.sqrt( p * (p - lab.getLength()) * (p - lac.getLength()) * (p - lbc.getLength()) );
}*/
public double getPerimeter() {
return lab.getLength() + lbc.getLength() + lac.getLength();
}
public double getArea() {
return lac.distance(b) * lac.getLength() / 2.0;
}
/*
public double getArea(){
double cos = (lab.getLength() * lab.getLength() + lac.getLength() * lac.getLength() - lbc.getLength() * lbc.getLength()) / (2.0 * lac.getLength() * lab.getLength() );
return Math.sqrt(1 - Math.pow(cos, 2)) * lab.getLength() * lac.getLength() * 0.5;
}*/
public Points getCentrePoint() {
Points CentrePoint = new Points();
double x1 = (a.getX() + b.getX() + c.getX()) / 3;
double y1 = (a.getY() + b.getY() + c.getY()) / 3;
CentrePoint.setX(x1);
CentrePoint.setY(y1);
return CentrePoint;
}
public void whichTriangle() {
double l1 = -1, l2 = -1, l3 = -1;
l1 = Math.min(lab.getLength(), Math.min(lbc.getLength(), lac.getLength()));
l3 = Math.max(lab.getLength(), Math.max(lbc.getLength(), lac.getLength()));
if (lab.getLength() == lbc.getLength() || lac.getLength() == lbc.getLength() || lab.getLength() == lac.getLength())
l2 = l1;
else {
if (lab.getLength() != l1 && lab.getLength() != l3)
l2 = lab.getLength();
else if (lac.getLength() != l1 && lac.getLength() != l3)
l2 = lac.getLength();
else
l3 = lbc.getLength();
}
int type = -1;
if (Math.abs(l1 * l1 + l2 * l2 - l3 * l3) < 2)
type = 2;
else if (l1 * l1 + l2 * l2 > l3 * l3)
type = 3;
else
type = 1;
if (type == 1)
System.out.println("true false false");
else if (type == 2)
System.out.println("false true false");
else
System.out.println("false false true");
}
public boolean IsTriangle() {
if (lab.IsCollinear(c) || lac.IsCollinear(b) || lbc.IsCollinear(a)) {
return false;
}
if (lab.IsParallel(lac) || lab.IsParallel(lbc) || lbc.IsParallel(lac)) {
return false;
}
return true;
}
public void IsSPTriangle() {
SetTriangle();
if (lab.getLength() == lbc.getLength() || lac.getLength() == lbc.getLength() || lab.getLength() == lac.getLength()) {
System.out.print("true" + " ");
} else
System.out.print("false" + " ");
if (lab.getLength() == lbc.getLength() && lab.getLength() == lac.getLength()) {
System.out.println("true");
} else
System.out.println("false");
}
public boolean IsLineCoincide(Line line) {//判断直线与三角形是否重合
if (line.IsCoincide(lab) || line.IsCoincide(lac) || line.IsCoincide(lbc))
return true;
return false;
}
public void IsInTriangle(Points u) {
double s1, s2, s3, s = 0;
Triangle triangle1 = new Triangle(a, b, u);
Triangle triangle2 = new Triangle(a, c, u);
Triangle triangle3 = new Triangle(c, b, u);
s1 = triangle1.getArea();
//System.out.println(s1);
s2 = triangle2.getArea();
//System.out.println(s2);
s3 = triangle3.getArea();
//System.out.println(s3);
s = getArea();
//System.out.println(s);
if ((s1 + s2 + s3) - s > 0.01) {
System.out.println("outof the triangle");
return;
}
List<Points> pointsList = new ArrayList<>();
pointsList.add(a);
pointsList.add(b);
pointsList.add(c);
List<Line> lineList = new ArrayList<>();
lineList.add(lac);
lineList.add(lab);
lineList.add(lbc);
for (Points p : pointsList) {
if (p.CheckPoints(u)) {
System.out.println("on the triangle");
return;
}
}
for (Line l : lineList) {
if (l.IsReallyCollinear(u) && l.IsCollinear(u)) {
System.out.println("on the triangle");
return;
}
}
System.out.println("in the triangle");
}
public void twoPointsOneTriangle(Line line) {
List<Line> lineList = new ArrayList<>();
lineList.add(lac);
lineList.add(lab);
lineList.add(lbc);
List<Points> pointsList = new ArrayList<>();
pointsList.add(a);
pointsList.add(b);
pointsList.add(c);
List<Points> list = new ArrayList<>();
int cnt = 0;
Points u;
for (Line l : lineList) {
u = l.CrossoverPoint(line);
boolean flag = false;
if (u != null) {
for (Line line1 : lineList) {
if (line1.IsReallyCollinearInclude(u)) {
flag = true;
}
}
for (Points p : list) {
if (p.CheckPoints(u)) {
flag = false;
break;
}
}
if (flag) {
list.add(u);
cnt++;
}
}
}
if (cnt != 2) {
System.out.println(cnt);
} else {
double s1, s2, s;
System.out.print("2 ");
Points p1 = list.get(0), p2 = list.get(1);
Points m;
if (lac.IsCollinear(p1) && lab.IsCollinear(p2) || lac.IsCollinear(p2) && lab.IsCollinear(p1))
m = a;
else if (lac.IsCollinear(p1) && lbc.IsCollinear(p2) || lac.IsCollinear(p2) && lbc.IsCollinear(p1))
m = c;
else
m = b;
Triangle triangle1 = new Triangle(m, list.get(0), list.get(1));
s1 = triangle1.getArea();
s1 = Check.sswr(s1, 3);
s = this.getArea();
s = Check.sswr(s, 3);
s2 = s - s1;
s2 = Check.sswr(s2, 3);
System.out.println(Math.min(s1, s2) + " " + Math.max(s1, s2));
}
}
}
class Line {
private Points m;
private Points n;
private double k;
private double b;
private double A;
private double B2;
private double C;
private double length;
public Line() {
}
public Line(Points m, Points n) {
this.m = m;
this.n = n;
SetLine();
}
public void setLength() {
length = m.PointsDistance(n.getX(), n.getY());
}
public double getA() {
return A;
}
public void setA(double a) {
A = a;
}
public double getB2() {
return B2;
}
public void setB2(double b2) {
B2 = b2;
}
public double getC() {
return C;
}
public void setC(double c) {
C = c;
}
public double getB() {
return b;
}
public void setB(double b) {
this.b = b;
}
public double getK() {
return k;
}
public void setK(double k) {
this.k = k;
}
public Points getN() {
return n;
}
public void setN(Points n) {
this.n = n;
// System.out.println("n :"+this.n.getX()+" "+this.n.getY());
}
public Points getM() {
return m;
}
public void setM(Points m) {
this.m = m;
// System.out.println("m :"+this.m.getX()+" "+this.m.getY());
}
public double getLength() {
return length;
}
public boolean CheckLine() {
if (m.getX() == n.getX() && m.getY() == n.getY()) {
System.out.println("points coincide");
return false;
}
return true;
}
public double slope() {
if (m.getX() == n.getX())
return POSITIVE_INFINITY;
else
return (m.getY() - n.getY()) / (m.getX() - n.getX());
}
public void SetLine() {
setK(Check.sswr(slope(), 6));
setB(Check.sswr(m.getY() - m.getX() * getK(), 6));
setA(m.getY() - n.getY());
setB2(n.getX() - m.getX());
setC(m.getX() * n.getY() - n.getX() * m.getY());
setLength();
}
public double distance(Points a) {
return Math.abs(getA() * a.getX() + getB2() * a.getY() + getC()) / Math.sqrt(getA() * getA() + getB2() * getB2());
}
public Points CrossoverPoint(Line l) {
Points CroPoint = new Points();
if (!IsParallel(l)) {
double x1 = (getB2() * l.getC() - l.getB2() * getC()) / (getA() * l.getB2() - l.getA() * getB2());
double y1 = (l.getA() * getC() - getA() * l.getC()) / (getA() * l.getB2() - l.getA() * getB2());
//System.out.println( "crp "+CroPoint.getX()+","+CroPoint.getY() );
CroPoint.setX(x1);
CroPoint.setY(y1);
return CroPoint;
}
// else
return null;
}
public boolean IsCoincide(Line l) {//判断两直线是否重合
if (slope() == l.slope() && IsCollinear(l.getM()) && IsCollinear(l.getN()))
return true;
return false;
}
public boolean IsPerpendicular(Line l) {//判断直线是否垂直
if (slope() == POSITIVE_INFINITY && l.slope() == 0 || slope() == 0 && l.slope() == POSITIVE_INFINITY)//斜率不存在的情况
return true;
if (slope() * l.slope() == -1)//斜率相乘等于-1垂直
return true;
return false;
}
public boolean IsReallyCrossover(Line l) {//判断两线段是否相交
Points m = CrossoverPoint(l);
// System.out.println( (m!=null&&l.IsReallyCollinearInclude(m)));
if (m != null && l.IsReallyCollinearInclude(m) && IsReallyCollinearInclude(m))
return true;
return false;
}
public Points IsReallyCrossoverReturnPoint(Line l) {//判断两线段是否相交
Points m = CrossoverPoint(l);
// System.out.println( (m!=null&&l.IsReallyCollinearInclude(m)));
if (m != null && l.IsReallyCollinearInclude(m) && IsReallyCollinearInclude(m))
return m;
return null;
}
public boolean IsCollinear(Points a) {//判断点是否在直线上
if (m.getX() == n.getX()) {
if (m.getX() == a.getX())
return true;
else
return false;
}
if (Math.abs(getA() * a.getX() + getB2() * a.getY() + getC()) < 0.01)
return true;
return false;
}
public boolean IsReallyCollinear(Points a) {
if(m.getX() == n.getX() && m.getX() == a.getX() ){
if(a.getY() > Math.min(m.getY(),n.getY() ) && a.getY() < Math.max(m.getY(),n.getY()))
return true;
else
return false;
}
else if(m.getY() == n.getY() && m.getY() == a.getY() ){
if(a.getX() > Math.min(m.getX(),n.getX() ) && a.getX() < Math.max(m.getX(),n.getX()))
return true;
else
return false;
}
else if (a.getX() > Math.min(m.getX(), n.getX()) && a.getX() < Math.max(m.getX(), n.getX()) && a.getY() > Math.min(m.getY(), n.getY()) && a.getY() < Math.max(m.getY(), n.getY()))
return true;
else
return false;
}
/*
public boolean IsReallyCollinearInclude(Points a) {
if (!IsCollinear(a))
return false;
if (a.getX() >= Math.min(m.getX(), n.getX()) && a.getX() <= Math.max(m.getX(), n.getX()) && a.getY() >= Math.min(m.getY(), n.getY()) && a.getY() <= Math.max(m.getY(), n.getY()))
return true;
else
return false;
}*/
public boolean IsReallyCollinearInclude(Points a){
if(!IsCollinear(a))
return false;
if(getM().CheckPoints(a) || getN().CheckPoints(a))
return true;
if( ( a.getX()-getM().getX() ) * (a.getX() - getN().getX()) < 0 || ( a.getY()-getM().getY() ) * (a.getY() - getN().getY()) <0 )
return true;
return false;
}
public boolean IsParallel(Line l) {
if (this.slope() == l.slope()) {
return true;
} else
return false;
}
public int whichSide(Points p) {//判断点在直线哪一侧，返回0在直线上，小于0右侧，大于0左侧
if (getA() * p.getX() + getB2() * p.getY() + getC() == 0)
return 0;
else if (getA() * p.getX() + getB2() * p.getY() + getC() < 0)
return -1;
else
return 1;
}
}
class Points {
private double x;
private double y;
public Points() {
}
public Points(double x, double y) {
this.x = x;
this.y = y;
}
public Points(Points a) {
this.x = a.getX();
this.y = a.getY();
}
public double getX() {
return this.x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return this.y;
}
public void setY(double y) {
this.y = y;
}
public boolean CheckPoints(Points p) {
if (Math.abs(getX() - p.getX()) < 0.001 && Math.abs(getY() - p.getY()) < 0.001) {
//System.out.println("points coincide");
return true;
} else
return false;
}
public double PointsDistance(double x, double y) {
return Math.sqrt(Math.pow((x - this.x), 2) + Math.pow((y - this.y), 2));
}
}
类图： 
SourceMonitor生成的报表内容： 
期中测试
期中测试的三道题主要是考察对继承与多态的运用，由于是层层递进，所以就拿第三题来讲，前两题除了主函数都差不多。
7-3 点线面问题再重构（容器类）
题目： 在“点与线（继承与多态）”题目基础上，对题目的类设计进行重构，增加容器类保存点、线、面对象，并对该容器进行相应增、删、遍历操作。
在原有类设计的基础上，增加一个GeometryObject容器类，其属性为ArrayList
增加该类的add()方法及remove(int index)方法，其功能分别为向容器中增加对象及删除第index - 1（ArrayList中index>=0）个对象
在主方法中，用户循环输入要进行的操作（choice∈[0,4]），其含义如下：
1：向容器中增加Point对象
2：向容器中增加Line对象
3：向容器中增加Plane对象
4：删除容器中第index - 1个数据，若index数据非法，则无视此操作
0：输入结束
示例代码如下：
choice = input.nextInt();
while(choice != 0) {
switch(choice) {
case 1://insert Point object into list
...
break;
case 2://insert Line object into list
...
break;
case 3://insert Plane object into list
...
break;
case 4://delete index - 1 object from list
int index = input.nextInt();
...
}
choice = input.nextInt();
}
输入结束后，按容器中的对象顺序分别调用每个对象的display()方法进行输出。
类图如下所示：
classdiagram.jpg
以下情况为无效作业
无法运行
设计不符合所给类图要求
未通过任何测试点测试
判定为抄袭
输入格式:
switch(choice) {
case 1://insert Point object into list
输入“点”对象的x，y值
break;
case 2://insert Line object into list
输入“线”对象两个端点的x，y值
break;
case 3://insert Plane object into list
输入“面”对象的颜色值
break;
case 4://delete index - 1 object from list
输入要删除的对象位置（从1开始）
...
}
输出格式:
Point、Line、Plane的输出参考题目2
删除对象时，若输入的index超出合法范围，程序自动忽略该操作
输入样例:
在这里给出一组输入。例如：
1
3.4
5.6
2
4.4
8.0
0.98
23.888
Red
3
Black
1
9.8
7.5
3
Green
4
3
0
输出样例:
在这里给出相应的输出。例如：
(3.40,5.60)
The line's color is:Red
The line's begin point's Coordinate is:
(4.40,8.00)
The line's end point's Coordinate is:
(0.98,23.89)
The line's length is:16.25
(9.80,7.50)
The Plane's color is:Green
试题分析： 题目很简单没什么好讲的，照着老师给的类图构建就行，主要注意两个点吧，一是输入颜色时要注意去掉前一个输入的回车，防止读取错误，二是删除操作index的限制条件，应该大于等于0，小于等于list的size。
源代码展示：
查看代码
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
class GeometryObject{
private List<Element> elementList = new ArrayList<>();
public List<Element> getElementList() {
return elementList;
}
public void add(Element element){
elementList.add(element);
}
public void remove(int index){
elementList.remove(index-1);
}
}//Element容器类
abstract class Element{
abstract void display();
}
class Plane extends Element{
private String color;
Plane(){}
Plane(String color){
this.color = color;
}
public void setColor(String color) {
this.color = color;
}
public String getColor() {
return color;
}
public void display(){
System.out.println("The Plane's color is:"+color);
}
}//面类
class Point extends Element{
private double x;
private double y;
Point(){}
Point(double x , double y ){
this.x = x;
this.y = y;
}
public void display(){
System.out.println(String.format("(%.2f,%.2f)", x ,y));
}
public void setX(double x) {
this.x = x;
}
public double getX() {
return x;
}
public void setY(double y) {
this.y = y;
}
public double getY() {
return y;
}
}//点类
class Line extends Element{
private Point point1;
private Point point2;
String color;
Line(){
}
Line(Point point1,Point point2,String color){
this.point1 = point1;
this.point2 = point2;
this.color = color;
}
public double getDistance(){
return Math.sqrt(Math.pow((point1.getX() - point2.getX()), 2) + Math.pow((point1.getY() - point2.getY()), 2));
}
public void display(){
System.out.println("The line's color is:"+color);
System.out.println("The line's begin point's Coordinate is:");
point1.display();
System.out.println("The line's end point's Coordinate is:");
point2.display();
System.out.println(String.format("The line's length is:%.2f",getDistance()));
}
public void setPoint1(Point point1) {
this.point1 = point1;
}
public Point getPoint1() {
return point1;
}
public void setPoint2(Point point2) {
this.point2 = point2;
}
public Point getPoint2() {
return point2;
}
public void setColor(String color) {
this.color = color;
}
public String getColor() {
return color;
}
}//线类
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
GeometryObject geometryObject = new GeometryObject();
int choice = in.nextInt();
Element element;
while(choice != 0) {
switch(choice) {
case 1://insert Point object into list
//element = inputPoint();
double x1,y1;
x1 = in.nextDouble();
y1 = in.nextDouble();
Point p = new Point(x1,y1);
element = p;
geometryObject.add(element);
break;
case 2://insert Line object into list
String color;
Point p1 = new Point(in.nextDouble(),in.nextDouble());
Point p2 = new Point(in.nextDouble(),in.nextDouble());
color = in.nextLine();color = in.nextLine();
Line line = new Line(p1,p2,color);
element = line;
geometryObject.add(element);
break;
case 3://insert Plane object into list
color = in.nextLine();color = in.nextLine();
Plane plane = new Plane(color);
element = plane;
geometryObject.add(element);
break;
case 4://delete index - 1 object from list
int index = in.nextInt();
if(index >= 0 && index <= geometryObject.getElementList().size())
geometryObject.remove(index);
}
choice = in.nextInt();
}
for (Element e : geometryObject.getElementList()){
e.display();
}
}
public static boolean checkPoint(double x){
if(x <= 0 || x > 200)
return false;
return true;
}
}//测试类
类图： 
SourceMonitor生成的报表内容： 
3. 采坑心得:
由于四边形和五边形类似三角形，有了前面的经验，坑不算多，只要分析清楚了其实就是照着思路走罢了。主要可能踩的坑有可能一下几个：求四边形面积没考虑凹四边形的特殊性，处理直线与多边形关系的case中没去除冗余点，求面积时点的顺序不对，五边形连接问题考虑不全面等，这几个点容易出错，别的点应该不容易出错。
4. 改进心得:
可惜时间有点紧张（懒）没有对代码进行很好的重构，多边形有很多重复的地方，可以写个多边形父类，让三角形，四边形，五边形去继承他，同样也可以抽象这个多边形类，像求面积等方法作为抽象方法，可大幅提高代码的复用性。
5. 总结:
通过这几次作业，我对java有了进一步的了解，也体会到了在大工程下，面向对象的优势，同时通过对java进一步深入的学习，了解了继承与多态后更体会到了java的灵活与便利，如果再写类似的作业时一点可以写得更完善更清晰。
标签：总结,return,get,System,PTA,pointsList,第二次,public,out From： https://www.cnblogs.com/shafufu/p/16839105.html