HDU5033 Building(单调栈)

题意是说在水平轴上有很多建筑物（没有宽度），知道每个建筑物的位置与高度。有m个查询，每次查询位置x所能看到的天空的角度。

方法是将建筑与查询一起排序，从左往右计算一遍，如果是建筑物，则比较最后两个（当前的与队尾的）斜率与队尾两个的斜率比较，如果较小则入队，否则一直出队尾元素直至满足条件（因为斜率为负数，斜率较小说明越堵）。

如果是查询，同样的比较这个位置与队尾的斜率同队尾两个元素的斜率比较，直至满足小于的关系结束，这时计算垂直方向左侧的夹角

最后从右往左计算右边，求和便是答案

#pragma comment(linker, "/STACK:1677721600")
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define INF 0x3f3f3f3f
#define inf (-((LL)1<<40))
#define lson k<<1, L, (L + R)>>1
#define rson k<<1|1,  ((L + R)>>1) + 1, R
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define mem(a, b) memset(a, b, sizeof(a))
#define FIN freopen("in.txt", "r", stdin)
#define FOUT freopen("out.txt", "w", stdout)
#define rep(i, a, b) for(int i = a; i <= b; i ++)
#define dec(i, a, b) for(int i = a; i >= b; i --)

template<class T> T MAX(T a, T b) { return a > b ? a : b; }
template<class T> T MIN(T a, T b) { return a < b ? a : b; }
template<class T> T GCD(T a, T b) { return b ? GCD(b, a%b) : a; }
template<class T> T LCM(T a, T b) { return a / GCD(a,b) * b;    }

//typedef __int64 LL;
typedef long long LL;
const int MAXN = 200000 + 100;
const int MAXM = 110000;
const double eps = 1e-8;
LL MOD = 1000000007;
const double PI = 4.0 * atan(1.0);

int T, N, Q;
int x, h;
struct Node {
    int x, h;
    Node(int _x = 0, int _h = -1) {
        x = _x; h = _h;
    }
}node[MAXN];
int sta[MAXN >> 1];
double ans_l[MAXN >> 1], ans_r[MAXN >> 1];

int cmp_up(Node A, Node B) { return A.x < B.x; }

int cmp_down(Node A, Node B) { return A.x > B.x; }

double pre(int r, int l) {
    return (double)(node[r].h - node[l].h) / fabs(1.0 * node[r].x - node[l].x);
}

double pre(Node a, int l) {
    return (double)(a.h - node[l].h) / fabs(1.0 * a.x - node[l].x);
}

void record_ans(double *angle) {
    int tp = 0;
    rep (i, 1, N + Q) {
        if(node[i].h < 0) {
            while(tp >= 2 && pre(Node(node[i].x, 0), sta[tp - 1]) - pre(sta[tp - 1], sta[tp - 2]) > eps) tp --;
            angle[-node[i].h] = atan(fabs(1.0 * node[i].x - node[sta[tp - 1]].x) / node[sta[tp - 1]].h);
        }
        else {
            while(tp >= 2 && pre(i, sta[tp - 1]) - pre(sta[tp - 1], sta[tp - 2]) > eps) tp --;
            sta[tp++] = i;
        }
    }
}

int main()
{
//    FIN;
    cin >> T;
    rep (cas, 1, T) {
        scanf("%d", &N);
        rep (i, 1, N) {
            scanf("%d %d", &x, &h);
            node[i] = Node(x, h);
        }
        scanf("%d", &Q);
        rep (i, 1, Q) {
            scanf("%d", &x);
            node[N + i] = Node(x, -i);
        }
        sort(node + 1, node + 1 + N + Q, cmp_up);
        record_ans(ans_l);
        sort(node + 1, node + 1 + N + Q, cmp_down);
        record_ans(ans_r);
        cout << "Case #" << cas <<":" << endl;
        rep (i, 1, Q) {
            printf("%.10f\n", (ans_l[i] + ans_r[i]) * 180 / PI);
        }
    }
    return 0;
}