HDU 5033 Building(单调栈)

题目链接http://acm.hdu.edu.cn/showproblem.php?pid=5033

Description

Once upon a time Matt went to a small town. The town was so small and narrow that he can regard the town as a pivot. There were some skyscrapers in the town, each located at position xi with its height hi. All skyscrapers located in different place. The skyscrapers had no width, to make it simple. As the skyscrapers were so high, Matt could hardly see the sky.Given the position Matt was at, he wanted to know how large the angle range was where he could see the sky. Assume that Matt's height is 0. It's guaranteed that for each query, there is at least one building on both Matt's left and right, and no building locate at his position.

Input

The first line of the input contains an integer T, denoting the number of testcases. Then T test cases follow.

Each test case begins with a number N(1<=N<=10^5), the number of buildings.

In the following N lines, each line contains two numbers, xi(1<=xi<=10^7) and hi(1<=hi<=10^7).

After that, there's a number Q(1<=Q<=10^5) for the number of queries.

In the following Q lines, each line contains one number qi, which is the position Matt was at.

Output

For each test case, first output one line "Case #x:", where x is the case number (starting from 1).

Then for each query, you should output the angle range Matt could see the sky in degrees. The relative error of the answer should be no more than 10^(-4).

Sample Input

3

3

1 2

2 1

5 1

1

4

3

1 3

2 2

5 1

1

4

3

1 4

2 3

5 1

1

4

Sample Output

Case #1:

101.3099324740

Case #2:

90.0000000000

Case #3:

78.6900675260

题意：

在一条坐标轴上给你n个楼的高度，再问你再某个坐标你所能看到天空的最大视角。

题解：

首先这个数据范围明显不能105*105暴力跑。在看了题解之后，了解到可以用一个叫做单调栈的东西。当规定了栈顶到栈低的顺序，那么在每次压栈的时候则考虑是否满足这个顺序，满足入栈，不满足栈顶弹出然后直到满足压栈。

首先是最大角度，这里首先使用了一个非常巧妙的方式。

首先我们可以将这个夹角看成以该点作垂线和左右两条之间的夹角之和。这样如果我们可以将该点的垂线和左边直线之间的夹角，再将坐标轴翻转，那么右边同样变成了上一个求出的方法，累加就好。

下面就是求垂线和左边的夹角。

这里某份题解同样用了一个非常巧妙的方式，因为查询点是高度为0，那么我们先把该点的纵坐标记作查询的顺序的负数（再按照横坐标顺序从小到大排序）。这样再后面的时候可以容易的判断是否为观察点，和容易记录半边角。

下面我们遍历所有的点，首先对于该点是查询点，那么我们开始判断栈顶的点能不能遮挡次栈顶的点，如果不能那么在后面的判断中也是不能遮挡的，则该点出栈，没有价值。直到找到这个点那么通过观察点的负值取负记录角度到输出结果。

对于非观察点，我们首先是判断该点是否比栈顶元素高，高的话明显可以遮挡出栈，不比栈顶元素高的的话我们再通过判断能否遮挡来确定栈顶元素是否出栈，然后将该点入栈。

判断函数，首先我们确定三个点a,b,c。c点是观察点，a的高度>b的高度，在我们建这个单调栈的时候我们就已经保证了这个。那么判断a->c的角度和b->c的角度，即可判断是否遮挡了。

代码：

#include <bits/stdc++.h>

using namespace std;

const double PI = acos(-1.0) ;

const int maxn = 100000+100;

struct Point {

    int x,h;

    bool operator < (const Point &R) const {

        return x < R.x ;

    }

};

Point s[maxn*2];

Point stk[maxn*2];

double ans[maxn] ;

int judge(Point a,Point b,Point c)

{

    if (c.h <= 0) c.h = 0;

    return (long long)(a.h-c.h)*(b.x-c.x) <= (long long)(b.h-c.h)*(a.x-c.x) ;

}

double angle(Point a,Point b)

{

    return atan(1.0*(b.x-a.x)/a.h) ;

}

int n,q;

void solve()

{

    int top = 0;

    for (int i = 0; i < n+q; i++){

        if (s[i].h <= 0){

            while (top >= 2 && judge(stk[top-2],stk[top-1],s[i]))

                top-- ;

            ans[-s[i].h] += angle(stk[top-1],s[i]) ;

        }else {

            while (top && stk[top-1].h <= s[i].h)

                top-- ;

            while (top >= 2 && judge(stk[top-2],stk[top-1],s[i]))

                top--;

            stk[top++] = s[i] ;

        }

    }

}

int main()

{

    int t;

    scanf("%d",&t);

    for (int _t = 1;_t <= t;_t++){

        scanf("%d",&n);

        for (int i = 0; i < n; i++)

            scanf("%d %d",&s[i].x,&s[i].h) ;

        scanf("%d",&q) ;

        for (int i = 0; i < q; i++){

            scanf("%d",&s[i+n].x);

            s[i+n].h = -i;

        }

        memset(ans,0,sizeof ans) ;

        sort(s,s+n+q) ;

        solve();

        reverse(s,s+n+q) ;

        for (int i = 0; i < n+q; i++)

            s[i].x = 10000000-s[i].x ;

        solve() ;

        printf("Case #%d:\n",_t) ;

        for (int i = 0 ; i <q; i++)

            printf("%.10lf\n",ans[i]*180/PI) ;

    }

    return 0;

}