Maximum Number of Visible Points

Maximum Number of Visible Points - Problem

You are given an array points, an integer angle, and your location location = [posx, posy] where points[i] = [xi, yi] both denote integral coordinates on the X-Y plane.

Initially, you are facing directly east from your position. You cannot move from your position, but you can rotate. In other words, posx and posy cannot be changed. Your field of view in degrees is represented by angle, determining how wide you can see from any given view direction.

Let d be the amount in degrees that you rotate counterclockwise. Then, your field of view is the inclusive range of angles [d - angle/2, d + angle/2].

You can see some set of points if, for each point, the angle formed by the point, your position, and the immediate east direction from your position is in your field of view.

There can be multiple points at one coordinate. There may be points at your location, and you can always see these points regardless of your rotation. Points do not obstruct your vision to other points.

Return the maximum number of points you can see.

Input & Output

Example 1 — Basic Field of View

$ Input: points = [[2,1],[2,2],[3,3]], angle = 90, location = [1,1]

› Output: 3

💡 Note: With a 90° field of view, we can rotate to capture all 3 points. The optimal rotation direction allows us to see points at angles that fit within the 90° range.

Example 2 — Narrow View

$ Input: points = [[2,1],[2,2],[3,4],[1,1]], angle = 30, location = [1,1]

› Output: 2

💡 Note: Point [1,1] is at our location (always visible). With 30° field of view, we can see at most 1 additional point, for total of 2.

Example 3 — Wide View

$ Input: points = [[1,0],[2,1]], angle = 180, location = [1,1]

› Output: 2

💡 Note: With 180° field of view (half circle), we can see both points by rotating to an appropriate direction.

Constraints

1 ≤ points.length ≤ 10³
points[i].length == 2
location.length == 2
-10⁹ ≤ x_i, y_i ≤ 10⁹
0 ≤ angle < 360

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 a Amazon 6

The key insight is to convert the geometric problem into angles and use sliding window. Convert all points to polar angles from your location, sort them, then use a sliding window to efficiently find the rotation that captures the maximum points within the field of view. Best approach is sliding window with Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force - Try All Rotations

⏱️ Time: O(n²) Space: O(n)

For each possible rotation direction, calculate which points fall within the field of view and track the maximum count. This involves computing angles for all points relative to each rotation.

Optimized Sliding Window

⏱️ Time: O(n log n) Space: O(n)

Convert all points to angles, sort them, then use a sliding window approach to efficiently find the rotation that captures the most points within the field of view.

Brute Force - Try All Rotations — Algorithm Steps

Calculate angle for each point relative to location
For each possible rotation direction (0 to 360°)
Count points within the field of view range
Return maximum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Angles

Convert all points to polar angles from location

Try Each Direction

For each angle, count points in field of view

Find Maximum

Return the rotation with most visible points

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define M_PI 3.14159265358979323846

// Helper function to calculate atan using Taylor series
double atan_approx(double x) {
    if (x < 0) return -atan_approx(-x);
    
    if (x > 1) {
        return M_PI/2 - atan_approx(1.0/x);
    }
    
    // Taylor series for atan(x) when |x| <= 1
    double result = x;
    double term = x;
    for (int n = 1; n < 20; n++) {
        term *= -x * x;
        result += term / (2*n + 1);
    }
    
    return result;
}

// Proper atan2 implementation
double atan2_approx(double y, double x) {
    if (x > 0) {
        return atan_approx(y / x);
    } else if (x < 0) {
        if (y >= 0) {
            return atan_approx(y / x) + M_PI;
        } else {
            return atan_approx(y / x) - M_PI;
        }
    } else { // x == 0
        if (y > 0) {
            return M_PI / 2;
        } else if (y < 0) {
            return -M_PI / 2;
        } else {
            return 0; // undefined, but return 0
        }
    }
}

int solution(int points[][2], int pointsSize, int angle, int location[]) {
    if (angle >= 360) {
        return pointsSize;
    }
    
    int sameLocation = 0;
    double angles[1000];
    int angleCount = 0;
    
    for (int i = 0; i < pointsSize; i++) {
        if (points[i][0] == location[0] && points[i][1] == location[1]) {
            sameLocation++;
        } else {
            double y_diff = points[i][1] - location[1];
            double x_diff = points[i][0] - location[0];
            
            double rad = atan2_approx(y_diff, x_diff);
            double deg = rad * 180.0 / M_PI;
            
            if (deg < 0) {
                deg += 360;
            }
            
            angles[angleCount++] = deg;
        }
    }
    
    if (angleCount == 0) {
        return sameLocation;
    }
    
    // Sort angles
    for (int i = 0; i < angleCount - 1; i++) {
        for (int j = 0; j < angleCount - i - 1; j++) {
            if (angles[j] > angles[j + 1]) {
                double temp = angles[j];
                angles[j] = angles[j + 1];
                angles[j + 1] = temp;
            }
        }
    }
    
    int maxCount = 0;
    
    // Try each angle as starting point
    for (int i = 0; i < angleCount; i++) {
        int count = 0;
        double startAngle = angles[i];
        
        for (int j = 0; j < angleCount; j++) {
            double angleDiff = angles[j] - startAngle;
            if (angleDiff < 0) angleDiff += 360;
            if (angleDiff <= angle) {
                count++;
            }
        }
        
        if (count > maxCount) {
            maxCount = count;
        }
    }
    
    // Try the circular case where field of view wraps around
    for (int i = 0; i < angleCount; i++) {
        int count = 0;
        double endAngle = angles[i];
        double startAngle = endAngle - angle;
        if (startAngle < 0) startAngle += 360;
        
        for (int j = 0; j < angleCount; j++) {
            if (startAngle <= endAngle) {
                if (startAngle <= angles[j] && angles[j] <= endAngle) {
                    count++;
                }
            } else { // wraps around 0°
                if (angles[j] >= startAngle || angles[j] <= endAngle) {
                    count++;
                }
            }
        }
        
        if (count > maxCount) {
            maxCount = count;
        }
    }
    
    return maxCount + sameLocation;
}

void parsePoints(char* str, int points[][2], int* pointsSize) {
    *pointsSize = 0;
    char* ptr = str;
    
    while (*ptr) {
        if (*ptr == '[' && *(ptr+1) != '[') {
            ptr++;
            
            // Skip whitespace
            while (*ptr == ' ') ptr++;
            
            // Parse x
            char* endPtr;
            int x = strtol(ptr, &endPtr, 10);
            ptr = endPtr;
            
            // Skip comma and whitespace
            while (*ptr == ',' || *ptr == ' ') ptr++;
            
            // Parse y
            int y = strtol(ptr, &endPtr, 10);
            ptr = endPtr;
            
            points[*pointsSize][0] = x;
            points[*pointsSize][1] = y;
            (*pointsSize)++;
            
            // Skip to next '[' or end
            while (*ptr && *ptr != '[') ptr++;
        } else {
            ptr++;
        }
    }
}

void parseLocation(char* str, int location[]) {
    char* ptr = str;
    int idx = 0;
    
    while (*ptr && idx < 2) {
        if ((*ptr >= '0' && *ptr <= '9') || *ptr == '-') {
            char* endPtr;
            int num = strtol(ptr, &endPtr, 10);
            location[idx++] = num;
            ptr = endPtr;
        } else {
            ptr++;
        }
    }
}

int main() {
    char line[10000];
    int points[1000][2];
    int pointsSize = 0;
    int angle;
    int location[2];
    
    fgets(line, sizeof(line), stdin);
    parsePoints(line, points, &pointsSize);
    
    scanf("%d", &angle);
    
    fgets(line, sizeof(line), stdin); // consume newline
    fgets(line, sizeof(line), stdin);
    parseLocation(line, location);
    
    printf("%d\n", solution(points, pointsSize, angle, location));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n points as potential rotation center, we check all n points

⚡ Linearithmic

Space Complexity

O(n)

Store angles for all points

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Rotations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler