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 =  + ;
 const int MAXM = ;
 const double eps = 1e-;
 LL MOD = ;
 const double PI = 4.0 * atan(1.0);

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

 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 = ;
     rep (i, , N + Q) {
         if(node[i].h < ) {
             while(tp >=  && pre(Node(node[i].x, ), sta[tp - ]) - pre(sta[tp - ], sta[tp - ]) > eps) tp --;
             angle[-node[i].h] = atan(fabs(1.0 * node[i].x - node[sta[tp - ]].x) / node[sta[tp - ]].h);
         }
         else {
             while(tp >=  && pre(i, sta[tp - ]) - pre(sta[tp - ], sta[tp - ]) > eps) tp --;
             sta[tp++] = i;
         }
     }
 }

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