和人事谈的月薪4w，但offer上工资构成是基本工资1w+绩效工资3w，有坑吗?

这道题的核心思想其实和“旋转窗口”或者“极角排序”这类思路比较接近。先来看看问题：

题目大意
给你一堆点（x, y），你站在一个固定的点 (px, py)，然后有一个视野角 angle，问你最多能看到多少个点。

这其实就是个“计算可见点”的问题，和我们写游戏时做视野裁剪（Frustum Culling）有异曲同工之妙。你得知道哪些点是在你的“可视范围”内，哪些点是“看不见”的。

解题思路

1. 计算所有点相对 (px, py) 的极角（Polar Angle）。
2. 把这些角度排序，然后利用滑动窗口在 angle 允许的范围内求最多的点数。
3. 关键优化点：由于角度是 360 度循环的，为了处理边界情况，我们可以把角度数组“复制一份”拼接起来。

代码实现
我们用 Java 来实现这个算法，思路很清晰：

1. 先计算所有点的极角（atan2）。
2. 排序并扩展角度（因为角度是圆的，需要处理 360 度边界情况）。
3. 用滑动窗口在 angle 范围内找最大点数。

import java.util.*;
public class VisiblePoints {
    public int maxVisiblePoints(List<List<Integer>> points, int angle, List<Integer> location) {
        int samePositionCount = 0;
        List<Double> angles = new ArrayList<>();
        int px = location.get(0), py = location.get(1);
                // 计算所有点的极角
        for (List<Integer> p : points) {
            int x = p.get(0), y = p.get(1);
            if (x == px && y == py) {
                samePositionCount++; // 如果点和自己重合，直接加计数
            } else {
                double theta = Math.toDegrees(Math.atan2(y - py, x - px)); // 计算角度
                angles.add(theta);
            }
        }
        // 排序角度
        Collections.sort(angles);
                // 处理角度“拼接”，为了避免 360 度边界问题
        int n = angles.size();
        for (int i = 0; i < n; i++) {
            angles.add(angles.get(i) + 360);
        }
        // 滑动窗口查找最大可见点
        int maxPoints = 0;
        int j = 0;
        for (int i = 0; i < n; i++) {
            while (j < angles.size() && angles.get(j) - angles.get(i) <= angle) {
                j++;
            }
            maxPoints = Math.max(maxPoints, j - i);
        }
        return maxPoints + samePositionCount;
    }
    public static void main(String[] args) {
        VisiblePoints solver = new VisiblePoints();
        List<List<Integer>> points = Arrays.asList(
                Arrays.asList(2, 2),
                Arrays.asList(3, 3),
                Arrays.asList(4, 4),
                Arrays.asList(1, 1),
                Arrays.asList(0, 0)
        );
        List<Integer> location = Arrays.asList(1, 1);
        int angle = 90;
        System.out.println(solver.maxVisiblePoints(points, angle, location)); // 输出可见点最大数量
    }
}

代码解析

1. atan2(y - py, x - px) 计算点相对 (px, py) 的极角，并转换成角度（度数）。
2. 对角度排序，方便滑动窗口操作。
3. 把 angles 数组“展开”一份（加 360 度），以便处理边界情况（类似于双倍字符串技巧）。
4. 采用滑动窗口（两个指针 i 和 j）找到最大可见点数。

时间复杂度

• 计算角度 O(n)
• 排序 O(n log n)
• 滑动窗口 O(n)

最终整体复杂度是 O(n log n)，足够应对大规模数据。

一些有趣的思考

• 这个问题其实很像“雷达扫描”或“FOV（Field of View）检测”，在 3D 游戏开发里也有类似的场景裁剪优化。
• 也可以用二分查找来优化滑动窗口，进一步降低复杂度，但对于大多数场景 O(n log n) 已经够用了。

总之，这题既考察了数学计算，也涉及到算法优化，是个不错的练手题！😆