可见点的最大数目

/*
 * Problem Statement:
 * Given an array of points, an angle, and a location, find the maximum number of points that can be seen
 * within the given angle from the location. You can rotate around your location but cannot change the position.
 * 
 * Solution Approach (using Java Streams):
 * 1. For each point, calculate the angle it makes with the positive x-axis using arctangent function.
 * 2. Normalize the angles and sort them using streams.
 * 3. Use a sliding window technique to find the maximum number of points visible within the given angle.
 */

import java.util.*;
import java.util.stream.Collectors;

public class VisiblePointsStream {
    public int visiblePoints(List<List<Integer>> points, int angle, List<Integer> location) {
        int samePositionCount = 0;
        int locX = location.get(0), locY = location.get(1);

        // Calculate angles and filter points at the same location
        List<Double> angles = points.stream()
                .map(p -> {
                    int px = p.get(0), py = p.get(1);
                    if (px == locX && py == locY) {
                        samePositionCount++;
                        return null;
                    }
                    return Math.atan2(py - locY, px - locX) * 180 / Math.PI;
                })
                .filter(Objects::nonNull)
                .sorted()
                .collect(Collectors.toList());

        // Duplicate list to handle circular nature
        List<Double> extendedAngles = new ArrayList<>(angles);
        extendedAngles.addAll(angles.stream().map(a -> a + 360).collect(Collectors.toList()));

        // Find max points in a window of 'angle' size
        int maxCount = 0, j = 0, n = extendedAngles.size();
        for (int i = 0; i < n; i++) {
            while (j < n && extendedAngles.get(j) - extendedAngles.get(i) <= angle) {
                j++;
            }
            maxCount = Math.max(maxCount, j - i);
        }

        return maxCount + samePositionCount;
    }
}