第二次博客总结
一 ，前言
第四次大作业题量不多，只有三道题。第一题为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，则按向量叉乘的方法计算出各个三角形的面积再求和即多边形的面
积。但就是不知道为啥很多测试点过不了（
标签：总结,p2,p1,System,博客,else,第二次,size,out From： https://www.cnblogs.com/SiSi-A/p/16836064.html