计算几何基础

记录点滴。

/*
2015.6    HT
ACM Work_8

*/

#include <iostream>
#include <cstdio>
using namespace std;

/*
线段判交--ACM

1.快速排斥实验
设以线段P1P2和线段Q1Q2为对角线的矩形为M,N;若M,N 不相交，则两个线段显然不相交；
2.跨立实验
如果两线段相交，则两线段必然相互跨立对方。若P1P2跨立Q1Q2，则矢量(P1-Q1)和(P2-Q1)位于矢量(Q2-Q1)的两侧，
即(P1-Q1)×(Q2-Q1)*(P2-Q1)×(Q2-Q1)<0,上式可改写成(P1-Q1)×(Q2-Q1)*(Q2-Q1)×(P2-Q1)>0。
当(P1-Q1)×(Q2-Q1)=0时，说明(P1-Q1)和(Q2-Q1)共线，但是因为已经通过快速排斥试验，所以P1一定在线段Q1Q2上；
同理，(Q2-Q1)×(P2-Q1)=0说明P2一定在线段Q1Q2上。
所以判断P1P2跨立Q1Q2的依据是：(P1-Q1)×(Q2-Q1)*(Q2-Q1)×(P2-Q1)>=0。

*/

/*
You can Solve a Geometry Problem too
判断两条线段是否相交

向量 p1*p2 = x1y2 – y1x2 = -p2*p1
*/
//struct Line
//{
//    double x1, y1, x2, y2;
//}lines[110];
//
//bool isCross(Line a, Line b)
//{
//    if (((a.x1 - b.x1)*(a.y2 - b.y1) - (a.x2 - b.x1)*(a.y1 - b.y1)) * ((a.x1 - b.x2)*(a.y2 - b.y2) 
//        - (a.x2 - b.x2)*(a.y1 - b.y2))>0)
//        return false;
//    if (((b.x1 - a.x1)*(b.y2 - a.y1) - (b.x2 - a.x1)*(b.y1 - a.y1)) * ((b.x1 - a.x2)*(b.y2 - a.y2) 
//        - (b.x2 - a.x2)*(b.y1 - a.y2))>0)
//        return false;
//    return true;
//}
//
//int main()
//{
//    int n;
//    while (cin >> n && n)
//    {
//        int i;
//        for (i = 0; i < n; ++i)
//        {
//            cin >> lines[i].x1 >> lines[i].y1 >> lines[i].x2 >> lines[i].y2;
//        }
//        int j;
//        int ans = 0;
//        for (i = 0; i < n; ++i)
//        {
//            for (j = i + 1; j < n; ++j)
//            {
//                if (isCross(lines[i], lines[j]) == true)
//                {
//                    ans++;
//                }
//            }
//        }
//        cout << ans << endl;
//    }
//    return 0;
//}



/*
改革春风吹满地

求多边形面积
s = 1/2 * (求和i=0~(n-1)) { Xi*Y(i+1) - X(i+1)*Yi }
逆时针给出点坐标，值为正
顺时针给出点坐标，值为负
*/
//int main()
//{
//    int n;
//    int a[100], b[100], i;
//    double s;
//    while (cin >> n && n)
//    {
//        s = 0;
//        for (i = 0; i < n; i++)
//            cin >> a[i] >> b[i];
//        a[n] = a[0];
//        b[n] = b[0];
//        for (i = 0; i<n; i++)
//            s += (a[i] * b[i + 1] - a[i + 1] * b[i]);
//        printf_s("%.1lf\n", s / 2);
//    }
//    return 0;
//}



/*
Shape of HDU

判断该多边形是凸多边形还是凹多边形
*/
//struct point
//{
//    int x, y;
//};
//
///*
//两个向量 a-> (p1.x-p0.x, p1.y-p0.y)  和 b->(p2.x-p1.x, p2.y-p1.y)
//两个向量叉积 （a.x*b.y - a.y*b.x）
//叉积结果 >0 ,则向量 a 在向量 b的顺时针方向； <0则相反； 等于0则在同一直线
//*/
//double cross(point p0, point p1, point p2)
//{
//    return (p1.x - p0.x)*(p2.y - p1.y) - (p1.y - p0.y)*(p2.x - p1.x);
//}
//
//int main()
//{
//    int n;
//    point p[1010];
//    while (scanf_s("%d", &n) && n)
//    {
//        int i, flag = 0;
//        for (i = 0; i<n; i++)
//        {  
//            scanf_s("%d%d", &p[i].x, &p[i].y);
//        }
//        p[n] = p[0];
//        p[n + 1] = p[1]; // 增加两个点代表最开始的两个点，以形成循环 
//        for (i = 2; i <= n + 1; i++)
//        {
//            if (cross(p[i - 2], p[i - 1], p[i])<0) 
//                flag = 1;
//        }
//        if (!flag)
//            printf_s("convex\n");
//        else 
//            printf_s("concave\n");
//    }
//    return 0;
//}



/*
Surround the Trees

*/
#define MAXD 110

typedef struct
{
    double x, y;
}point;
point Tree[MAXD], Result[MAXD];
int N, P;

/*
叉乘
P1 x P2
>0 : P1 is clockwise from P2 with respect to (0,0)
<0 : counterclockwise (即P1在P2左边)
=0 : collinear
*/
double cross(double x1, double y1, double x2, double y2)
{
    return x1 * y2 - x2 * y1;
}

// 按 y坐标从低到高排序，若 y相等则按 x坐标排序
int cmp(const void *_p, const void *_q)
{
    point *p = (point *)_p, *q = (point *)_q;
    if (p->y == q->y)
        return p->x < q->x ? -1 : 1;

    return p->y < q->y ? -1 : 1;
}

double Distance(double x, double y, double x1, double y1)
{
    double temp1 = (x - x1)*(x - x1);
    double temp2 = (y - y1)*(y - y1);
    return sqrt(temp1 + temp2);
}

double sqr(double x)
{
    return x * x;
}

// 是否删除
int del(int top, int i)
{
    if (cross(Result[top].x - Result[top - 1].x, Result[top].y - Result[top - 1].y,
        Tree[i].x - Result[top].x, Tree[i].y - Result[top].y) < 0)
        return 1;
    return 0;
}

int graham()
{
    int i, mint, top = 1;
    Result[0] = Tree[0];
    Result[1] = Tree[1];
    for (i = 2; i < N; i++)
    {
        while (top && del(top, i))
            --top;
        Result[++top] = Tree[i];
    }
    mint = top;
    Result[++top] = Tree[N - 2];
    for (i = N - 3; i >= 0; i--)
    {
        while (top != mint && del(top, i))
            --top;
        Result[++top] = Tree[i];
    }
    return top;
}

int main()
{
    int i;
    double sum;
    while (1)
    {
        cin >> N;
        if (!N)
            break;

        for (i = 0; i < N; i++)
            cin >> Tree[i].x >> Tree[i].y;

        // 快排
        qsort(Tree, N, sizeof(Tree[0]), cmp);
        sum = 0;

        if (N == 1)
            printf_s("0.00\n");
        else if (N == 2)
        {
            sum = Distance(Tree[0].x, Tree[0].y, Tree[1].x, Tree[1].y);
            printf_s("%.2f\n", sum);
        }
        else
        {
            P = graham();
            for (i = 0; i < P; i++)
                sum += Distance(Result[i].x, Result[i].y, Result[i + 1].x, Result[i + 1].y);
            printf_s("%.2f\n",sum);
        }
    }
    return 0;
}