Maximum Points Inside the Square - Practice Coding Problems

Maximum Points Inside the Square - Problem

Maximum Points Inside the Square

Imagine you're a game designer creating a magical square arena centered at the origin (0, 0) with edges parallel to the coordinate axes. You have a collection of tagged points scattered across a 2D plane, where each point has unique coordinates and a character tag.

Your challenge: Find the largest possible square that contains the maximum number of points while following one crucial rule - no two points with the same tag can coexist within the square.

Input:
• points: A 2D array where points[i] = [x, y] represents coordinates
• s: A string where s[i] is the character tag for points[i]

Output: Return the maximum number of points that can fit in a valid square.

Key Rules:
• Square is centered at origin (0, 0)
• Square edges are parallel to axes
• Points on square boundaries count as inside
• Square side length can be zero (just the origin)
• No duplicate tags allowed within the square

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: The square with side length 4 (distance 2 from origin) contains points [2,2] with tag 'a' and [-1,-2] with tag 'b'. No duplicate tags, so we can include 2 points maximum.

example_2.py — All Points Valid

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

› Output: 1

💡 Note: Points have tags 'a', 'b', 'b'. Since two points have tag 'b', we can only include one point with tag 'b'. The largest valid square contains just 1 point.

example_3.py — Origin Only

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

› Output: 1

💡 Note: Single point case. The square of side length 2 (distance 1) contains the point [1,1] with tag 'a', giving us 1 point.

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

Understanding the Visualization

Map the Gallery

Plot all artworks on coordinate grid with their sensor tags

Calculate Distances

Measure each artwork's distance from the entrance (origin)

Sort by Distance

Arrange artworks from closest to farthest from entrance

Expand Security Zone

Gradually increase square zone size, monitoring for sensor conflicts

Detect Conflict

Stop expansion when we encounter duplicate sensor codes

Return Maximum

Report the largest conflict-free zone size

Key Takeaway

🎯 Key Insight: The optimal square size is determined by sorting points by distance and finding the largest square that stops just before encountering any duplicate tag.

Asked in

G Google 23 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal approach uses sorting and binary search to efficiently find the largest valid square. First, sort all points by their distance from origin (using max(|x|, |y|)). Then use binary search on the distance to find the largest square size that contains no duplicate tags. This reduces time complexity from O(n²) brute force to O(n log² n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Square Sizes)	O(n²)	O(n)	Test every possible square size and count valid points for each
Sorting + Binary Search on Distance	O(n log² n)	O(n)	Sort points by distance and binary search for the largest valid square

Brute Force (Try All Square Sizes) — Algorithm Steps

Calculate Manhattan distance for each point (max of |x|, |y|)
Try every possible square size from 0 to maximum distance
For each size, count points that fit inside without duplicate tags
Return the maximum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Distances

Find the distance of each point from origin using max(|x|, |y|)

Try Each Size

For each possible square size, check which points fit inside

Check Duplicates

Ensure no duplicate tags exist within each square

Track Maximum

Keep track of the maximum valid count found

Code -

solution.c — C

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

int max(int a, int b) { return a > b ? a : b; }
int abs_val(int x) { return x < 0 ? -x : x; }

int numPointsInLargestSquare(int** points, int pointsSize, int* pointsColSize, char* s) {
    int maxPoints = 0;
    
    // Find maximum possible square size
    int maxSize = 0;
    for (int i = 0; i < pointsSize; i++) {
        maxSize = max(maxSize, max(abs_val(points[i][0]), abs_val(points[i][1])));
    }
    
    // Try all possible square sizes
    for (int size = 0; size <= maxSize; size++) {
        bool seenTags[256] = {false}; // ASCII characters
        int count = 0;
        bool valid = true;
        
        for (int i = 0; i < pointsSize; i++) {
            // Check if point is within current square
            if (max(abs_val(points[i][0]), abs_val(points[i][1])) <= size) {
                if (seenTags[(unsigned char)s[i]]) {
                    valid = false;
                    break;
                }
                seenTags[(unsigned char)s[i]] = true;
                count++;
            }
        }
        
        if (valid) {
            maxPoints = max(maxPoints, count);
        }
    }
    
    return maxPoints;
}

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)

Need to store tags seen for each square size check

⚡ Linearithmic Space

28.3K Views

Medium-High Frequency

~25 min Avg. Time

847 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