hdu 1392凸包周长
//用的自己的计算几何模板，不过比较慢嘿嘿
//要注意只有一个点和两个点
//Computational Geometry
//by kevin_samuel(fenice) Soochow University
//temple
#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstdio>
//#include <stack>
using namespace std;
//define
const double EPS = 1e-8;
const double PI = acos(-1.0);
//point
//====================================================================
class Point
{
public:
double x;
double y;
Point(){}
Point(double x,double y):x(x),y(y){}
//operator
//operator=
Point& operator=(const Point& _P)
{
x = _P.x;
y = _P.y;
return *this;
}
//operator*
double operator*(const Point& _P)const
{
return x*_P.y - y *_P.x;
}
//operator-
Point operator-(const Point& _P)const
{
return Point(x - _P.x,y - _P.y);
}
//operator==
bool operator==(const Point& _P)const
{
if(fabs(_P.x - x) < EPS && fabs(_P.y - y) < EPS)
return true;
else
return false;
}
bool operator!=(const Point& _P)const
{
return ((*this) == _P) == false;
}
//dot product
static double dotProduct(Point s1,Point e1,Point s2,Point e2)
{
double result = 0;
double x1 = e1.x - s1.x;
double y1 = e1.y - s1.y;
double x2 = e2.x - s2.x;
double y2 = e2.y - s2.y;
result = x1*x2 + y1*y2;
return result;
}
//cross product 1 (4 point-type params)
static double crossProduct(Point s1,Point e1,Point s2,Point e2)
{
double result = 0;
double x1 = e1.x - s1.x;
double y1 = e1.y - s1.y;
double x2 = e2.x - s2.x;
double y2 = e2.y - s2.y;
result = x1*y2 - x2*y1;
return result;
}
//cross product 2 (3 point-type params)
static double crossProduct(Point p1,Point p2,Point p0)
{
return crossProduct(p0,p1,p0,p2);
}
//Is on segment or line
static bool onSegment(Point Pi,Point Pj,Point Q)
{
if(Q.x >= min(Pi.x,Pj.x) && Q.x <= max(Pi.x,Pj.x) &&
Q.y >= min(Pi.y,Pj.y) && Q.y <= max(Pi.y,Pj.y) &&
fabs(crossProduct(Q,Pj,Pi)) < EPS
)
return true;
else
return false;
}
//Is on segment
bool IsOnSegment(Point Pi,Point Pj)
{
if(this->x >= min(Pi.x,Pj.x) && this->x <= max(Pi.x,Pj.x) &&
this->y >= min(Pi.y,Pj.y) && this->y <= max(Pi.y,Pj.y) &&
fabs(Point::crossProduct(*this,Pj,Pi)) < EPS
)
return true;
else
return false;
}
//Is inside triangle
bool inTriangle(Point A,Point B,Point C)
{
double Sabc = fabs(Point::crossProduct(B,C,A));
double Spab = fabs(Point::crossProduct(A,B,(*this)));
double Spac = fabs(Point::crossProduct(A,C,(*this)));
double Spbc = fabs(Point::crossProduct(B,C,(*this)));
if(Spbc + Spab + Spac == Sabc)
return true;
else
return false;
}
//Is inside polygon
//polys[] ,0-n
bool insidePolygon(Point *polys,int n)
{
int counter = 0;
double xinters;
Point p1,p2;
p1 = polys[0];
for(int i = 1; i < n; i++)
{
p2 = polys[i % n];
if(Point::onSegment(p1,p2,(*this)) == true)
return true;
if((*this).y > min(p1.y,p2.y) && (*this).y <= max(p1.y,p2.y))
{
if((*this).x <= max(p1.x,p2.x) && p1.y != p2.y)
{
xinters = ((*this).y - p1.y)*(p2.x - p1.x)/(p2.y - p1.y) + p1.x;
if(p1.x == p2.x || (*this).x <= xinters)
counter++;
}
}
p1 = p2;
}
if(counter % 2 == 0)
return false;
return true;
}
//distance^2
double dis2(const Point& _P)const
{
return (x - _P.x)*(x - _P.x) + (y - _P.y)*(y - _P.y);
}
//distance
double dis(const Point& _P)const
{
return sqrt(dis2(_P));
}
static double dis(const Point& p1,const Point& p2)
{
return sqrt((p2.x - p1.x)*(p2.x - p1.x) + (p2.y - p1.y)*(p2.y -p1.y));
}
};
//==================================================================================
//vector segment or line
//==================================================================================
class Vector
{
public:
Point start;
Point end;
double _x;
double _y;
double a,b,c; //ax + by + c = 0
Vector(){}
Vector(double __x,double __y):_x(__x),_y(__y){}
Vector(Point a,Point b):start(a),end(b) { _x = end.x - start.x; _y = end.y - start.y; }
//operator
//judge the position of the point relative to the segment
double operator*(const Point& _P)const
{
double res = Point::crossProduct(_P,this->end,this->start);
if(fabs(res) < EPS)
return 0;
if(res > 0)
return 1;
else
return -1;
}
//crossProduct
double operator*(const Vector& _V)const
{
Point st = _V.start;
Point en = _V.end;
return Point::crossProduct(start,end,st,en);
}
//transfer to normal rex
bool pton()
{
a = start.y - end.y;
b = end.x - start.x;
c = start.x * end.y - start.y * end.x;
return true;
}
//judge whether _P is on the line
bool IsLinehasPoint(const Point& _P)const
{
if(fabs((*this)*_P) < EPS)
return true;
else
return false;
}
//juegde whether _P is on the segment
bool IsSegmenthasPoint(const Point& _P)const
{
if(_P.x >= min(this->start.x,this->end.x) && _P.x <= max(this->start.x,this->end.x) &&
_P.y >= min(this->start.y,this->end.y) && _P.y <= max(this->start.y,this->end.y) &&
fabs((*this)*_P) < EPS
)
return true;
else
return false;
}
//the distance from point to line
double disToPoint(const Point& _P)
{
pton(); //transfer
double td = (a*_P.x + b*_P.y + c)/sqrt(a*a + b*b);
double xp = (b*b*_P.x - a*b*_P.y -a*c)/(a*a + b*b);
double yp = (-a*b*_P.x + a*a*_P.y - b*c)/(a*a + b*b);
double xb = max(start.x,end.x);
double yb = max(start.y,end.y);
double xs = start.x + end.x - xb;
double ys = start.y + end.y - yb;
if(xp > xb + EPS||xp < xs - EPS||yp > yb + EPS||yp < ys - EPS)
td = min(_P.dis(start),_P.dis(end));
return fabs(td);
}
//out the mirror point by this line or segment
Point mirrorPoint(const Point& _P)const
{
Point ret;
double d = a * a + b * b;
ret.x = (b*b*_P.x - a*a*_P.x - 2*a*b*_P.y - 2*a*c)/d;
ret.y = (a*a*_P.y - b*b*_P.y - 2*a*b*_P.x - 2*b*c)/d;
return ret;
}
//out the vertical line of two points
static Vector verticalLine(const Point& _a,const Point& _b)
{
Vector ret;
ret.start.x = (_a.x + _b.x)/2;
ret.start.y = (_a.y + _b.y)/2;
ret.a = _b.x - _a.x;
ret.b = _b.y - _a.y;
ret.c = (_a.y - _b.y)*ret.start.y + (_a.x - _b.x)*ret.start.x;
if(fabs(ret.a) > EPS)
{
ret.end.y = 0.0;
ret.end.x = -ret.c/ret.a;
if(ret.end == ret.start)
{
ret.end.y = 1e10;
ret.end.x = -(ret.c - ret.b * ret.end.y)/ret.a;
}
}
else
{
ret.end.x = 0.0;
ret.end.y = - ret.c/ret.b;
if(ret.end == ret.start)
{
ret.end.x = 1e10;
ret.end.y = - (ret.c - ret.a*ret.end.x)/ret.b;
}
}
return ret;
}
//line with line
//two lines coincide
bool equal(const Vector& _P)const
{
return IsLinehasPoint(_P.start) && IsLinehasPoint(_P.end);
}
// two parallel lines
bool parallel(const Vector& _P)const
{
return (fabs((*this)*_P)) < EPS;
}
//the intersection points of two lines
Point Intersection(Vector _V)
{
//judge parallel and coincide
Point ret = start;
double t = ((start.x - _V.start.x)*(_V.start.y - _V.end.y) - (start.y - _V.start.y)*(_V.start.x - _V.end.x))/
((start.x - end.x)*(_V.start.y - _V.end.y) - (start.y - end.y)*(_V.start.x - _V.end.x));
ret.x += (end.x - start.x)*t;
ret.y += (end.y - start.y)*t;
return ret;
}
//line and segment
//is line cross with segment
//param:segment
bool crossSL(const Vector& _V)const
{
double rs = (*this)*_V.start;
double re = (*this)*_V.end;
return rs*re < EPS;
}
//segment and segment
//judge wheather two segments intersect
bool IsCrossSS(const Vector& _V)const
{
return (
max(start.x,end.x) >= min(_V.start.x,_V.end.x) &&
max(_V.start.x,_V.end.x) >= min(start.x,end.x) &&
max(start.y,end.y) >= min(_V.start.y,_V.end.y) &&
max(_V.start.y,_V.end.y) >= min(start.y,end.y) &&
((Vector(_V.start,start)*_V)*(_V*Vector(_V.start,end)) >= EPS) &&
((Vector(start,_V.start)*(*this))*((*this)*Vector(start,_V.start))>=EPS)
);
}
};
//=================================================================================
//Graham-scan
#define MAXN 110
Point Points[MAXN];
int N;
int stack[MAXN];
int top;
bool cmp(const Point& a,const Point& b)
{
if(a.y == b.y)
return a.x < b.x;
else
return a.y < b.y;
}
bool multi(Point sp,Point ep,Point op)
{
return (sp.x - op.x)*(ep.y - op.y) >= (ep.x - op.x)*(sp.y - op.y);
}
void Graham_Scan()
{
int len;
top = 1;
sort(Points,Points+N,cmp);
if(N == 0)
return;
stack[0] = 0;
if(N == 1)
return;
stack[1] = 1;
if(N == 2)
return;
stack[2] = 2;
for(int i = 2; i < N; i++)
{
while(top && multi(Points[i],Points[stack[top]],Points[stack[top-1]])) top--;
stack[++top] = i;
}
len = top;
stack[++top] = N - 2;
for(int i = N - 3; i >= 0; i--)
{
while(top != len && multi(Points[i],Points[stack[top]],Points[stack[top-1]])) top--;
stack[++top] = i;
}
}
//==================================================================================
//test zone
int main()
{
while(cin>>N)
{
if(N == 0)
break;
for(int i = 0; i < N; i++)
{
cin>>Points[i].x>>Points[i].y;
}
Graham_Scan();
double length = 0;
for(int i = 0; i <= top - 2; i++)
{
length +=Point::dis(Points[stack[i]],Points[stack[i+1]]);
}
length +=Point::dis(Points[stack[top - 1]],Points[stack[0]]);
if(N == 1)
printf("0.00\n");
else if(N == 2)
printf("%.2lf\n",Point::dis(Points[0],Points[1]));
else
printf("%.2lf\n",length);
}
return 0;
}