力扣1610——可见点的最大数目（数学）

题目描述（困难）

给你一个点数组 points 和一个表示角度的整数 angle ，你的位置是 location ，其中 location = [posx, posy] 且 points[i] = [xi, yi] 都表示 X-Y 平面上的整数坐标。

最开始，你面向东方进行观测。你 不能 进行移动改变位置，但可以通过 自转 调整观测角度。换句话说，posx 和 posy 不能改变。你的视野范围的角度用 angle 表示， 这决定了你观测任意方向时可以多宽。设 d 为你逆时针自转旋转的度数，那么你的视野就是角度范围 [d - angle/2, d + angle/2] 所指示的那片区域。
对于每个点，如果由该点、你的位置以及从你的位置直接向东的方向形成的角度 位于你的视野中 ，那么你就可以看到它。

同一个坐标上可以有多个点。你所在的位置也可能存在一些点，但不管你的怎么旋转，总是可以看到这些点。同时，点不会阻碍你看到其他点。

返回你能看到的点的最大数目。



提示：

1 <= points.length <= 105
points[i].length == 2
location.length == 2
0 <= angle < 360
0 <= posx, posy, xi, yi <= 100

思路

很直观的想法，计算每个点的角度
直角坐标转换为极坐标，通过arctan函数以及分情况处理得到每个点的角坐标，中间记录相同点；
按角坐标排序，度数都在0到360之间，
对小于angle的角，加入（360 + 角度），因为是环形，可重复扫，举例范围90度，可覆盖315和45这个范围，可跨过x轴。这样处理相当于把环变直线。
问题转化为直线上选取angle范围，其中点数最大为多少，可以双指针扫，我用队列写了
用队列存起点，如果当前点和起点满足角度要求，将该点入队；
如果不满足，起点出队，换下一队首点来判断。中间记录更新最大值。
最后答案为相同点+最大值。

这题的细节点太多了，arctan的处理，x轴可横跨，double浮点误差等
调了好久

代码

class Solution {
public:
    double PI = 3.1415926;
    int visiblePoints(vector<vector<int>>& points, int angle, vector<int>& location) {
        vector<double> angs;
        int ans = 0;
        int x0 = location[0], y0 = location[1];
        for(auto p : points) {
            double pang;
            if(p[1] == y0 && p[0] == x0) {
                ans++;
                continue;
            }
            else if(p[0] == x0) {
                if(p[1] > y0) pang = 90;
                else pang = 270;
            }
            else if(p[1] == y0) {
                if(p[0] > x0) pang = 0;
                else pang = 180;
            }
            else {
                double ptan = (double)abs(p[1] - y0) / (double)abs(p[0] - x0);
                pang = atan(ptan)*180/PI;   //第一象限不变
                if(p[1] > y0 && p[0] < x0)  //第二象限
                    pang = 180 - pang;
                else if(p[1] < y0 && p[0] < x0) //第三象限
                    pang = 180 + pang;
                else if(p[1] < y0 && p[0] > x0) //第四象限
                    pang = 360 - pang;
            }
            angs.push_back(pang);
        }
        sort(angs.begin(), angs.end());        
        int n = angs.size();
        if(n <= 1) 
            return ans;
        int tmpmax = 0;
        queue<int> qu;
        qu.push(0);
        for(int i = 0; i < n; i++) {
            if(angs[i] <= angle) angs.push_back(360 + angs[i]);
        }
        n = angs.size();
        for(int i = 1; i < n; i++) {
            if(angs[i] - angs[qu.front()] <= (double) (angle + 0.001)) {
                qu.push(i);
                int tmp = qu.size();
                tmpmax = max(tmpmax, tmp);
            } 
            else {
                while(!qu.empty() && angs[i] - angs[qu.front()] > angle) {
                    qu.pop();
                }
                qu.push(i);
                int tmp = qu.size();
                tmpmax = max(tmpmax, tmp);
            }
        }
        return ans + tmpmax;
    }
};