BZOJ 4570: [Scoi2016]妖怪

二次联通门 : BZOJ 4570: [Scoi2016]妖怪

二次联通门 : luogu P3291 [SCOI2016]妖怪

LibreOJ : LibreOJ  #2015. 「SCOI2016」妖怪

/*
    BZOJ 4570: [Scoi2016]妖怪

    凸包

    我果然还是naive
    看见这题就想二分
    结果惨挂

    做了凸包后就想三分
    又挂了。。 

    完美落入了每个坑。。果然还是自己太菜

    对于每个妖怪，其在(a,b)时的最大战力为过当前点斜率为(-b/a)的直线的截距之和
    最大的战力就是最外面的那条直线

    对n个点做一个上凸包
    最大值一定在凸包的右上部分(自行脑补)

    那么这些点的斜率都有着一个范围ki-1<ki<ki+1

    那么战力就变为了一个双钩函数
    讨论求最值即可
*/
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <cmath>

void read (long long &now)
{
    register char word = getchar ();
    int temp = ;
    for (now = ; !isdigit (word); word = getchar ())
        if (word == '-')
            temp = ;
    for (; isdigit (word); now = now *  + word - '', word = getchar ());
    if (temp)
        now = -now;
}

#define INF 1e9

struct Point
{
    long long x, y;

    Point (long long __x, long long __y) : x (__x), y (__y) {}
    Point () {}

    bool operator < (const Point &now) const
    {
        return this->x == now.x ? this->y < now.y : this->x < now.x;
    }

    Point operator - (const Point &now) const
    {
        return Point (this->x - now.x, this->y - now.y);
    }
};

inline long long Cross (const Point &A, const Point &B)
{
    return A.x * B.y - A.y * B.x;
}

#define Max 1000250

inline double Calculate (const Point &now, const double &k)
{
    return k >=  ? INF : (double) now.x + now.y + - k * now.x - now.y / k;
}

inline double Get_point_k (const Point &now)
{
    return -sqrt ((double) now.y / now.x);
}

inline double Get_line_k (const Point &A, const Point &B)
{
    return (A.x ^ B.x) ? ((double)(A.y - B.y) / (double) (A.x - B.x)) : INF;
}

int Get_convex_Hull (Point *point, int N, Point *Stack)
{
    std :: sort (point + , point + N + );

    register int top = ;
    for (int i = ; i <= N; ++ i)
    {
        for (; top >  && Cross (Stack[top] - Stack[top - ], point[i] - Stack[top - ]) >= ; -- top);
        Stack[++ top] = point[i];
    }
    return top;
}

Point yukari[Max], Stack[Max];

int main (int argc, char *argv[])
{
    register int i;
    int N;
    scanf ("%d", &N);
    for (i = ; i <= N; ++ i)
        read (yukari[i].x), read (yukari[i].y);

    int M = Get_convex_Hull (yukari, N, Stack);

    if (M < )
    {
        printf ("%.4lf", Calculate (Stack[], Get_point_k (Stack[])));
        return ;
    }
    double k, _k, __k, Answer = INF;

    k = Get_point_k (Stack[]);
    __k = Get_line_k (Stack[], Stack[]);

    if (k >= __k)
        Answer = std :: min (Answer, Calculate (Stack[], k));

    k = Get_point_k (Stack[M]);
    _k = Get_line_k (Stack[M - ], Stack[M]);

    if (k <= _k)
        Answer = std :: min (Answer, Calculate (Stack[M], k));
    Answer = std :: min (Answer, Calculate (Stack[M], _k));

    for (i = ; i < M; ++ i)
    {
        _k = Get_line_k (Stack[i - ], Stack[i]);
        __k = Get_line_k (Stack[i], Stack[i + ]);

        k = Get_point_k (Stack[i]);

        Answer = std :: min (Answer, Calculate (Stack[i], _k));
        if (k <= _k && k >= __k)
            Answer = std :: min (Answer, Calculate (Stack[i], k));
    }
    printf ("%.4lf", Answer);
    return ;
}