Maximum Points Inside the Square

Maximum Points Inside the Square - Problem

You are given a 2D array points where points[i] represents the coordinates of point i, and a string s where s[i] represents the tag of point i.

A valid square is a square that:

Is centered at the origin (0, 0)
Has edges parallel to the axes
Does not contain two points with the same tag

Return the maximum number of points contained in a valid square.

Note: A point is considered to be inside the square if it lies on or within the square's boundaries. The side length of the square can be zero.

Input & Output

Example 1 — Basic Case

$ Input: points = [[2,2],[-1,-2],[-4,4],[-3,1],[3,-3]], s = "abdca"

› Output: 2

💡 Note: The square with maximum side length that doesn't contain duplicate tags has size 4 (distance 2 from origin), containing points [2,2] (tag 'a') and [-1,-2] (tag 'b'). Total: 2 points.

Example 2 — All Different Tags

$ Input: points = [[1,1],[-2,-2],[3,-1]], s = "abb"

› Output: 1

💡 Note: The largest valid square can only contain 1 point because tags 'b' appear twice. The square of size 2 (distance 1) contains only [1,1] with tag 'a'.

Example 3 — Single Point

$ Input: points = [[1,1]], s = "a"

› Output: 1

💡 Note: Only one point exists, so the maximum is 1.

Constraints

1 ≤ points.length ≤ 10⁵
points[i].length == 2
-10⁹ ≤ points[i][0], points[i][1] ≤ 10⁹
s.length == points.length
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is to find the largest square centered at origin that contains at most one point of each tag. The optimal approach uses binary search on the answer or sorting by distance for O(n log n) time complexity. Binary search leverages the monotonic property: if a square size is invalid, all larger sizes are also invalid.

Common Approaches

✓ Brute Force - Try All Square Sizes

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

For each possible square size, check if the square contains at most one point of each tag. The square size is determined by the maximum distance from origin to any point inside.

Binary Search on Answer

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

Since larger squares contain all points of smaller squares, we can binary search on the answer. For each candidate size, check if it forms a valid square.

Sort by Distance - Incremental Expansion

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

Sort all points by their distance from origin, then expand the square step by step. Stop when we encounter a duplicate tag.

Brute Force - Try All Square Sizes — Algorithm Steps

Step 1: Get all unique distances from origin
Step 2: For each distance, create a square and check if valid
Step 3: Return maximum valid square point count

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Distances

Find all unique distances from origin

Test Each Size

For each distance, check if square is valid

Track Maximum

Keep the largest valid square

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int max_val(int a, int b) {
    return a > b ? a : b;
}

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int solution(int points[][2], int n, char* s) {
    if (n == 0) return 0;
    
    // Get all possible distances
    int distances[1000];
    int distCount = 0;
    bool seen[10001] = {false};
    
    for (int i = 0; i < n; i++) {
        int dist = max_val(abs_val(points[i][0]), abs_val(points[i][1]));
        if (!seen[dist + 5000]) {
            seen[dist + 5000] = true;
            distances[distCount++] = dist;
        }
    }
    
    qsort(distances, distCount, sizeof(int), compare);
    
    int maxPoints = 0;
    
    for (int d = 0; d < distCount; d++) {
        int dist = distances[d];
        bool tagsSeen[256] = {false};
        int count = 0;
        bool valid = true;
        
        for (int i = 0; i < n; i++) {
            int x = points[i][0], y = points[i][1];
            if (max_val(abs_val(x), abs_val(y)) <= dist) {
                if (tagsSeen[(unsigned char)s[i]]) {
                    valid = false;
                    break;
                }
                tagsSeen[(unsigned char)s[i]] = true;
                count++;
            }
        }
        
        if (valid && count > maxPoints) {
            maxPoints = count;
        }
    }
    
    return maxPoints;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse points array
    int points[1000][2];
    int n = 0;
    char *token = strtok(line, "[],");
    while (token != NULL && n < 1000) {
        if (strlen(token) > 0 && token[0] != '\n' && token[0] != ' ') {
            points[n/2][n%2] = atoi(token);
            n++;
        }
        token = strtok(NULL, "[],");
    }
    n /= 2;
    
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int result = solution(points, n, s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n possible square sizes, we check all n points

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set to track tags in current square

⚡ Linearithmic Space

3.4K Views

Medium Frequency

~25 min Avg. Time

89 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 Square Sizes — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler