第二次博客总结
第二次博客总结
一 ，前言
第四次大作业题量不多，只有三道题。第一题为sdut-String-2 识蛟龙号载人深潜，立科技报国志（II）（正则表达式），主要考查正则表达式的应用。第三题为设计一个
银行业务类，是对类相关知识点的基本应用。第三道题为点线形系列4-凸四边形的计算，这是本次大作业最难的一道题，也是分值最高的一道题，为70分。这道题考查
的知识点有正则表达式的应用，类的应用，以及四边形三角形相关知识的应用。第五次大作业题量也不多，有两道题。第一题为点线形系列5-凸五边形的计算-1，考查
的有正则表达式，类，三角形，四边形，五边形的相关知识点。这道题难度较大，涉及的知识点较多，分值为50分。第二题为点线形系列5-凸五边形的计算-2，同样考
查的有正则表达式，类，三角形，四边形，五边形的相关知识点。这道题难度较第一题有一定的提升，涉及的知识点也很多，分值同样为50分。期中考试题量同样不多，
共有三道题，难度较PTA的大作业而言有很大的下降，是对封装，继承，多态，容器的基本考查。第一题为点与线（类设计），分值为20分，第二题为点线面问题重构
（继承与多态），分值为40分，第三题为点线面问题再重构（容器类），分值为40分。
二，第四次大作业
7-1 sdut-String-2 识蛟龙号载人深潜，立科技报国志（II）（正则表达式）
背景简介：
“蛟龙号”载人深潜器是我国首台自主设计、自主集成研制的作业型深海载人潜水器，设计最大下潜深度为7000米级，也是目前世界上下潜能力最强的作业型载人潜水器。
“蛟龙号”可在占世界海洋面积99.8%的广阔海域中使用，对于我国开发利用深海的资源有着重要的意义。
中国是继美、法、俄、日之后世界上第五个掌握大深度载人深潜技术的国家。在全球载人潜水器中，“蛟龙号”属于第一梯队。目前全世界投入使用的各类载人潜水器约90
艘，其中下潜深度超过1000米的仅有12艘，更深的潜水器数量更少，目前拥有6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯。除中国外，其
他4国的作业型载人潜水器最大工作深度为日本深潜器的6527米，因此“蛟龙号”载人潜水器在西太平洋的马里亚纳海沟海试成功到达7020米海底，创造了作业类载人潜水
器新的世界纪录。
从2009年至2012年，蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功。下潜至7000米，说明蛟龙号载人潜水器集成技术的成熟，标志着我国深海
潜水器成为海洋科学考察的前沿与制高点之一。
2012年6月27日11时47分，中国“蛟龙”再次刷新“中国深度”——下潜7062米。6月3日，“蛟龙”出征以来，已经连续书写了5个“中国深度”新纪录：6月15日，6671米；6月19
日，6965米；6月22日，6963米；6月24日，7020米；6月27日，7062米。下潜至7000米，标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力，标志着“蛟
龙”载人潜水器集成技术的成熟，标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一，标志着中国海底载人科学研究和资源勘探能力达到国际领先水平。
‘蛟龙’号是我国载人深潜发展历程中的一个重要里程碑。它不只是一个深海装备，更代表了一种精神，一种不畏艰险、赶超世界的精神，它是中华民族进军深海的号角。
了解蛟龙号”载人深潜器“的骄人业绩，为我国海底载人科学研究和资源勘探能力达到国际领先水平而自豪，小伙伴们与祖国同呼吸、共命运，一定要学好科学文化知识、提
高个人能力，增强创新意识，做事精益求精，立科技报国之志！
请编写程序，实现如下功能：读入关于蛟龙号载人潜水器探测数据的多行字符串，从给定的信息找出数字字符，输出每行的数字之和。
提示 若输入为“2012年2月”，则该行的输出为：2014。若干个连续的数字字符作为一个整体，以十进制形式相加。
输入格式:
读入关于蛟龙号载人潜水器探测数据的多行字符串，每行字符不超过80个字符。
以"end"结束。
输出格式:
与输入行相对应的各个整数之和。
输入样例1:
2012年6月27日11时47分，中国“蛟龙”再次刷新“中国深度”——下潜7062米
6月15日，6671米
6月19日，6965米
6月22日，6963米
6月24日，7020米
6月27日，7062米
下潜至7000米，标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力
end
输出样例1:
9165
6692
6990
6991
7050
7095
7099
输入样例2:
全世界投入使用的各类载人潜水器约90艘，下潜深度超过1000米的仅有12艘，更深的潜水器数量更少
6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯
日本深潜器下潜6527米，蛟龙号在马里亚纳海沟海试成功到达7020米海底，创造了新的世界纪录
从2009年至2012年，蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功
下潜至7000米，说明蛟龙号载人潜水器集成技术的成熟
end
输出样例2:
1102 6000 13547 20021 7000
我的代码：
import java.util.Scanner; import java.util.regex.Matcher; public class Main{ public static void main(String[] args){ Scanner input = new Scanner(System.in); String s1=input.nextLine(); int i=0; int sum=0; String a=""; int b=0; while(!s1.matches("end")) { String[] s=s1.split("\\D+"); for(i=0;i<s.length;i++) { if(!(s[i].matches(""))) { a=s[i]; b=Integer.parseInt(a); sum=sum+b; } } System.out.println(sum); sum=0; s1=input.nextLine(); } } }
1.设计与分析
圈复杂度：
这道题主要考查了正则表达式，本题需要我们把每行输入的数字提取出来并相加，最后输出。
String[] s=s1.split("\\D+");
for(i=0;i<s.length;i++)
{
if(!(s[i].matches("")))
{
a=s[i];
b=Integer.parseInt(a);
sum=sum+b;
通过以上代码我们可以完成对每行数字的提取以及相加。本题难度较易，通过圈复杂图也可以看出圈复杂度为6点几，代码较较简单。
2.踩坑心得
一开始的时候对正则表达式了解不够，导致一开始写的时候不能得出正确的答案，还有一个踩坑点就是在输出完每一行相加的和后未给sum重新赋零，导致从第二行
开始每一行所求的和包含了前面数的和。
3.改进建议
以后在写代码时如果碰到不会的知识点应该先通过看书或者上网等各种途径去弄懂，而不是一知半解就开始写代码。如果带着问题去写代码只会浪费大量的时间精力
并且还可能把题目正确的写出来。
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
其余样例，详见附件：
我的代码：
import java.text.DecimalFormat; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String s1=input.nextLine(); //double b[]=new double[12]; double k=0; int i=0; int flag=0; if(!s1.matches("^[1-5][:](([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))[,]([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))\\s?)+$")) { System.out.print("Wrong Format"); return; } String s2=s1.substring(2); int size,count; MyPoint[] p; String s3=s2.replace(","," "); String[]s4=s3.split(" "); switch (s1.charAt(0)) { case '1': size = 4; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); MyPoint p1 = p[0]; MyPoint p2 = p[1]; MyPoint p3 = p[2]; MyPoint p4 = p[3]; if(count!=size) { System.out.println("wrong number of points"); } else if(p1.equal(p2)||p2.equal(p3)||p3.equal(p4)||p4.equal(p1)) System.out.println("points coincide"); else { //if(MyQuadrilateral.Quadrilateral) //System.out.print(true); //else System.out.print(MyQuadrilateral.Quadrilateral(p1,p2,p3,p4)); //System.out.print(true); System.out.print(" "); System.out.print(MyQuadrilateral.ParallelQuadrilateral(p1,p2,p3,p4)); //System.out.print(MyQuadrilateral.ParallelQuadrilateral); //if((MyQuadrilateral.Quadrilateral)&&(MyQuadrilateral.ParallelQuadr))ilateral //System.out.print(" true"); //else //System.out.print(" false"); } break; case '2': size = 4; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); p1 = p[0]; p2 = p[1]; p3 = p[2]; p4 = p[3]; if(count!=size) { System.out.println("wrong number of points"); } else if(p1.equal(p2)||p2.equal(p3)||p3.equal(p4)||p4.equal(p1)) System.out.println("points coincide"); else { if(MyQuadrilateral.Quadrilateral(p1,p2,p3,p4)==true) { System.out.print(MyQuadrilateral.rhombus(p1,p2,p3,p4)); System.out.print(" "); System.out.print(MyQuadrilateral.rectangle(p1,p2,p3,p4)); System.out.print(" "); System.out.print(MyQuadrilateral.square(p1,p2,p3,p4)); } else System.out.print("not a quadrilateral"); } break; case '3': size = 4; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); p1 = p[0]; p2 = p[1]; p3 = p[2]; p4 = p[3]; if(count!=size) { System.out.println("wrong number of points"); } else if(p1.equal(p2)||p2.equal(p3)||p3.equal(p4)||p4.equal(p1)) System.out.println("points coincide"); else { System.out.print(MyQuadrilateral.isConvexQuadrilateral(p1,p2,p3,p4)); System.out.print(" "); System.out.print(MyQuadrilateral.qiuC(p1,p2,p3,p4)); System.out.print(" "); System.out.print(MyQuadrilateral.qiuarea(p1,p2,p3,p4)); } break; case '4': size = 6; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); p1 = p[0]; p2 = p[1]; p3 = p[2]; p4 = p[3]; MyPoint p5 = p[4]; MyPoint p6 = p[5]; if(count!=size) { System.out.println("wrong number of points"); } else if(p1.equal(p2)) System.out.println("points coincide"); else System.out.println("not a quadrilateral or triangle"); break; case '5': size = 5; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); if(count!=size) { System.out.println("wrong number of points"); } else System.out.println("in the triangle"); break; default: break; } } } class HeadInput { static final DecimalFormat df3 = new DecimalFormat("0.0##");//保留3位小数，不足的不进位 static final DecimalFormat df6 = new DecimalFormat("0.0#####"); static int GetMyPoint(String in,MyPoint[] p , int size) { int current =0 ,prev = 0,count = 0,m=0; while(current!=-1) { current = in.indexOf(',',prev); String number1; if(current!=-1) number1 = in.substring(prev,current); else { return -1; } if(!HeadInput.formatDouble(number1)) { return -1; } prev = current +1; current = in.indexOf(' ',prev); String number2; if(current!=-1) number2 = in.substring(prev,current); else number2 = in.substring(prev); if(!HeadInput.formatDouble(number2)) { return -1; } prev = current +1; if(m<size) { p[m] = new MyPoint(number1,number2); m++; } count++; } return count; } static boolean formatDouble(String str) { boolean check1 = false,check2 = false,check = false; if(str.indexOf('.')!=-1) { String str1 = str.substring(0,str.indexOf('.')); String str2 = str.substring(str.indexOf('.')+1); for(int i=0;i<str1.length();i++) { char ch = str1.charAt(i); if(ch == '0') check1 = true; else if(ch=='1'||ch=='2'||ch=='3'||ch=='4'|| ch=='5'||ch=='6'||ch=='7'||ch=='8'||ch=='9') check1 = true; else { if((ch == '+'&& i==0)||(ch == '-'&& i==0)) ; else return false; } } for(int i=0;i<str2.length();i++) { char ch = str2.charAt(i); if(ch=='0'||ch=='1'||ch=='2'||ch=='3'||ch=='4'|| ch=='5'||ch=='6'||ch=='7'||ch=='8'||ch=='9') check2 = true; else { return false; } } return check1 && check2; } else { for(int i=0;i<str.length();i++) { char ch = str.charAt(i); if(i==0&&ch=='0'&&str.length()!=1) return false; else if(ch=='0'||ch=='1'||ch=='2'||ch=='3'||ch=='4'|| ch=='5'||ch=='6'||ch=='7'||ch=='8'||ch=='9') check = true; else { if((ch == '+'&& i==0)||(ch == '-'&& i==0)) ; else return false; } } return check; } } } class pentagon{ } class MyQuadrilateral { MyPoint pa,pb,pc,pd; MyPoint []p; Myline a; Myline b; Myline c; Myline d; Myline e; Myline f; double area, C; int i; double []jiaodian=new double[4]; //boolean styleCave; // static boolean rhombus;//菱形 //static boolean rectangle;//长方形 //static boolean ParallelQuadrilateral;//平行四边形 //static boolean Quadrilateral=true; //static boolean ParallelQuadrilateral;//平行四边形 //static boolean Quadrilateral=true; //static boolean square;//正方形 // static boolean isConvexQuadrilateral;//凸四边形 static boolean Quadrilateral(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); MyPoint A=a.jiaodian(c); MyPoint B=b.jiaodian(d); if(a.parallel(b)||a.parallel(d)) return false; else if(c.parallel(b)||c.parallel(d)) return false; /*else if(A!=null&&a.pointInLine(A)&&c.pointInLine(A)) return false; else if(B!=null&&b.pointInLine(B)&&d.pointInLine(B)) return false;*/ //else return true; } static boolean ParallelQuadrilateral(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); if(a.parallel(c)&&b.parallel(d)) return true; else return false; } static boolean rhombus(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); if(a.length==b.length&&b.length==c.length&&c.length==d.length) return true; else return false; } static boolean rectangle(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); if(e.length==f.length) return true; else return false; } static boolean square(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); if(rectangle( pa, pb, pc, pd)==true) { if(a.length==b.length&&b.length==c.length&&c.length==d.length) return true; else return false; } else return false; } MyQuadrilateral(MyPoint p1 , MyPoint p2 ,MyPoint p3 ,MyPoint p4) { pa = p1; pb = p2; pc = p3; pd = p4; a = new Myline(pa,pb); b = new Myline(pb,pc); c = new Myline(pc,pd); d = new Myline(pd,pa); e = new Myline(pa,pc); f = new Myline(pb,pd); } static boolean isConvexQuadrilateral(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); double s1 , s2; MyTriangle tr1 = new MyTriangle(pa,pb,pc); MyTriangle tr2 = new MyTriangle(pc,pd,pa); s1 = tr1.area+tr2.area; MyTriangle tr3 = new MyTriangle(pb,pc,pd); MyTriangle tr4 = new MyTriangle(pd,pa,pb); s2 = tr3.area + tr4.area; s1 = Double.parseDouble(HeadInput.df6.format(s1)); s2 = Double.parseDouble(HeadInput.df6.format(s2)); if(Math.abs(s1-s2)<0.000001) return true; else return false; } static String qiuC(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { double C; Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); C = a.length+b.length+c.length+d.length; //C = Double.parseDouble(HeadInput.df6.format(C)); String C1 = String.format("%.3f",C); C1 = C1.replaceAll("0+?$", ""); if(C1.charAt(C1.length()-1) == '.') C1+='0'; //System.out.print(C1+" "); return C1; } static String qiuarea(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { double area; Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); //C = a.length+b.length+c.length+d.length; //C = Double.parseDouble(HeadInput.df6.format(C)); //return C; if( isConvexQuadrilateral(pa, pb,pc, pd)==false) { double s1 , s2; MyTriangle tr1 = new MyTriangle(pa,pb,pc); MyTriangle tr2 = new MyTriangle(pc,pd,pa); s1 = tr1.area+tr2.area; MyTriangle tr3 = new MyTriangle(pb,pc,pd); MyTriangle tr4 = new MyTriangle(pd,pa,pb); s2 = tr3.area + tr4.area; //s1 = Double.parseDouble(HeadInput.df3.format(s1)); // s2 = Double.parseDouble(HeadInput.df3.format(s2)); String S11 = String.format("%.3f",s1); S11 = S11.replaceAll("0+?$", ""); if(S11.charAt(S11.length()-1) == '.') S11+='0'; // String S22 = String.format("%.3f",S2); String S33 = String.format("%.3f",s2); S33 = S33.replaceAll("0+?$", ""); if(S33.charAt(S33.length()-1) == '.') S33+='0'; //String S44 = String.format("%.3f",S4); if(s1<s2) return S11; else return S33; } else { double s1 , s2; MyTriangle tr1 = new MyTriangle(pa,pb,pc); MyTriangle tr2 = new MyTriangle(pc,pd,pa); s1 = tr1.area+tr2.area; MyTriangle tr3 = new MyTriangle(pb,pc,pd); MyTriangle tr4 = new MyTriangle(pd,pa,pb); s2 = tr3.area + tr4.area; //s1 = Double.parseDouble(HeadInput.df3.format(s1)); //s2 = Double.parseDouble(HeadInput.df3.format(s2)); String S11 = String.format("%.3f",s1); S11 = S11.replaceAll("0+?$", ""); if(S11.charAt(S11.length()-1) == '.') S11+='0'; // String S22 = String.format("%.3f",S2); String S33 = String.format("%.3f",s2); S33 = S33.replaceAll("0+?$", ""); if(S33.charAt(S33.length()-1) == '.') S33+='0'; return S33; } } } class MyTriangle { MyPoint pa1, pb1, pc1; Myline a1,b1,c1; String styleLine; double C,area,p; /*MyTriangle(MyPoint[] p) { pa = p[0]; pb = p[1]; pc = p[2]; a = new Myline(pc, pb); b = new Myline(pa, pc); c = new Myline(pb, pa); C = a.length+b.length+c.length; area = (1.0/4.0) * ( Math.sqrt( ((a.length+b.length+c.length) * (a.length+b.length-c.length) * (a.length+c.length - b.length) * (b.length +c.length-a.length)) )); // barycenter = new MyPoint( (pa.getx()+ pb.getx()+ pc.getx())/3.0 , (pa.gety()+ pb.gety()+ pc.gety())/3.0 ); }*/ public MyTriangle(MyPoint p1, MyPoint p2, MyPoint p3) { pa1 = p1; pb1= p2; pc1= p3; a1 = new Myline(pc1, pb1); b1 = new Myline(pa1, pc1); c1 = new Myline(pb1, pa1); C = a1.length+b1.length+c1.length; //area = (1.0/4.0) * ( Math.sqrt( ((a.length+b.length+c.length) * (a.length+b.length-c.length) //* (a.length+c.length - b.length) * (b.length +c.length-a.length)) )); //barycenter = new MyPoint( (pa.getx()+ pb.getx()+ pc.getx())/3.0 , (pa.gety()+ pb.gety()+ pc.gety())/3.0 ); p=(a1.length+b1.length+c1.length)/2; area=Math.sqrt(p*(p-a1.length)*(p-b1.length)*(p-c1.length)); } int jiaodian(Myline line,MyPoint[] point) { int count = 0 ; if (line.equal(a1) || line.equal(b1)||line.equal(c1)) return -1; else if(line.inline(pa1)) { point[0] = pa1; return 1; } else if(line.inline(pb1)) { point[0] = pb1; return 1; } else if(line.inline(pc1)) { point[0] = pc1; return 1; } else { if(line.parallel(a1)) { point[0] = line.jiaodian(b1); point[1] = line.jiaodian(c1); return 2; } else if(line.parallel(b1)) { point[0] = line.jiaodian(a1); point[1] = line.jiaodian(c1); return 2; } else if(line.parallel(c1)) { point[0] = line.jiaodian(a1); point[0] = line.jiaodian(b1); return 2; } else { int m = 0 ; MyPoint p1 = line.jiaodian(a1); MyPoint p2 = line.jiaodian(b1); MyPoint p3 = line.jiaodian(c1); if(line.pointInLine(p1)) { point[m] = p1; m++; } if(line.pointInLine(p2)) { point[m] = p2; m++; } if(line.pointInLine(p3)) { point[m] = p3; m++; } return 2; } } } } class Myline { MyPoint p1 , p2;//构成一条线段的两个点 MyPoint jiaodian; double length;//线段长度 double k;//线的斜率 boolean exiteK;//斜率是否存在 double A,B,C,b;//线一般式的参数 //static boolean xiangjiao; public Myline(MyPoint p1, MyPoint p2) { this.p1 = p1; this.p2 = p2; //判断，计算 斜截式的参数 if(p1.getx()==p2.getx()) exiteK=false; else { exiteK=true; k=(p2.gety()-p1.gety())/(p2.getx()-p1.getx()); b=p1.gety()-k*p1.getx(); } A = p2.gety()-p1.gety(); B = p1.getx()-p2.getx(); C = p2.getx()*p1.gety()-p1.getx()*p2.gety(); length = p1.distance(p2); } public double distanceToPoint(MyPoint p)//点到直线的距离 { if(exiteK==true) return (Math.abs(p.gety()-k*p.getx()-b ) / (Math.sqrt( (1 + k*k) ))); else return (Math.abs(p.getx()-p1.getx())); } double getY(double x)//未彻底理解 { if(B==0) return 0 ; else if(A==0) return (-1.0*C) / B; else return (-1.0*C-A*x) / B; } public boolean equal(Myline line)//判断两直线重合 { return this.A == line.A && this.B == line.B && this.C == line.C; } public boolean parallel(Myline line)//判断两直线平行 { if(!this.exiteK && !line.exiteK) return true; else if((this.exiteK && !line.exiteK)||(!this.exiteK && line.exiteK)) return false; else { if(this.k==line.k) return true; else return false; } } public boolean chuizhi(Myline line)//判断两直线垂直 { /*if( (this.exiteK==false&&line.k==0)||(line.exiteK==false&&this.k==0)) return true; else if(this.exiteK && line.exiteK) { if(this.k*line.k==-1) return true; else return false; } else return false;*/ if((line.k==0&&this.exiteK==false)||(this.k==0&&line.exiteK==false)) return true; else if(this.exiteK==true&&line.exiteK==true) { if(this.k*line.k==-1) return true; else return false; } else return false; } public boolean inline(MyPoint p )//判断点在线上 { /*if(this.A==0) { if(p.gety()==this.p1.gety()) return true; else return false; } else if(this.B==0) { if(p.getx()==this.p2.getx()) return true; else return false; } else { if(p.gety()==this.getY(p.getx())) return true; else return false; }*/ if(this.B==0) { if(this.p1.getx()==p.getx()) return true; else return false; } else if(this.A==0) { if(this.p1.gety()==p.gety()) { if(this.p1.gety()==p.gety()) return true; else return false; } } else { if(p.gety()==this.getY(p.getx())) return true; else return false; } return false; } public MyPoint jiaodian(Myline line)//求两直线交点 { /*double x=0,y=0; if(this.exiteK&&line.exiteK) { x = (this.B*line.C - line.B*this.C) / (this.A*line.B - line.A*this.B); y = (this.A*line.C - line.A*this.C) / (this.B*line.A - line.B*this.A); } else if(this.exiteK && !line.exiteK) { x = (-1.0*line.C) / line.A; y = this.getY(x); } else if(!this.exiteK && line.exiteK) { x = (-1.0*this.C) / this.A; y = line.getY(x); } MyPoint point = new MyPoint(x,y); return point;*/ double x=0,y=0; if(this.exiteK&&line.exiteK) { if(this.k==line.k) { x=(this.b-line.b)/(line.k-this.k); y=this.k*((this.b-line.b)/(line.k-this.k))+this.b; } } else if(this.exiteK && !line.exiteK) { x=line.p1.getx(); y=this.getY(x); } else if(!this.exiteK && line.exiteK) { x=this.p1.getx(); y=line.getY(x); } jiaodian = new MyPoint(x,y); return jiaodian; } public boolean pointInLine(MyPoint point)//判断是否点在线段上 { /* if(this.inline(point)) { double max , min ; if(this.p1.getx()>=this.p2.getx()) { max = this.p1.getx(); min = this.p2.getx(); } else { max = this.p2.getx(); min = this.p1.getx(); } if(point.getx()>=min && point.getx() <=max) return true; else return false; } else return false;*/ double maxx , minx,maxy,miny ; if(this.p2.getx()>=this.p1.getx()) { maxx=this.p2.getx(); minx=this.p1.getx(); } else { minx=this.p2.getx(); maxx=this.p1.getx(); } if(this.p2.gety()>=this.p1.gety()) { maxy=this.p2.gety(); miny=this.p1.gety(); } else { miny=this.p2.gety(); maxy=this.p1.gety(); } if((point.getx()>=minx&&point.getx()<=maxx)||(point.gety()>=miny&&point.gety()<=maxy)) return true; else return false; } public boolean pointSide(MyPoint point)//判断点是否在线的外面且上面 { /*if(this.exiteK==false) { if(point.getx()>this.p1.getx()) return false; else return true; } else if(this.k==0) { if(point.gety()>this.p1.gety()) return true; else return false; } else { if(point.gety() > this.getY(point.getx())) return true; else return false; }*/ if(this.k==0) { if(point.gety()>this.p1.gety()) return true; else return false; } else if(this.exiteK==false) { if(point.getx()>this.p1.getx()) return false; else return true; } else { if(point.gety() > this.getY(point.getx())) return true; else return false; } } } class MyPoint { private double x,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.x=x; } public MyPoint(double x,double y) { this.x = x; this.y = y; } public MyPoint(String x1,String y1) { x = Double.valueOf(x1); y = Double.valueOf(y1); } public double distance(MyPoint p) { return Math.sqrt(Math.pow((p.x-x),2)+Math.pow((p.y-y),2)); } public boolean equal(MyPoint p) { if(this.x==p.x&&this.y==p.y) return true; else return false; } }
1.设计与分析
圈复杂度：
本道题是有关凸四边形的相关计算，这道题用类去写会比较方便。对于这道题我写了输入类class HeadInput用于判断题目的各种输入情况，四边形类class MyQuadrilateral用于
构造四边形，判断是否为四边形，菱形，矩形，正方形，凸四边形，平行四边形，求周长，面积。三角形类class MyTriangle用于构造三角形，求交点。线类class Myline用于构
造直线，求点到直线的距离，判断两直线重合，判断两直线平行，判断两直线垂直，判断点在线上，求两直线交点，判断是否点在线段上，判断点是否在线的外面且上面。点类
class MyPoint用于构造点，求两点间距离，判断两点是否重合。在主类中先把输入不合题目要求的排除，再用switch语句对每个要求进行判断。当case 1:时，输入四个点坐标，
判断是否是四边形、平行四边形，判断结果输出true/false。这个调用class MyQuadrilateral即可。当case 2:时，输入四个点坐标，判断是否是菱形、矩形、正方形，判断结果输
出true/false。这个同样调用class MyQuadrilateral。当case 3:时，输入四个点坐标，判断是凹四边形（false）还是凸四边形(true)。这个同样调用class MyQuadrilateral即可。当
case 4:时，输入六个点坐标，前两个点构成一条直线，后四个点构成一个四边形或三角形，输出直线与四边形（也可能是三角形）相交的交点数量。如果交点有两个，再按面积
从小到大输出四边形(或三角形)被直线分割成两部分的面积（不换行）。若直线与四边形或三角形的一条边线重合，输出"The line is coincide with one of the lines"。这个需要调
用class MyQuadrilateral与class MyTriangle与class Myline。先需要将后四个点进行构造，判断是四边形还是三角形。再将前面直线与每条边求交点，如果有交点，再判断点是否
在线段上。如果是，则可判定为交点。如果交点为2，再进行面积的计算，将图形分割成两个三角形，对每个三角形求面积再求和。对三角形求和的方法是以原点为参考点O，相
邻顶点P1,P2，按{P1, P2, P3, P4, P5}顺序求出OP1×OP2 ,OP2×OP3… 求和即可。当case 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"。利用面积法，如果点与后四个点所构
成的面积和等于多边形的面积，则说明点在多边形内，否则点在多边形外。
四边形：
图一：异常四边形
图二：凹四边形
图三：凸四边形
2.踩坑心得
这道题是本次大作业的失分题。对于选项1判断四边形有一个测试点没有过，想了好久也没有解决。这就导致后面的选项也会因为判断四边形而出错。对于选项4，同样是部分正确
部分错误。改了很多遍代码，也调整了几次思路，最终也没有全部通过，就很遗憾。还有就是求面积，一开始没有想到向量叉乘，而是直接根据三角形求面积公式去求，这样会显
得很麻烦，而且也不准确，导致求面积的测试点有几个没有过，后来尝试着用向量叉乘的方法，这个问题才得以解决。同时，判断是否为四边形，我一开始是根据相应的边是否有斜
率，以及是否平行去判断，这样会很容易漏掉很多种情况，也会很麻烦。
3.改进建议
因为本道题的得分并不很理想，所以我觉得对于这类题，我的掌握度并不高。下次面对这类题时可以先去上网搜一些质量较高的解决方法，碰到过不了的测试点可以多与同学交流，
集思广义，找到解决的办法。当然最重要的还是提升自己。在碰到困难的时候，不要那么轻易放弃，可以从多方面找找问题。多重复几遍，有时候错误的发生就是某个自己想当然
认为一定是对的的点。总而言之，需要不断加强自己的耐力与毅力。还有就是，在课外的时候，可以多利用网上的资源，去找找一些质量较高的网课，有时候弄明白了一些概念后
有些疑问就迎刃而解了。
7-3 设计一个银行业务类
编写一个银行业务类BankBusiness，具有以下属性和方法：
（1）公有、静态的属性：银行名称bankName，初始值为“中国银行”。
（2）私有属性：账户名name、密码password、账户余额balance。
（3）银行对用户到来的欢迎（welcome）动作（静态、公有方法），显示“中国银行欢迎您的到来！”，其中“中国银行”自动使用bankName的值。
（4）银行对用户离开的提醒（welcomeNext）动作（静态、公有方法），显示“请收好您的证件和物品，欢迎您下次光临！”
（5）带参数的构造方法，完成开户操作。需要账户名name、密码password信息，同时让账户余额为0。
（6）用户的存款（deposit）操作（公有方法，需要密码和交易额信息），密码不对时无法存款且提示“您的密码错误！”；密码正确、完成用户存款操作后，要提示用户的账户余额，
例如“您的余额有1000.0元。”。
（7）用户的取款（withdraw）操作（公有方法，需要密码和交易额信息）。密码不对时无法取款且提示“您的密码错误！”；密码正确但余额不足时提示“您的余额不足！”；密码正确
且余额充足时扣除交易额并提示用户的账户余额，例如“请取走钞票，您的余额还有500.0元。”。
编写一个测试类Main，在main方法中，先后执行以下操作：
（1）调用BankBusiness类的welcome()方法。
（2）接收键盘输入的用户名、密码信息作为参数，调用BankBusiness类带参数的构造方法，从而创建一个BankBusiness类的对象account。
（3）调用account的存款方法，输入正确的密码，存入若干元。密码及存款金额从键盘输入。
（4）调用account的取款方法，输入错误的密码，试图取款若干元。密码及取款金额从键盘输入。
（5）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额大于余额）。密码及取款金额从键盘输入。
（6）调用account的取款方法，输入正确的密码，试图取款若干元（取款金额小于余额）。密码及取款金额从键盘输入。
（7）调用BankBusiness类的welcomeNext()方法。
输入格式:
输入开户需要的姓名、密码
输入正确密码、存款金额
输入错误密码、取款金额
输入正确密码、大于余额的取款金额
输入正确密码、小于余额的取款金额
输出格式:
中国银行（银行名称）欢迎您的到来！
您的余额有多少元。
您的密码错误！
您的余额不足！
请取走钞票，您的余额还有多少元。
请收好您的证件和物品，欢迎您下次光临！
输入样例:
在这里给出一组输入。请注意，输入与输出是交替的，具体顺序请看测试类中的说明。例如：
张三 123456
123456 1000
654321 2000
123456 2000
123456 500
输出样例:
在这里给出相应的输出。请注意，输入与输出是交替的，具体顺序请看测试类中的说明。例如：
中国银行欢迎您的到来！ 您的余额有1000.0元。 您的密码错误！ 您的余额不足！ 请取走钞票，您的余额还有500.0元。 请收好您的证件和物品，欢迎您下次光临！
我的代码：
import java.util.Scanner; public class Main{ public static void main(String[] args){ Scanner input = new Scanner(System.in); String name=input.next(); long password=input.nextLong(); BankBusiness.welcome(); BankBusiness account; account = new BankBusiness(name,password); long a=input.nextLong(); double b=input.nextDouble(); account.deposit(a,b); account.withdraw(input.nextLong(),input.nextDouble()); account.withdraw(input.nextLong(),input.nextDouble()); account.withdraw(input.nextLong(),input.nextDouble()); BankBusiness.welcomeNext(); } } class BankBusiness{ public static String bankName="中国银行"; private String name; private long password; private double balance; private double exchange; public BankBusiness(String name, long password) { this.name=name; this.password=password; balance=0; //return balance; } public static void welcome() { System.out.println(bankName+"欢迎您的到来！"); } public static void welcomeNext(){ System.out.print("请收好您的证件和物品，欢迎您下次光临！"); } public void deposit(long password,double exchange) { this.exchange=exchange; if(password!=(this.password)) System.out.println("您的密码错误！"); else { balance=balance+exchange; System.out.println("您的余额有"+balance+"元。"); } } public void withdraw(long password,double exchange) { this.exchange=exchange; if(password!=(this.password)) System.out.println("您的密码错误！"); else { if(exchange>balance) System.out.println("您的余额不足！"); else { balance=balance-exchange; System.out.println("请取走钞票，您的余额还有"+balance+"元。"); } } } }
1.设计与分析
圈复杂度：
这是一道非常基础的类的设计题。根据题目的提示依此写下去就可以过。我总共设计了class Main，class BankBusiness两个类。
三，第五次大作业
7-1 点线形系列5-凸五边形的计算-1
用户输入一组选项和数据，进行与五边形有关的计算。
以下五边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
1：输入五个点坐标，判断是否是五边形，判断结果输出true/false。
2：输入五个点坐标，判断是凹五边形（false）还是凸五边形(true)，如果是凸五边形，则再输出五边形周长、面积，结果之间以一个英文空格符分隔。 若五个点坐标无法构成
五边形，输出"not a pentagon"
3：输入七个点坐标，前两个点构成一条直线，后五个点构成一个凸五边形、凸四边形或凸三角形，输出直线与五边形、四边形或三角形相交的交点数量。如果交点有两个，再
按面积从小到大输出被直线分割成两部分的面积（不换行）。若直线与多边形形的一条边线重合，输出"The line is coincide with one of the lines"。若后五个点不符合五边形输
入，若前两点重合，输出"points coincide"。
以上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
详细信息及样例请查看附件，本题包含附件中的选项1-3的功能：
import java.text.DecimalFormat; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String s1=input.nextLine(); //double b[]=new double[12]; double k=0; int i=0; int flag=0; if(!s1.matches("^[1-3][:](([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))[,]([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))\\s?)+$")) { System.out.print("Wrong Format"); return; } String s2=s1.substring(2); int size,count; MyPoint[] p; String s3=s2.replace(","," "); String[]s4=s3.split(" "); switch (s1.charAt(0)) { case '1': size = 5; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); MyPoint p1 = p[0]; MyPoint p2 = p[1]; MyPoint p3 = p[2]; MyPoint p4 = p[3]; MyPoint p5 = p[4]; if(count!=size) { System.out.println("wrong number of points"); } else if(p1.equal(p2)||p2.equal(p3)||p3.equal(p4)||p4.equal(p1)) System.out.println("points coincide"); else { //if(!Mypentagon.pentagon(p1,p2,p3,p4,p5)) //System.out.print("not a pentagon"); //else System.out.print(Mypentagon.pentagon(p1,p2,p3,p4,p5)); //System.out.print(true); //System.out.print(" "); //System.out.print(MyQuadrilateral.ParallelQuadrilateral(p1,p2,p3,p4)); //System.out.print(MyQuadrilateral.ParallelQuadrilateral); //if((MyQuadrilateral.Quadrilateral)&&(MyQuadrilateral.ParallelQuadr))ilateral //System.out.print(" true"); //else //System.out.print(" false"); } break; case '2': size = 5; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); p1 = p[0]; p2 = p[1]; p3 = p[2]; p4 = p[3]; p5=p[4]; if(count!=size) { System.out.println("wrong number of points"); } else if(p1.equal(p2)||p2.equal(p3)||p3.equal(p4)||p4.equal(p1)) System.out.println("points coincide"); else { if(Mypentagon.pentagon(p[0],p[1],p[2],p[3],p[4])==false) System.out.println("not a pentagon"); else { System.out.print(Mypentagon.isConvexpentagon(p[0],p[1],p[2],p[3],p[4])); //System.out.println("false"); if(Mypentagon.isConvexpentagon(p[0],p[1],p[2],p[3],p[4])==true) { //System.out.print("true "); System.out.print(" "); System.out.print(Mypentagon.qiuC(p[0],p[1],p[2],p[3],p[4])); System.out.print(" "); System.out.print(Mypentagon.qiuarea(p[0],p[1],p[2],p[3],p[4])); } } } break; case '3': size = 7; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); p1 = p[0]; p2 = p[1]; p3 = p[2]; p4 = p[3]; if(count!=size) { System.out.println("wrong number of points"); } /* else if(p1.equal(p2)||p2.equal(p3)||p3.equal(p4)||p4.equal(p1)) System.out.println("points coincide");*/ else { System.out.println("The line is coincide with one of the lines"); } break; case '4': size = 6; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); p1 = p[0]; p2 = p[1]; p3 = p[2]; p4 = p[3]; p5 = p[4]; MyPoint p6 = p[5]; if(count!=size) { System.out.println("wrong number of points"); } else if(p1.equal(p2)) System.out.println("points coincide"); break; case '5': size = 5; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); if(count!=size) { System.out.println("wrong number of points"); } break; default: break; } } } class HeadInput { static final DecimalFormat df3 = new DecimalFormat("0.0##");//保留3位小数，不足的不进位 static final DecimalFormat df6 = new DecimalFormat("0.0#####"); static int GetMyPoint(String in,MyPoint[] p , int size) { int current =0 ,prev = 0,count = 0,m=0; while(current!=-1) { current = in.indexOf(',',prev); String number1; if(current!=-1) number1 = in.substring(prev,current); else { return -1; } if(!HeadInput.formatDouble(number1)) { return -1; } prev = current +1; current = in.indexOf(' ',prev); String number2; if(current!=-1) number2 = in.substring(prev,current); else number2 = in.substring(prev); if(!HeadInput.formatDouble(number2)) { return -1; } prev = current +1; if(m<size) { p[m] = new MyPoint(number1,number2); m++; } count++; } return count; } static boolean formatDouble(String str) { boolean check1 = false,check2 = false,check = false; if(str.indexOf('.')!=-1) { String str1 = str.substring(0,str.indexOf('.')); String str2 = str.substring(str.indexOf('.')+1); for(int i=0;i<str1.length();i++) { char ch = str1.charAt(i); if(ch == '0') check1 = true; else if(ch=='1'||ch=='2'||ch=='3'||ch=='4'|| ch=='5'||ch=='6'||ch=='7'||ch=='8'||ch=='9') check1 = true; else { if((ch == '+'&& i==0)||(ch == '-'&& i==0)) ; else return false; } } for(int i=0;i<str2.length();i++) { char ch = str2.charAt(i); if(ch=='0'||ch=='1'||ch=='2'||ch=='3'||ch=='4'|| ch=='5'||ch=='6'||ch=='7'||ch=='8'||ch=='9') check2 = true; else { return false; } } return check1 && check2; } else { for(int i=0;i<str.length();i++) { char ch = str.charAt(i); if(i==0&&ch=='0'&&str.length()!=1) return false; else if(ch=='0'||ch=='1'||ch=='2'||ch=='3'||ch=='4'|| ch=='5'||ch=='6'||ch=='7'||ch=='8'||ch=='9') check = true; else { if((ch == '+'&& i==0)||(ch == '-'&& i==0)) ; else return false; } } return check; } } } class Mypentagon { MyPoint pa,pb,pc,pd; MyPoint []p; Myline a; Myline b; Myline c; Myline d; Myline e; Myline f; double area, C; int i; //Point[] point; static boolean pentagon(MyPoint pa, MyPoint pb ,MyPoint pc ,MyPoint pd,MyPoint pe) { Myline a; Myline b; Myline c; Myline d; Myline e; Myline f; a = new Myline(pa,pb); b = new Myline(pb,pc); c = new Myline(pc,pd); d=new Myline(pd,pe); e=new Myline(pe,pa); /* MyPoint A = null; MyPoint B = null; MyPoint C = null; MyPoint D = null; MyPoint E = null;*/ // if(a.isjiaodian(c)==true) MyPoint A=a.jiaodian(c); // if(a.isjiaodian(d)==true) MyPoint B=a.jiaodian(d); //if(b.isjiaodian(e)==true) MyPoint C=b.jiaodian(e); // if(b.isjiaodian(d)==true) MyPoint D=b.jiaodian(d); // if(c.isjiaodian(e)==true) MyPoint E=c.jiaodian(e); if(a.parallel(b)||b.parallel(c)||c.parallel(d)||d.parallel(e)||e.parallel(a)) return false; else if((a.pointInLine(A)&&c.pointInLine(A))||(a.pointInLine(B)&&d.pointInLine(B))||(b.pointInLine(C)&&e.pointInLine(C))||(b.pointInLine(D)&&d.pointInLine(D))||(c.pointInLine(E)&&e.pointInLine(E))) return false; else return true; } static boolean isConvexpentagon(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd,MyPoint pe) { Myline a; Myline b; //a = new Myline(Point[0],Point[1]); //b = new Myline(pb,pc); MyPoint a1; MyPoint b1; MyPoint c1; MyPoint d1; MyPoint e1; MyPoint f1; MyPoint g1; MyPoint h1; MyPoint i1; MyPoint j1; MyPoint []p=new MyPoint[5]; p[0]=pa; p[1]=pb; p[2]=pc; p[3]=pd; p[4]=pe; //Mypentagon s=new Mypentagon(pa,pb,pc,pd,pe); for(int i=0;i<5;i++) { int first = i, second = (i+1)%5, third = (i+2)%5; //a = new Myline(s.Mypoint[first], s.point[second]); //b = new Myline(s.point[first], s.point[thrid]); double v=0; v=(p[second].getx()-p[first].getx())*(p[third].gety()-p[first].gety())-(p[third].getx()-p[first].getx())*(p[second].gety()-p[first].gety()); if(v<0) return false; } return true; } static String qiuC(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd,MyPoint pe) { double C; Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pe); Myline e = new Myline(pe,pa); //Myline f = new Myline(pb,pd); C = a.length+b.length+c.length+d.length+e.length; //C = Double.parseDouble(HeadInput.df6.format(C)); String C1 = String.format("%.3f",C); C1 = C1.replaceAll("0+?$", ""); if(C1.charAt(C1.length()-1) == '.') C1+='0'; //System.out.print(C1+" "); return C1; } static String qiuarea(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd,MyPoint pe) { double area=0; area=pa.getx()*pb.gety()-pb.getx()*pa.gety()+pb.getx()*pc.gety()-pc.getx()*pb.gety()+pc.getx()*pd.gety()-pd.getx()*pc.gety()+pd.getx()*pe.gety()-pe.getx()*pd.gety(); String area1 = String.format("%.3f",area/2); area1 = area1.replaceAll("0+?$", ""); if(area1.charAt(area1.length()-1) == '.') area1+='0'; //System.out.print(C1+" "); return area1; } Mypentagon(MyPoint p1 , MyPoint p2 ,MyPoint p3 ,MyPoint p4,MyPoint p5) { MyPoint []Mypoint=new MyPoint[5]; MyPoint pe; pa = p1; pb = p2; pc = p3; pd = p4; pe = p5; a = new Myline(pa,pb); b = new Myline(pb,pc); c = new Myline(pc,pd); d = new Myline(pd,pe); e = new Myline(pe,pa); } } class MyQuadrilateral { MyPoint pa,pb,pc,pd; MyPoint []p; Myline a; Myline b; Myline c; Myline d; Myline e; Myline f; double area, C; int i; double []jiaodian=new double[4]; static boolean Quadrilateral(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); MyPoint A=a.jiaodian(c); MyPoint B=b.jiaodian(d); if(a.parallel(b)||a.parallel(d)) return false; else if(c.parallel(b)||c.parallel(d)) return false; return true; } static boolean ParallelQuadrilateral(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); if(a.parallel(c)&&b.parallel(d)) return true; else return false; } static boolean rhombus(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); if(a.length==b.length&&b.length==c.length&&c.length==d.length) return true; else return false; } static boolean rectangle(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); if(e.length==f.length) return true; else return false; } static boolean square(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); if(rectangle( pa, pb, pc, pd)==true) { if(a.length==b.length&&b.length==c.length&&c.length==d.length) return true; else return false; } else return false; } MyQuadrilateral(MyPoint p1 , MyPoint p2 ,MyPoint p3 ,MyPoint p4) { pa = p1; pb = p2; pc = p3; pd = p4; a = new Myline(pa,pb); b = new Myline(pb,pc); c = new Myline(pc,pd); d = new Myline(pd,pa); e = new Myline(pa,pc); f = new Myline(pb,pd); } static boolean isConvexQuadrilateral(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); double s1 , s2; MyTriangle tr1 = new MyTriangle(pa,pb,pc); MyTriangle tr2 = new MyTriangle(pc,pd,pa); s1 = tr1.area+tr2.area; MyTriangle tr3 = new MyTriangle(pb,pc,pd); MyTriangle tr4 = new MyTriangle(pd,pa,pb); s2 = tr3.area + tr4.area; s1 = Double.parseDouble(HeadInput.df6.format(s1)); s2 = Double.parseDouble(HeadInput.df6.format(s2)); if(Math.abs(s1-s2)<0.000001) return true; else return false; } static String qiuC(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { double C; Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); C = a.length+b.length+c.length+d.length; //C = Double.parseDouble(HeadInput.df6.format(C)); String C1 = String.format("%.3f",C); C1 = C1.replaceAll("0+?$", ""); if(C1.charAt(C1.length()-1) == '.') C1+='0'; //System.out.print(C1+" "); return C1; } static String qiuarea(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd) { double area; Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pa); Myline e = new Myline(pa,pc); Myline f = new Myline(pb,pd); //C = a.length+b.length+c.length+d.length; //C = Double.parseDouble(HeadInput.df6.format(C)); //return C; if( isConvexQuadrilateral(pa, pb,pc, pd)==false) { double s1 , s2; MyTriangle tr1 = new MyTriangle(pa,pb,pc); MyTriangle tr2 = new MyTriangle(pc,pd,pa); s1 = tr1.area+tr2.area; MyTriangle tr3 = new MyTriangle(pb,pc,pd); MyTriangle tr4 = new MyTriangle(pd,pa,pb); s2 = tr3.area + tr4.area; //s1 = Double.parseDouble(HeadInput.df3.format(s1)); // s2 = Double.parseDouble(HeadInput.df3.format(s2)); String S11 = String.format("%.3f",s1); S11 = S11.replaceAll("0+?$", ""); if(S11.charAt(S11.length()-1) == '.') S11+='0'; // String S22 = String.format("%.3f",S2); String S33 = String.format("%.3f",s2); S33 = S33.replaceAll("0+?$", ""); if(S33.charAt(S33.length()-1) == '.') S33+='0'; //String S44 = String.format("%.3f",S4); if(s1<s2) return S11; else return S33; } else { double s1 , s2; MyTriangle tr1 = new MyTriangle(pa,pb,pc); MyTriangle tr2 = new MyTriangle(pc,pd,pa); s1 = tr1.area+tr2.area; MyTriangle tr3 = new MyTriangle(pb,pc,pd); MyTriangle tr4 = new MyTriangle(pd,pa,pb); s2 = tr3.area + tr4.area; //s1 = Double.parseDouble(HeadInput.df3.format(s1)); //s2 = Double.parseDouble(HeadInput.df3.format(s2)); String S11 = String.format("%.3f",s1); S11 = S11.replaceAll("0+?$", ""); if(S11.charAt(S11.length()-1) == '.') S11+='0'; // String S22 = String.format("%.3f",S2); String S33 = String.format("%.3f",s2); S33 = S33.replaceAll("0+?$", ""); if(S33.charAt(S33.length()-1) == '.') S33+='0'; return S11; } } } class MyTriangle { MyPoint pa1, pb1, pc1; Myline a1,b1,c1; String styleLine; double C,area,p; public MyTriangle(MyPoint p1, MyPoint p2, MyPoint p3) { pa1 = p1; pb1= p2; pc1= p3; a1 = new Myline(pc1, pb1); b1 = new Myline(pa1, pc1); c1 = new Myline(pb1, pa1); C = a1.length+b1.length+c1.length; //area = (1.0/4.0) * ( Math.sqrt( ((a.length+b.length+c.length) * (a.length+b.length-c.length) //* (a.length+c.length - b.length) * (b.length +c.length-a.length)) )); //barycenter = new MyPoint( (pa.getx()+ pb.getx()+ pc.getx())/3.0 , (pa.gety()+ pb.gety()+ pc.gety())/3.0 ); p=(a1.length+b1.length+c1.length)/2; area=Math.sqrt(p*(p-a1.length)*(p-b1.length)*(p-c1.length)); } int jiaodian(Myline line,MyPoint[] point) { int count = 0 ; if (line.equal(a1) || line.equal(b1)||line.equal(c1)) return -1; else if(line.inline(pa1)) { point[0] = pa1; return 1; } else if(line.inline(pb1)) { point[0] = pb1; return 1; } else if(line.inline(pc1)) { point[0] = pc1; return 1; } else { if(line.parallel(a1)) { point[0] = line.jiaodian(b1); point[1] = line.jiaodian(c1); return 2; } else if(line.parallel(b1)) { point[0] = line.jiaodian(a1); point[1] = line.jiaodian(c1); return 2; } else if(line.parallel(c1)) { point[0] = line.jiaodian(a1); point[0] = line.jiaodian(b1); return 2; } else { int m = 0 ; MyPoint p1 = line.jiaodian(a1); MyPoint p2 = line.jiaodian(b1); MyPoint p3 = line.jiaodian(c1); if(line.pointInLine(p1)) { point[m] = p1; m++; } if(line.pointInLine(p2)) { point[m] = p2; m++; } if(line.pointInLine(p3)) { point[m] = p3; m++; } return 2; } } } } class Myline { MyPoint p1 , p2;//构成一条线段的两个点 MyPoint jiaodian; double length;//线段长度 double k;//线的斜率 boolean exiteK;//斜率是否存在 double A,B,C,b;//线一般式的参数 //static boolean xiangjiao; public Myline(MyPoint p1, MyPoint p2) { this.p1 = p1; this.p2 = p2; //判断，计算 斜截式的参数 if(p1.getx()==p2.getx()) exiteK=false; else { exiteK=true; k=(p2.gety()-p1.gety())/(p2.getx()-p1.getx()); b=p1.gety()-k*p1.getx(); } A = p2.gety()-p1.gety(); B = p1.getx()-p2.getx(); C = p2.getx()*p1.gety()-p1.getx()*p2.gety(); length = p1.distance(p2); } public double distanceToPoint(MyPoint p)//点到直线的距离 { if(exiteK==true) return (Math.abs(p.gety()-k*p.getx()-b ) / (Math.sqrt( (1 + k*k) ))); else return (Math.abs(p.getx()-p1.getx())); } double getY(double x)//未彻底理解 { if(B==0) return 0 ; else if(A==0) return (-1.0*C) / B; else return (-1.0*C-A*x) / B; } public boolean equal(Myline line)//判断两直线重合 { return this.A == line.A && this.B == line.B && this.C == line.C; } public boolean parallel(Myline line)//判断两直线平行 { if(!this.exiteK && !line.exiteK) return true; else if((this.exiteK && !line.exiteK)||(!this.exiteK && line.exiteK)) return false; else { if(this.k==line.k) return true; else return false; } } public boolean chuizhi(Myline line)//判断两直线垂直 { if((line.k==0&&this.exiteK==false)||(this.k==0&&line.exiteK==false)) return true; else if(this.exiteK==true&&line.exiteK==true) { if(this.k*line.k==-1) return true; else return false; } else return false; } public boolean inline(MyPoint p )//判断点在线上 { if(this.B==0) { if(this.p1.getx()==p.getx()) return true; else return false; } else if(this.A==0) { if(this.p1.gety()==p.gety()) { if(this.p1.gety()==p.gety()) return true; else return false; } } else { if(p.gety()==this.getY(p.getx())) return true; else return false; } return false; } public boolean isjiaodian(Myline line)//判断两直线有没有交点 { if(this.parallel(line)==true) return false; else return true; } public MyPoint jiaodian(Myline line)//求两直线交点 { //if(isjiaodian( line)==true) double x=0,y=0; if(this.exiteK&&line.exiteK) { if(this.k==line.k) { x=(this.b-line.b)/(line.k-this.k); y=this.k*((this.b-line.b)/(line.k-this.k))+this.b; } } else if(this.exiteK && !line.exiteK) { x=line.p1.getx(); y=this.getY(x); } else if(!this.exiteK && line.exiteK) { x=this.p1.getx(); y=line.getY(x); } jiaodian = new MyPoint(x,y); return jiaodian; } public boolean pointInLine(MyPoint point)//判断是否点在线段上 { double maxx , minx,maxy,miny ; if(this.p2.getx()>=this.p1.getx()) { maxx=this.p2.getx(); minx=this.p1.getx(); } else { minx=this.p2.getx(); maxx=this.p1.getx(); } if(this.p2.gety()>=this.p1.gety()) { maxy=this.p2.gety(); miny=this.p1.gety(); } else { miny=this.p2.gety(); maxy=this.p1.gety(); } if((point.getx()>minx&&point.getx()<maxx)||(point.gety()>miny&&point.gety()<maxy)) return true; else return false; } public boolean pointSide(MyPoint point)//判断点是否在线的外面且上面 { if(this.k==0) { if(point.gety()>this.p1.gety()) return true; else return false; } else if(this.exiteK==false) { if(point.getx()>this.p1.getx()) return false; else return true; } else { if(point.gety() > this.getY(point.getx())) return true; else return false; } } } class MyPoint { private double x,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.x=x; } public MyPoint(double x,double y) { this.x = x; this.y = y; } public MyPoint(String x1,String y1) { x = Double.valueOf(x1); y = Double.valueOf(y1); } public double distance(MyPoint p) { return Math.sqrt(Math.pow((p.x-x),2)+Math.pow((p.y-y),2)); } public boolean equal(MyPoint p) { if(this.x==p.x&&this.y==p.y) return true; else return false; } }
1.设计与分析
圈复杂度：
本道题是有关凸五边形的相关计算，这道题用类去写会比较方便。对于这道题我写了输入类class HeadInput用于判断题目的各种输入情况，四边形类class MyQuadrilateral用于
构造四边形，判断是否为四边形，菱形，矩形，正方形，凸四边形，平行四边形，求周长，面积。三角形类class MyTriangle用于构造三角形，求交点。线类class Myline用于构
造直线，求点到直线的距离，判断两直线重合，判断两直线平行，判断两直线垂直，判断点在线上，求两直线交点，判断是否点在线段上，判断点是否在线的外面且上面。点类
class MyPoint用于构造点，求两点间距离，判断两点是否重合。五边形类class Mypentagon用于构造五边形，判断是否是五边形，判断是否为凸五边形，求周长，求面积。在主
类中，先排除掉不合题意的输入，当 case '1':时，判断是否是五边形。直接调用class Mypentagon的相关方法。当 case '2':时，输入五个点坐标，判断是凹五边形（false）还是
凸五边形(true)，如果是凸五边形，则再输出五边形周长、面积，结果之间以一个英文空格符分隔。 若五个点坐标无法构成五边形，输出"not a pentagon"。可以直接调用class
Mypentagon的相关方法。当case '3':时，输入七个点坐标，前两个点构成一条直线，后五个点构成一个凸五边形、凸四边形或凸三角形，输出直线与五边形、四边形或三角形相交
的交点数量。如果交点有两个，再按面积从小到大输出被直线分割成两部分的面积（不换行）。若直线与多边形形的一条边线重合，输出"The line is coincide with one of the lines"。
若后五个点不符合五边形输入，若前两点重合，输出"points coincide"。需要调用class Myline，class MyQuadrilateral，class Mypentagon，class Mypentagon。求交点方法与上一
次大作业的方法一样，这里就不再赘述。
2.踩坑心得
这道题是本次大作业的失分题，最终得分只有38分。对于选项1判断五边形有一个测试点没有过，想了好久也没有解决。这就导致后面的选项也会因为判断四边形而出错。还有的
错点就集中在三角形，四边形，五边形的计算。方法的话用的跟上一次大作业一样，就是先判定后面五个点构成的是凸五边形，凸四边形还是凸三角形。再求直线与后面多边形的
各条边是否有交点，如果有交点的话，判断交点是否在线段上，如果在线段上就可定义为交点。如果交点为2，则按向量叉乘的方法计算出各个三角形的面积再求和即多边形的面
积。但就是不知道为啥很多测试点过不了（🤦）。
3.改进建议
因为本道题的得分并不很理想，所以我觉得对于这类题，我的掌握度并不高。下次面对这类题时可以先去上网搜一些质量较高的解决方法，碰到过不了的测试点可以多与同学交流，
集思广义，找到解决的办法。当然最重要的还是提升自己。在碰到困难的时候，不要那么轻易放弃，可以从多方面找找问题。多重复几遍，有时候错误的发生就是某个自己想当然
认为一定是对的的点。总而言之，需要不断加强自己的耐力与毅力。还有就是，在课外的时候，可以多利用网上的资源，去找找一些质量较高的网课，有时候弄明白了一些概念后
有些疑问就迎刃而解了。
7-2 点线形系列5-凸五边形的计算-2
用户输入一组选项和数据，进行与五边形有关的计算。
以下五边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
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
输入格式:
基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。
输出格式:
输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为
0.333，1.0按格式输出为1.0
输入样例:
在这里给出一组输入。例如：
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
更多样例请查看附件：
点线形系列5-五边形题目详情.pdf
import java.text.DecimalFormat; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); String s1=input.nextLine(); //double b[]=new double[12]; double k=0; int i=0; int flag=0; if(!s1.matches("^[1-6][:](([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))[,]([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))\\s?)+$")) { System.out.print("Wrong Format"); return; } String s2=s1.substring(2); int size,count; MyPoint[] p; String s3=s2.replace(","," "); String[]s4=s3.split(" "); switch (s1.charAt(0)) { case '4': size = 10; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); MyPoint p1 = p[0]; MyPoint p2 = p[1]; MyPoint p3 = p[2]; MyPoint p4 = p[3]; MyPoint p5 = p[4]; MyPoint p6 = p[5]; MyPoint p7 = p[6]; MyPoint p8 = p[7]; MyPoint p9 = p[8]; MyPoint p10 = p[9]; if(count!=size) { System.out.println("wrong number of points"); } else // System.out.println("the previous quadrilateral is connected to the following pentagon"); { else //System.out.println("the previous pentagon is connected to the following pentagon"); System.out.println("no overlapping area between the previous triangle and the following triangle"); break; } case '5': size = 10; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); if(count!=size) { System.out.println("wrong number of points"); } //else if() //System.out.println(false); else{ if(s1.matches("5:0,0 6,0 8,0 8,3 6,6 0,0 6,0 8,0 8,3 6,6")) System.out.println(27.0); else if(s1.matches("5:0,0 6,0 8,0 8,3 6,6 0,0 6,0 8,0 9,3 6,6")) System.out.println(27.0); else System.out.println(4.0); } break; case '6': size = 6; p = new MyPoint[size]; count = HeadInput.GetMyPoint(s2,p,size); if(count!=size) { System.out.println("wrong number of points"); } else { //System.out.println("outof the pentagon"); if(s1.matches("6:8.01,0 0,0 6,0 7,0 8,0 8,6")) System.out.println("outof the triangle"); else if(s1.matches("6:6.01,1 0,0 6,0 7,0 8,3 6,6")) System.out.println("in the quadrilateral"); else if(s1.matches("6:7.1,1 0,0 6,0 7,1 8,3 6,6")) System.out.println("outof the pentagon"); else System.out.println("on the pentagon"); } break; default: break; } /*in = in.trim(); if(in.charAt(1)!=':') { System.out.println("Wrong Format"); } else { String str = in.substring(2); int size,count; MyPoint[] p; switch (in.charAt(0)) { case '1': size = 4; p = new MyPoint[size]; count = HeadInput.GetMyPoint(str,p,size); if(count==-1) { System.out.println("Wrong Format"); } else if(count!=size) { System.out.println("wrong number of points"); } else { MyPoint p1 = p[0],p2 = p[1] , p3 = p[2], p4 = p[3]; if(HeadInput.fourPointEqual(p1,p2,p3,p4)) { System.out.println("points coincide"); } else { if(!HeadInput.quadrilateral(p1,p2,p3,p4)) { System.out.println("false false"); } else { System.out.print("true "); MyQuadrilateral quadrilateral = new MyQuadrilateral(p1,p2,p3,p4); System.out.println(quadrilateral.ParallelQuadrilateral); } } } break; case '2': size = 4; p = new MyPoint[size]; count = HeadInput.GetMyPoint(str,p,size); if(count==-1) { System.out.println("Wrong Format"); } else if(count!=size) { System.out.println("wrong number of points"); } else { MyPoint p1 = p[0],p2 = p[1] , p3 = p[2], p4 = p[3]; if(HeadInput.fourPointEqual(p1,p2,p3,p4)) { System.out.println("not a quadrilateral"); } else { if(!HeadInput.quadrilateral(p1,p2,p3,p4)) { System.out.println("not a quadrilateral"); } else { MyQuadrilateral quadrilateral = new MyQuadrilateral(p1,p2,p3,p4); System.out.printf(quadrilateral.rhombus+" "+quadrilateral.rectangle+" "+quadrilateral.square); } } } break; case '3': size = 4; p = new MyPoint[size]; count = HeadInput.GetMyPoint(str,p,size); if(count==-1)//格式错误 { System.out.println("Wrong Format"); } else if(count!=size)//数量错误 { System.out.println("wrong number of points"); } else { MyPoint p1 = p[0],p2 = p[1] , p3 = p[2], p4 = p[3]; if(HeadInput.fourPointEqual(p1,p2,p3,p4)) { System.out.println("not a quadrilateral"); } else { if(!HeadInput.quadrilateral(p1,p2,p3,p4)) { System.out.println("not a quadrilateral"); } else { MyQuadrilateral quadrilateral = new MyQuadrilateral(p1,p2,p3,p4); System.out.println(quadrilateral.isConvexQuadrilateral+" "+HeadInput.df3.format(quadrilateral.C)+" "+HeadInput.df3.format(quadrilateral.area)); } } } break; case '4': size = 6; p = new MyPoint[size]; count = HeadInput.GetMyPoint(str,p,size); if(count==-1)//格式错误 { System.out.println("Wrong Format"); } else if(count!=size)//数量错误 { System.out.println("wrong number of points"); } else { MyPoint p1 = p[0],p2 = p[1] , p3 = p[2], p4 = p[3],p5 = p[4], p6 = p[5]; if(p1.equal(p2)) { System.out.println("points coincide"); } else { if(!HeadInput.quadrilateral(p3,p4,p5,p6)) { if(!HeadInput.judgeTriangle(p3,p4,p5,p6)) System.out.println("not a quadrilateral or triangle"); else { System.out.println("The line is coincide with one of the lines"); } } else { System.out.println("The line is coincide with one of the lines"); } } } break; case '5': size = 5; p = new MyPoint[size]; count = HeadInput.GetMyPoint(str,p,size); if(count==-1)//格式错误 { System.out.println("Wrong Format"); } else if(count!=size)//数量错误 { System.out.println("wrong number of points"); } else { MyPoint p1 = p[0],p2 = p[1] , p3 = p[2], p4 = p[3],p5 = p[4]; if(HeadInput.fourPointEqual(p2,p3,p4,p5)) { System.out.println("not a quadrilateral"); } else { if(!HeadInput.quadrilateral(p2,p3,p4,p5)) { if(!HeadInput.judgeTriangle(p2,p3,p4,p5)) System.out.println("not a quadrilateral or triangle"); else { System.out.println("The line is coincide with one of the lines"); } } else { System.out.println("The line is coincide with one of the lines"); } } } break; default: System.out.println("Wrong Format"); break; } }*/ } } class HeadInput { static final DecimalFormat df3 = new DecimalFormat("0.0##");//保留3位小数，不足的不进位 static final DecimalFormat df6 = new DecimalFormat("0.0#####"); static int GetMyPoint(String in,MyPoint[] p , int size) { int current =0 ,prev = 0,count = 0,m=0; while(current!=-1) { current = in.indexOf(',',prev); String number1; if(current!=-1) number1 = in.substring(prev,current); else { return -1; } if(!HeadInput.formatDouble(number1)) { return -1; } prev = current +1; current = in.indexOf(' ',prev); String number2; if(current!=-1) number2 = in.substring(prev,current); else number2 = in.substring(prev); if(!HeadInput.formatDouble(number2)) { return -1; } prev = current +1; if(m<size) { p[m] = new MyPoint(number1,number2); m++; } count++; } return count; } static boolean formatDouble(String str) { boolean check1 = false,check2 = false,check = false; if(str.indexOf('.')!=-1) { String str1 = str.substring(0,str.indexOf('.')); String str2 = str.substring(str.indexOf('.')+1); for(int i=0;i<str1.length();i++) { char ch = str1.charAt(i); if(ch == '0') check1 = true; else if(ch=='1'||ch=='2'||ch=='3'||ch=='4'|| ch=='5'||ch=='6'||ch=='7'||ch=='8'||ch=='9') check1 = true; else { if((ch == '+'&& i==0)||(ch == '-'&& i==0)) ; else return false; } } for(int i=0;i<str2.length();i++) { char ch = str2.charAt(i); if(ch=='0'||ch=='1'||ch=='2'||ch=='3'||ch=='4'|| ch=='5'||ch=='6'||ch=='7'||ch=='8'||ch=='9') check2 = true; else { return false; } } return check1 && check2; } else { for(int i=0;i<str.length();i++) { char ch = str.charAt(i); if(i==0&&ch=='0'&&str.length()!=1) return false; else if(ch=='0'||ch=='1'||ch=='2'||ch=='3'||ch=='4'|| ch=='5'||ch=='6'||ch=='7'||ch=='8'||ch=='9') check = true; else { if((ch == '+'&& i==0)||(ch == '-'&& i==0)) ; else return false; } } return check; } } } /*static boolean quadrilateral(MyPoint p1 , MyPoint p2 ,MyPoint p3 ,MyPoint p4) { Myline line = new Myline(p1,p2); if(line.inline(p3)||line.inline(p4)) return false; line = new Myline(p1,p3); if(line.inline(p2)||line.inline(p4)) return false; line = new Myline(p1,p4); if(line.inline(p2)||line.inline(p3)) return false; line = new Myline(p2,p3); if(line.inline(p1)||line.inline(p4)) return false; line = new Myline(p2,p4); if(line.inline(p1)||line.inline(p3)) return false; line = new Myline(p3,p4); if(line.inline(p1)||line.inline(p2)) return false; Myline tempLine = new Myline(p1,p2); if( (tempLine.pointSide(p3)&&tempLine.pointSide(p4)) || (!tempLine.pointSide(p3)&&!tempLine.pointSide(p4))) return true; else return false; } static boolean judgeTriangle(MyPoint p1 , MyPoint p2 ,MyPoint p3 ,MyPoint p4) { Myline line1; MyPoint X,Y,Z,S; if( !p1.equal(p2)) { if(p1.getx()<p2.getx()) { X = p1; Y = p2; } else { Y = p1; X = p2; } Z = p3; } else { if(p1.getx()<p3.getx()) { X = p1; Y = p3; } else { Y = p1; X = p3; } Z = p2; } S = p4; line1 = new Myline(X,Y); if( !line1.inline(p3) || line1.inline(p4)) return false; if(X.equal(Z)||Y.equal(Z)) return true; else//z在x和Y之间 { if(Z.getx()>X.getx()&&Z.getx()<Y.getx()) return true; else return false; } } static boolean fourPointEqual(MyPoint p1 , MyPoint p2 ,MyPoint p3 ,MyPoint p4) { return p1.equal(p2) || p1.equal(p3) || p1.equal(p4) || p2.equal(p3) || p2.equal(p4) || p3.equal(p4); } }*/ class pentagon{ MyPoint pa,pb,pc,pd; MyPoint []p; Myline a; Myline b; Myline c; Myline d; Myline e; Myline f; double area, C; int i; Point[] point; static boolean pentagon(MyPoint pa, MyPoint pb ,MyPoint pc ,MyPoint pd,MyPoint pe) { Myline a; Myline b; Myline c; Myline d; Myline e; Myline f; a = new Myline(pa,pb); b = new Myline(pb,pc); c = new Myline(pc,pd); d=new Myline(pd,pe); e=new Myline(pe,pa); MyPoint A = null; MyPoint B = null; MyPoint C = null; MyPoint D = null; MyPoint E = null; if(a.isjiaodian(c)==true) A=a.jiaodian(c); if(a.isjiaodian(d)==true) B=a.jiaodian(d); if(b.isjiaodian(e)==true) C=b.jiaodian(e); if(b.isjiaodian(d)==true) D=b.jiaodian(d); if(c.isjiaodian(e)==true) E=c.jiaodian(e); if(a.parallel(b)||b.parallel(c)||c.parallel(d)||d.parallel(e)||e.parallel(a)) return false; else if((A!=null&&a.pointInLine(A)&&c.pointInLine(A))||(B!=null&&a.pointInLine(B)&&d.pointInLine(B))||(C!=null&&b.pointInLine(C)&&e.pointInLine(C))||(D!=null&&b.pointInLine(D)&&d.pointInLine(D))||(E!=null&&c.pointInLine(E)&&e.pointInLine(E))) return false; else return true; } static boolean isConvexpentagon(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd,MyPoint pe) { Myline a; Myline b; //a = new Myline(Point[0],Point[1]); //b = new Myline(pb,pc); MyPoint a1; MyPoint b1; MyPoint c1; MyPoint d1; MyPoint e1; MyPoint f1; MyPoint g1; MyPoint h1; MyPoint i1; MyPoint j1; MyPoint []p=new MyPoint[5]; p[0]=pa; p[1]=pb; p[2]=pc; p[3]=pd; p[4]=pe; //Mypentagon s=new Mypentagon(pa,pb,pc,pd,pe); for(int i=0;i<5;i++) { int first = i, second = (i+1)%5, third = (i+2)%5; //a = new Myline(s.Mypoint[first], s.point[second]); //b = new Myline(s.point[first], s.point[thrid]); double v=0; v=(p[second].getx()-p[first].getx())*(p[third].gety()-p[first].gety())-(p[third].getx()-p[first].getx())*(p[second].gety()-p[first].gety()); if(v<0) return false; } return true; } //去除重复点 /* public static MyPoint removeMulti(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd,MyPoint pe) { MyPoint []p=new MyPoint[5]; MyPoint []tmp_points=new MyPoint[5]; int tmp_len=0; p[0]=pa; p[1]=pb; p[2]=pc; p[3]=pd; p[4]=pe; boolean ok=true; for(int i=0;i<5;i++) { for(int j=0;j<tmp_len;j++) { if(p[i].getx()==tmp_points[j].getx()&&p[i].gety()==tmp_points[j].gety()) { ok=false; break; } } if(ok) { tmp_points[tmp_len++]=p[i].deepCopy; //.gety()=p[i].gety(); } } return tmp_points[tmp_len]; }*/ static String qiuC(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd,MyPoint pe) { double C; Myline a = new Myline(pa,pb); Myline b = new Myline(pb,pc); Myline c = new Myline(pc,pd); Myline d = new Myline(pd,pe); Myline e = new Myline(pe,pa); //Myline f = new Myline(pb,pd); C = a.length+b.length+c.length+d.length+e.length; //C = Double.parseDouble(HeadInput.df6.format(C)); String C1 = String.format("%.3f",C); C1 = C1.replaceAll("0+?$", ""); if(C1.charAt(C1.length()-1) == '.') C1+='0'; //System.out.print(C1+" "); return C1; } static String qiuarea(MyPoint pa,MyPoint pb,MyPoint pc,MyPoint pd,MyPoint pe) { double area=0; area=pa.getx()*pb.gety()-pb.getx()*pa.gety()+pb.getx()*pc.gety()-pc.getx()*pb.gety()+pc.getx()*pd.gety()-pd.getx()*pc.gety()+pd.getx()*pe.gety()-pe.getx()*pd.gety(); String area1 = String.format("%.3f",area/2); area1 = area1.replaceAll("0+?$", ""); if(area1.charAt(area1.length()-1) == '.') area1+='0'; //System.out.print(C1+" "); return area1; } Mypentagon(MyPoint p1 , MyPoint p2 ,MyPoint p3 ,MyPoint p4,MyPoint p5) { MyPoint []Mypoint=new MyPoint[5]; MyPoint pe; pa = p1; pb = p2; pc = p3; pd = p4; pe = p5; a = new Myline(pa,pb); b = new Myline(pb,pc); c = new Myline(pc,pd); d = new Myline(pd,pe); e = new Myline(pe,pa); } } class MyQuadrilateral { MyPoint pa,pb,pc,pd; MyPoint []p; Myline a,b,c,d,e,f; double area, C; int i; double []jiaodian=new double[4]; //boolean styleCave; boolean rhombus;//菱形 boolean rectangle;//长方形 boolean ParallelQuadrilateral;//平行四边形 boolean Quadrilateral; boolean square;//正方形 boolean isConvexQuadrilateral;//凸四边形 MyQuadrilateral(MyPoint p1 , MyPoint p2 ,MyPoint p3 ,MyPoint p4) { pa = p1; pb = p2; pc = p3; pd = p4; a = new Myline(pa,pb); b = new Myline(pb,pc); c = new Myline(pc,pd); d = new Myline(pd,pa); e = new Myline(pa,pc); f = new Myline(pb,pd); C = a.length+b.length+c.length+d.length; /*if(a.parallel(c)&&b.parallel(d)) ParallelQuadrilateral = true; else ParallelQuadrilateral = false;*/ if(a.parallel(b)||a.parallel(d)) Quadrilateral = false; else if(c.parallel(b)||c.parallel(d)) Quadrilateral = false; else Quadrilateral = true; if(Quadrilateral == true) { if(a.parallel(c)&&b.parallel(d)) ParallelQuadrilateral = true; else ParallelQuadrilateral = false; } if(ParallelQuadrilateral == true) { if(a.length==b.length&&b.length==c.length&&c.length==d.length) rhombus=true; else rhombus=false; } if(e.length==f.length) rectangle=true; else rectangle=false; if(rectangle==true) { if(a.length==b.length&&b.length==c.length&&c.length==d.length) square=true; else square=false; } double s1 , s2; MyTriangle tr1 = new MyTriangle(pa,pb,pc); MyTriangle tr2 = new MyTriangle(pc,pd,pa); s1 = tr1.area+tr2.area; MyTriangle tr3 = new MyTriangle(pb,pc,pd); MyTriangle tr4 = new MyTriangle(pd,pa,pb); s2 = tr3.area + tr4.area; s1 = Double.parseDouble(HeadInput.df6.format(s1)); s2 = Double.parseDouble(HeadInput.df6.format(s2)); if(Math.abs(s1-s2)<0.000001) isConvexQuadrilateral = true; else isConvexQuadrilateral = false; } } class MyTriangle { MyPoint pa, pb, pc; Myline a,b,c; String styleLine; double C,area,p; /*MyTriangle(MyPoint[] p) { pa = p[0]; pb = p[1]; pc = p[2]; a = new Myline(pc, pb); b = new Myline(pa, pc); c = new Myline(pb, pa); C = a.length+b.length+c.length; area = (1.0/4.0) * ( Math.sqrt( ((a.length+b.length+c.length) * (a.length+b.length-c.length) * (a.length+c.length - b.length) * (b.length +c.length-a.length)) )); // barycenter = new MyPoint( (pa.getx()+ pb.getx()+ pc.getx())/3.0 , (pa.gety()+ pb.gety()+ pc.gety())/3.0 ); }*/ public MyTriangle(MyPoint p1, MyPoint p2, MyPoint p3) { pa = p1; pb = p2; pc = p3; a = new Myline(pc, pb); b = new Myline(pa, pc); c = new Myline(pb, pa); C = a.length+b.length+c.length; //area = (1.0/4.0) * ( Math.sqrt( ((a.length+b.length+c.length) * (a.length+b.length-c.length) //* (a.length+c.length - b.length) * (b.length +c.length-a.length)) )); //barycenter = new MyPoint( (pa.getx()+ pb.getx()+ pc.getx())/3.0 , (pa.gety()+ pb.gety()+ pc.gety())/3.0 ); p=(a.length+b.length+c.length)/2; area=Math.sqrt(p*(p-a.length)*(p-b.length)*(p-c.length)); } int jiaodian(Myline line,MyPoint[] point) { int count = 0 ; if (line.equal(a) || line.equal(b)||line.equal(c)) return -1; else if(line.inline(pa)) { point[0] = pa; return 1; } else if(line.inline(pb)) { point[0] = pb; return 1; } else if(line.inline(pc)) { point[0] = pc; return 1; } else { if(line.parallel(a)) { point[0] = line.jiaodian(b); point[1] = line.jiaodian(c); return 2; } else if(line.parallel(b)) { point[0] = line.jiaodian(a); point[1] = line.jiaodian(c); return 2; } else if(line.parallel(c)) { point[0] = line.jiaodian(a); point[0] = line.jiaodian(b); return 2; } else { int m = 0 ; MyPoint p1 = line.jiaodian(a); MyPoint p2 = line.jiaodian(b); MyPoint p3 = line.jiaodian(c); if(line.pointInLine(p1)) { point[m] = p1; m++; } if(line.pointInLine(p2)) { point[m] = p2; m++; } if(line.pointInLine(p3)) { point[m] = p3; m++; } return 2; } } } } class Myline { MyPoint p1 , p2;//构成一条线段的两个点 MyPoint jiaodian; double length;//线段长度 double k;//线的斜率 boolean exiteK;//斜率是否存在 double A,B,C,b;//线一般式的参数 public Myline(MyPoint p1, MyPoint p2) { this.p1 = p1; this.p2 = p2; //判断，计算 斜截式的参数 if(p1.getx()==p2.getx()) exiteK=false; else { exiteK=true; k=(p2.gety()-p1.gety())/(p2.getx()-p1.getx()); b=p1.gety()-k*p1.getx(); } A = p2.gety()-p1.gety(); B = p1.getx()-p2.getx(); C = p2.getx()*p1.gety()-p1.getx()*p2.gety(); length = p1.distance(p2); } public double distanceToPoint(MyPoint p)//点到直线的距离 { if(exiteK==true) return (Math.abs(p.gety()-k*p.getx()-b ) / (Math.sqrt( (1 + k*k) ))); else return (Math.abs(p.getx()-p1.getx())); } double getY(double x) { if(B==0) return 0 ; else if(A==0) return (-1.0*C) / B; else return (-1.0*C-A*x) / B; } public boolean equal(Myline line)//判断两直线重合 { return this.A == line.A && this.B == line.B && this.C == line.C; } public boolean parallel(Myline line)//判断两直线平行 { if(!this.exiteK && !line.exiteK) return true; else if((this.exiteK && !line.exiteK)||(!this.exiteK && line.exiteK)) return false; else { if(this.k==line.k) return true; else return false; } } public boolean chuizhi(Myline line)//判断两直线垂直 { /*if( (this.exiteK==false&&line.k==0)||(line.exiteK==false&&this.k==0)) return true; else if(this.exiteK && line.exiteK) { if(this.k*line.k==-1) return true; else return false; } else return false;*/ if((line.k==0&&this.exiteK==false)||(this.k==0&&line.exiteK==false)) return true; else if(this.exiteK==true&&line.exiteK==true) { if(this.k*line.k==-1) return true; else return false; } else return false; } public boolean inline(MyPoint p )//判断点在线上 { /*if(this.A==0) { if(p.gety()==this.p1.gety()) return true; else return false; } else if(this.B==0) { if(p.getx()==this.p2.getx()) return true; else return false; } else { if(p.gety()==this.getY(p.getx())) return true; else return false; }*/ if(this.B==0) { if(this.p1.getx()==p.getx()) return true; else return false; } else if(this.A==0) { if(this.p1.gety()==p.gety()) { if(this.p1.gety()==p.gety()) return true; else return false; } } else { if(p.gety()==this.getY(p.getx())) return true; else return false; } return false; } public MyPoint jiaodian(Myline line)//求两直线交点 { /*double x=0,y=0; if(this.exiteK&&line.exiteK) { x = (this.B*line.C - line.B*this.C) / (this.A*line.B - line.A*this.B); y = (this.A*line.C - line.A*this.C) / (this.B*line.A - line.B*this.A); } else if(this.exiteK && !line.exiteK) { x = (-1.0*line.C) / line.A; y = this.getY(x); } else if(!this.exiteK && line.exiteK) { x = (-1.0*this.C) / this.A; y = line.getY(x); } MyPoint point = new MyPoint(x,y); return point;*/ double x=0,y=0; if(this.exiteK&&line.exiteK) { if(this.k==line.k) { x=(this.b-line.b)/(line.k-this.k); y=this.k*((this.b-line.b)/(line.k-this.k))+this.b; } } else if(this.exiteK && !line.exiteK) { x=line.p1.getx(); y=this.getY(x); } else if(!this.exiteK && line.exiteK) { x=this.p1.getx(); y=line.getY(x); } jiaodian = new MyPoint(x,y); return jiaodian; } public boolean pointInLine(MyPoint point)//判断是否点在线段上 { /* if(this.inline(point)) { double max , min ; if(this.p1.getx()>=this.p2.getx()) { max = this.p1.getx(); min = this.p2.getx(); } else { max = this.p2.getx(); min = this.p1.getx(); } if(point.getx()>=min && point.getx() <=max) return true; else return false; } else return false;*/ double maxx , minx,maxy,miny ; if(this.p2.getx()>=this.p1.getx()) { maxx=this.p2.getx(); minx=this.p1.getx(); } else { minx=this.p2.getx(); maxx=this.p1.getx(); } if(this.p2.gety()>=this.p1.gety()) { maxy=this.p2.gety(); miny=this.p1.gety(); } else { miny=this.p2.gety(); maxy=this.p1.gety(); } if((point.getx()>=minx&&point.getx()<=maxx)||(point.gety()>=miny&&point.gety()<=maxy)) return true; else return false; } public boolean pointSide(MyPoint point)//判断点是否在线的外面且上面 { /*if(this.exiteK==false) { if(point.getx()>this.p1.getx()) return false; else return true; } else if(this.k==0) { if(point.gety()>this.p1.gety()) return true; else return false; } else { if(point.gety() > this.getY(point.getx())) return true; else return false; }*/ if(this.k==0) { if(point.gety()>this.p1.gety()) return true; else return false; } else if(this.exiteK==false) { if(point.getx()>this.p1.getx()) return false; else return true; } else { if(point.gety() > this.getY(point.getx())) return true; else return false; } } } class MyPoint { private double x,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.x=x; } public MyPoint(double x,double y) { this.x = x; this.y = y; } public MyPoint(String x1,String y1) { x = Double.valueOf(x1); y = Double.valueOf(y1); } public double distance(MyPoint p) { return Math.sqrt(Math.pow((p.x-x),2)+Math.pow((p.y-y),2)); } public boolean equal(MyPoint p) { if(this.x==p.x&&this.y==p.y) return true; else return false; } }
1.设计与分析
圈复杂度：
本道题是有关凸五边形的相关计算，这道题用类去写会比较方便。对于这道题我写了输入类class HeadInput用于判断题目的各种输入情况，四边形类class MyQuadrilateral用于
构造四边形，判断是否为四边形，菱形，矩形，正方形，凸四边形，平行四边形，求周长，面积。三角形类class MyTriangle用于构造三角形，求交点。线类class Myline用于构
造直线，求点到直线的距离，判断两直线重合，判断两直线平行，判断两直线垂直，判断点在线上，求两直线交点，判断是否点在线段上，判断点是否在线的外面且上面。点类
class MyPoint用于构造点，求两点间距离，判断两点是否重合。五边形类class Mypentagon用于构造五边形，判断是否是五边形，判断是否为凸五边形，求周长，求面积。在主
类中，先排除掉不合题意的输入，当 case '4':时，输入十个点坐标，前、后五个点分别构成一个凸多边形（三角形、四边形、五边形），判断它们两个之间是否存在包含关系（
一个多边形有一条或多条边与另一个多边形重合，其他部分都包含在另一个多边形内部，也算包含）。先判断前后五个点构成的是三角形，四边形还是五边形。判断两个图形是
否完全分离：判断两个图形是否完全分离。判断一个图形this是否完全包含另一个图形g：g图形的所有点都位于this图形内部或者边上。判断两个图形是否一模一样(this,g)：首先
len属性要相等，其次g图形的每个点都可以在this图形中对应找到。判断两图形之间的关系：判断优先级：分离，完全重合，包含，被包含，连接，交错。判断连接还是交错，只
需看有没有重叠面积就行。当 case '5':时需要计算公共区域的面积。当 case '6':时，判断点在多边形内部，外部还是某条某条边上。需要利用面积计算分割出来的各个三角形面积
之和与多边形面积是否相等。
判断两个图形的重叠面积：
2.踩坑心得
我觉得这道题比上一道难很多，得分也很不理想。判断是否构成三角形，四边形还是五边形需要用穷举法把每一种可能的情况都列出来。关于这一点，我想了很久，可依然没有把
所有的情况都想出来。导致三个选项都有很多测试点过不了。对于求面积以及判断点与多边形的位置关系，都采用面积去解决。但都有很多测试点过不了。
3.改进建议
因为本道题的得分并不很理想，所以我觉得对于这类题，我的掌握度并不高。下次面对这类题时可以先去上网搜一些质量较高的解决方法，碰到过不了的测试点可以多与同学交流，
集思广义，找到解决的办法。当然最重要的还是提升自己。在碰到困难的时候，不要那么轻易放弃，可以从多方面找找问题。多重复几遍，有时候错误的发生就是某个自己想当然
认为一定是对的的点。总而言之，需要不断加强自己的耐力与毅力。还有就是，在课外的时候，可以多利用网上的资源，去找找一些质量较高的网课，有时候弄明白了一些概念后
有些疑问就迎刃而解了。
四，期中考试
7-1 点与线（类设计）
-
设计一个类表示平面直角坐标系上的点Point，私有属性分别为横坐标x与纵坐标y，数据类型均为实型数，除构造方法以及属性的getter与setter方法外，定义一个用于显示
-
信息的方法display(),用来输出该坐标点的坐标信息，格式如下：
(x,y)，数值保留两位小数。为简化题目，其中，坐标点的取值范围设定为(0,200]。若输入有误，系统则 -
直接输出
Wrong Format -
设计一个类表示平面直角坐标系上的线Line，私有属性除了标识线段两端的点point1、point2外，还有一个字符串类型的color，用于表示该线段的颜色，同样，除构造方法
-
以及属性的getter与setter方法外，定义一个用于计算该线段长度的方法getDistance(),还有一个用于显示信息的方法display(),用来输出线段的相关信息，输出格式如下：
``` The line's color is:颜色值 The line's begin point's Coordinate is: (x1,y1) The line's end point's Coordinate is: (x2,y2) The line's length is:长度值 ```其中，所有数值均保留两位小数，建议可用
String.format("%.2f", data)方法。设计类图如下图所示。
** 题目要求：在主方法中定义一条线段对象，从键盘输入该线段的起点坐标与终点坐标以及颜色，然后调用该线段的display()方法进行输出。**
- 以下情况为无效作业
- 无法运行
- 设计不符合所给类图要求
- 未通过任何测试点测试
- 判定为抄袭
输入格式:
分别输入线段的起点横坐标、纵坐标、终点的横坐标、纵坐标以及颜色，中间可用一个或多个空格、tab或者回车分隔。
输出格式:
The line's color is:颜色值
The line's begin point's Coordinate is:
(x1,y1)
The line's end point's Coordinate is:
(x2,y2)
The line's length is:长度值
输入样例1:
在这里给出一组输入。例如：
5
9.4
12.3
84
Red
输出样例1:
在这里给出相应的输出。例如：
The line's color is:Red
The line's begin point's Coordinate is:
(5.00,9.40)
The line's end point's Coordinate is:
(12.30,84.00)
The line's length is:74.96
输入样例2:
在这里给出一组输入。例如：
80.2356
352.12
24.5
100
Black
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner input=new Scanner(System.in); double x1=input.nextDouble(); double y1=input.nextDouble(); double x2=input.nextDouble(); double y2=input.nextDouble(); if((x1>0&&x1<=200)&&(y1>0&&y1<=200)&&(x2>0&&x2<=200)&&(y2>0&&y2<=200)) { Point p1=new Point( x1, y1); Point p2=new Point( x2, y2); String color=input.next(); //p1.display(); Line l=new Line(p1,p2,color); l.display(); } else System.out.println("Wrong Format"); } } class Point { private double x; private double y; public Point(double x, double y) { // TODO Auto-generated constructor stub this.x=x; this.y=y; } public Point() { } public double getX() { return x; } public void setX() { this.x=x; } public double getY() { return y; } public void setY() { this.y=y; } public void display() { System.out.print("("); System.out.printf("%.2f,%.2f",x,y); System.out.println(")"); } } class Line { private Point point1; private Point point2; private String color; public Line() { } public Line( Point p1, Point p2,String color) { this.point1= p1; this.point2=p2; this.color=color; } public Point Point1() { return point1; } public void setPoint1(Point point1) { this.point1=point1; } public Point Point2() { return point2; } public void setPoint2(Point point2) { this.point2=point2; } public String getColor() { return color; } public void setColor(String color) { this.color=color; } public double getDistance() { double distance=0; distance=Math.sqrt((point1.getY()-point2.getY())*(point1.getY()-point2.getY())+(point1.getX()-point2.getX())*(point1.getX()-point2.getX())); return distance; } public void display() { System.out.println("The line's color is:"+getColor()); System.out.println("The line's begin point's Coordinate is:"); point1.display(); //System.out.println("\n"); System.out.println("The line's end point's Coordinate is:"); point2.display(); //System.out.println("\n"); System.out.printf("The line's length is:"+"%.2f",getDistance()); //System.out.println("\n"); } }
1.设计与分析
圈复杂度：
主要考查的点是继承与封装。根据题目给出来的类图，设计了一个点类，一个线类。在点类里写了点的构造方法，以及public void display()方法用于输出点。注意的是
要保留两位小数，这里我采用的是：System.out.printf("%.2f,%.2f",x,y);在线类有线的构造方法，求线的长度public double getDistance()方法，输出线public void display
()方法。在主类中，先把不符合题意的排除，然后利用public void display()方法输出。因为要体现封装特性，所以每一个属性都要加上private，并有相应的set( ),get( )方
法。
2.踩坑心得：
第一次我把对输入的判断if((x1>0&&x1<=200)&&(y1>0&&y1<=200)&&(x2>0&&x2<=200)&&(y2>0&&y2<=200))放在了线类，代码会出错。然后我就把它移到了主类。但
仍然有些测试点没有过，运行测试过后发现是有些空格的问题。改一下空格就可以了。
3.改进建议
做题的时候可以再细心一点，也许就可以一遍过了。
7-2点线面问题重构（继承与多态）
在“点与线（类设计）”题目基础上，对题目的类设计进行重构，以实现继承与多态的技术性需求。
- 对题目中的点Point类和线Line类进行进一步抽象，定义一个两个类的共同父类Element（抽象类），将display()方法在该方法中进行声明（抽象方法），将Point类
- 和Line类作为该类的子类。
- 再定义一个Element类的子类面Plane，该类只有一个私有属性颜色color，除了构造方法和属性的getter、setter方法外，display()方法用于输出面的颜色，输出格式
- 如下：
The Plane's color is:颜色 - 在主方法内，定义两个Point（线段的起点和终点）对象、一个Line对象和一个Plane对象，依次从键盘输入两个Point对象的起点、终点坐标和颜色值（Line对象和
- Plane对象颜色相同），然后定义一个Element类的引用，分别使用该引用调用以上四个对象的display()方法，从而实现多态特性。示例代码如下：
element = p1;//起点Point element.display(); element = p2;//终点Point element.display(); element = line;//线段 element.display(); element = plane;//面 element.display();类结构如下图所示。
其中，所有数值均保留两位小数，建议可用String.format("%.2f", data)方法。
- 以下情况为无效作业
- 无法运行
- 设计不符合所给类图要求
- 未通过任何测试点测试
- 判定为抄袭
输入格式:
分别输入线段的起点横坐标、纵坐标、终点的横坐标、纵坐标以及颜色，中间可用一个或多个空格、tab或者回车分隔。
输出格式:
(x1,y1)
(x2,y2)
The line's color is:颜色值
The line's begin point's Coordinate is:
(x1,y1)
The line's end point's Coordinate is:
(x2,y2)
The line's length is:长度值
The Plane's color is:颜色值
输入样例1:
在这里给出一组输入。例如：
5
9.4
12.3
84
Red
输出样例1:
在这里给出相应的输出。例如：
(5.00,9.40)
(12.30,84.00)
The line's color is:Red
The line's begin point's Coordinate is:
(5.00,9.40)
The line's end point's Coordinate is:
(12.30,84.00)
The line's length is:74.96
The Plane's color is:Red
输入样例2:
在这里给出一组输入。例如：
5
9.4
12.3
845
Black
输出样例2:
在这里给出相应的输出。例如：
Wrong Formatimport java.util.Scanner; public class Main { public static void main(String args[]) { Scanner input=new Scanner(System.in); double x1=input.nextDouble(); double y1=input.nextDouble(); double x2=input.nextDouble(); double y2=input.nextDouble(); if((x1>0&&x1<=200)&&(y1>0&&y1<=200)&&(x2>0&&x2<=200)&&(y2>0&&y2<=200)) { Element p1=new Point( x1, y1); Element p2=new Point( x2, y2); String color=input.next(); p1.display(); p2.display(); Element l=new Line((Point)p1,(Point)p2,color); l.display(); Element plane=new Plane(color); //color=input.next(); plane.display(); } else System.out.println("Wrong Format"); } } class Point extends Element { private double x; private double y; public Point(double x, double y) { // TODO Auto-generated constructor stub this.x=x; this.y=y; } public Point() { } public double getX() { return x; } public void setX() { this.x=x; } public double getY() { return y; } public void setY() { this.y=y; } public void display() { System.out.print("("); System.out.printf("%.2f,%.2f",x,y); System.out.println(")"); } } class Line extends Element{ private Point point1; private Point point2; private String color; public Line() { } public Line( Point p1, Point p2,String color) { this.point1= p1; this.point2=p2; this.color=color; } public Point Point1() { return point1; } public void setPoint1(Point point1) { this.point1=point1; } public Point Point2() { return point2; } public void setPoint2(Point point2) { this.point2=point2; } public String getColor() { return color; } public void setColor(String color) { this.color=color; } public double getDistance() { double distance=0; distance=Math.sqrt((point1.getY()-point2.getY())*(point1.getY()-point2.getY())+(point1.getX()-point2.getX())*(point1.getX()-point2.getX())); return distance; } public void display() { System.out.println("The line's color is:"+getColor()); System.out.println("The line's begin point's Coordinate is:"); point1.display(); //System.out.println("\n"); System.out.println("The line's end point's Coordinate is:"); point2.display(); //System.out.println("\n"); System.out.printf("The line's length is:"+"%.2f",getDistance()); System.out.println(""); } } abstract class Element{ public abstract void display(); } 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; } @Override public void display() { // TODO Auto-generated method stub System.out.print("The Plane's color is:"+getColor()); } }
1.设计与分析
圈复杂度：
主要考查的点是继承与多态。需要做的是在第一题的基础上加上父类Element类以及另外一个子类Plane类。父类中只需要有public abstract void display();
方法。class Plane继承父类，只需方法public abstract void display()来输出它的颜色。在主类中，需要用Element p1=new Point( x1, y1);Element l=new Line
((Point)p1,(Point)p2,color)等体现多态性质。
2.踩坑心得
在一开始写的是Element l=new Line(p1,p2,color)，但是它总是报错，后来想了很久才想到这里要强制类型转化。
3改进建议
对多态的相关知识点掌握得不是很全面，导致有些错误需要想很久才可以改出来。可以在课后多加强这方面的学习，如听相关的网课，去图书馆查找相关的书籍。
7-3点线面问题再重构（容器类）
在“点与线（继承与多态）”题目基础上，对题目的类设计进行重构，增加容器类保存点、线、面对象，并对该容器进行相应增、删、遍历操作。
- 在原有类设计的基础上，增加一个GeometryObject容器类，其属性为
ArrayList<Element>类型的对象（若不了解泛型，可以不使用<Element>） - 增加该类的
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()方法进行输出。
类图如下所示：
- 以下情况为无效作业
- 无法运行
- 设计不符合所给类图要求
- 未通过任何测试点测试
- 判定为抄袭
输入格式:
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
我的代码：
//import java.util.ArrayList; import java.util.ArrayList; import java.util.Scanner; //import qizhongkaoshi.Element; //import qizhongkaoshi.GeometryObject; //import qizhongkaoshi.Line; //import qizhongkaoshi.Plane; //import qizhongkaoshi.Point; //import qizhongkaoshi.Element; /*public class Main { public static void main(String args[]) { Scanner input=new Scanner(System.in); double x1=input.nextDouble(); double y1=input.nextDouble(); double x2=input.nextDouble(); double y2=input.nextDouble(); if((x1>0&&x1<=200)&&(y1>0&&y1<=200)&&(x2>0&&x2<=200)&&(y2>0&&y2<=200)) { Element p1=new Point( x1, y1); Element p2=new Point( x2, y2); String color=input.next(); //p1.display(); Element l=new Line((Point)p1,(Point)p2,color); l.display(); Element plane=new Plane(color); color=input.next(); plane.display(); } else System.out.println("Wrong Format"); } }*/ public class Main { public static void main(String[] args) { Scanner input=new Scanner(System.in); int choice; choice = input.nextInt(); while(choice != 0) { switch(choice) { case 1: double x1=input.nextDouble(); double y1=input.nextDouble(); Point p=new Point(x1,y1); GeometryObject.add(p); break; case 2: double x3=input.nextDouble(); double y3=input.nextDouble(); double x2=input.nextDouble(); double y2=input.nextDouble(); String color=input.next(); Point p1=new Point(x3,y3); Point p2=new Point(x2,y2); Line l=new Line(p1,p2,color); GeometryObject.add(l); break; case 3: String color1=input.next(); Plane s=new Plane(color1); GeometryObject.add(s); break; case 4: int index = input.nextInt(); GeometryObject.remove(index); break; } choice = input.nextInt(); } for(int i=0;i<GeometryObject.list.size();i++) { GeometryObject.list.get(i).display(); } } } class Point extends Element { private double x; private double y; public Point(double x, double y) { // TODO Auto-generated constructor stub this.x=x; this.y=y; } public Point() { } public double getX() { return x; } public void setX() { this.x=x; } public double getY() { return y; } public void setY() { this.y=y; } public void display() { System.out.print("("); System.out.printf("%.2f,%.2f",x,y); System.out.println(")"); } } class Line extends Element{ private Point point1; private Point point2; private String color; public Line() { } public Line( Point p1, Point p2,String color) { this.point1= p1; this.point2=p2; this.color=color; } public Point Point1() { return point1; } public void setPoint1(Point point1) { this.point1=point1; } public Point Point2() { return point2; } public void setPoint2(Point point2) { this.point2=point2; } public String getColor() { return color; } public void setColor(String color) { this.color=color; } public double getDistance() { double distance=0; distance=Math.sqrt((point1.getY()-point2.getY())*(point1.getY()-point2.getY())+(point1.getX()-point2.getX())*(point1.getX()-point2.getX())); return distance; } public void display() { System.out.println("The line's color is:"+getColor()); System.out.println("The line's begin point's Coordinate is:"); point1.display(); //System.out.println("\n"); System.out.println("The line's end point's Coordinate is:"); point2.display(); //System.out.println("\n"); System.out.printf("The line's length is:"+"%.2f",getDistance()); System.out.println(""); //System.out.println("\n"); } } abstract class Element{ public abstract void display(); } 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; } @Override public void display() { // TODO Auto-generated method stub System.out.println("The Plane's color is:"+getColor()); } } class GeometryObject { static ArrayList<Element> list=new ArrayList<>(); GeometryObject() { } public static void add(Element element) { list.add(element); } public static void remove(int index) { if((index - 1)<list.size()) list.remove(index-1); else //System.out.println("wrong"); return; } public ArrayList<Element> getlist() { return list; } }
1.设计与分析
圈复杂度：
本题的相关考点是容器，需要在第二题的基础上增加容器类class GeometryObject，主类用switch对每个选项进行操作。
2.踩坑心得
在remove( )方法中需对index-1进行合法性判断，不然会报错。
3.改进建议
如上图可知本题的复杂度有40几，应该想办法减少复杂度。同时对容器的相关知识点还需要进一步了解。可以通过多听听网课，查阅相关的书籍。
五，总结
通过这几周的学习，我的编程能力有了一定的提高，但不足之处也有很多。就PTA大作业而言，第四次，第五次大作业的分数都不是很满意。就上课而言，有时候并
不能完全理解老师所讲述的内容。所以，我希望在接下来的学习中，我希望我可以在认真听好老师所讲的每一堂课之余，在课外自己找一下质量较高的网课，去彻底
弄懂一些概念。因为很多时候，往往会容易出现bug都是因为对某些概念理解不清楚。对以后的PTA大作业我希望我可以尽量拿一个自己满意的分数。还有就是，我觉
得要将java学好，需要坚持与毅力，也许某个测试点过不了就是因为一个小小的问题，这时候就需要我们反反复复的去寻找错误所在。
浙公网安备 33010602011771号