HDU

题意：有一排建筑，每座建筑有一定的高度，宽度可以忽略，求在某点的平地上能看到天空的最大角度。

网上的做法基本都是离线的...其实这道题是可以在线做的。

对于向右能看到的最大角度，从右往左倍增维护每个时刻的单调栈（凸壳），对于每个询问，先二分找到它右面的第一个建筑的位置，然后在对应的凸壳上倍增找到切点即可。

向左看把x坐标对称一下就行。

复杂度$O(nlogn)$

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
const db pi=acos(-1);
const int N=1e5+10,inf=0x3f3f3f3f;
int n,m,ka;
struct P {
    db x,y;
    P operator-(const P& b) {return {x-b.x,y-b.y};}
    db rad() {return atan2(y,x);}
    bool operator<(const P& b)const {return x<b.x;}
} a[N];
struct D {
    P p,v;
    bool operator<(const D& b)const {return p<b.p;}
};
db cross(const P& a,const P& b) {return a.x*b.y-a.y*b.x;}
struct Solver {
    int F[N][20];
    D b[N];
    void build(P* a) {
        b[n]= {a[n],{0,-1}};
        for(int i=1; i<n; ++i)b[i]= {a[i],a[i+1]-a[i]};
        for(int k=19; k>=0; --k)F[n][k]=n;
        for(int i=n-1; i>=1; --i) {
            int j=i+1;
            if(cross(b[j].p-a[i],b[j].v)>0) {
                for(int k=19; k>=0; --k)
                    if(cross(b[F[j][k]].p-a[i],b[F[j][k]].v)>0)j=F[j][k];
                j=F[j][0];
            }
            F[i][0]=j;
            b[i].v=a[j]-a[i];
            for(int k=1; k<20; ++k)F[i][k]=F[F[i][k-1]][k-1];
        }
    }
    db qry(P px) {
        int i=lower_bound(b+1,b+1+n,(D) {px, {0,0}})-b;
        if(cross(b[i].p-px,b[i].v)>0) {
            for(int k=19; k>=0; --k)
                if(cross(b[F[i][k]].p-px,b[F[i][k]].v)>0)i=F[i][k];
            i=F[i][0];
        }
        return (b[i].p-px).rad()*180/pi;
    }
} solver[2];
int main() {
    int T;
    for(scanf("%d",&T); T--;) {
        printf("Case #%d:
",++ka);
        scanf("%d",&n);
        for(int i=1; i<=n; ++i)scanf("%lf%lf",&a[i].x,&a[i].y);
        a[++n]= {~inf,0},a[++n]= {inf,0};
        sort(a+1,a+1+n);
        solver[0].build(a);
        for(int i=1; i<=n; ++i)a[i]= {-a[i].x,a[i].y};
        reverse(a+1,a+1+n);
        solver[1].build(a);
        for(scanf("%d",&m); m--;) {
            db x;
            scanf("%lf",&x);
            printf("%.10f
",180-(solver[0].qry({x,0})+solver[1].qry({-x,0})));
        }
    }
    return 0;
}