Count Lattice Points Inside a Circle - Practice Coding Problems

Count Lattice Points Inside a Circle - Problem

You're given a collection of circles on a 2D coordinate grid, and you need to count how many lattice points (points with integer coordinates) fall inside at least one of these circles.

Each circle is defined by its center coordinates (x, y) and radius r. A point is considered inside a circle if the distance from the point to the circle's center is less than or equal to the radius - this means points on the circumference count too!

Goal: Return the total count of unique lattice points that are covered by one or more circles.

Example: If you have a circle centered at (0, 0) with radius 2, it would contain lattice points like (0,0), (1,0), (0,1), (2,0), etc.

Input & Output

example_1.py — Single Circle

$ Input: circles = [[2,2,1]]

› Output: 5

💡 Note: The circle centered at (2,2) with radius 1 contains lattice points: (1,2), (2,1), (2,2), (2,3), (3,2). Total = 5 points.

example_2.py — Multiple Overlapping Circles

$ Input: circles = [[2,2,2],[3,4,1]]

› Output: 16

💡 Note: First circle contains 13 points, second circle contains 5 points, but 2 points are shared between both circles. Total unique points = 13 + 5 - 2 = 16.

example_3.py — Non-overlapping Circles

$ Input: circles = [[1,1,1],[10,10,1]]

› Output: 10

💡 Note: Each circle contains 5 lattice points and they don't overlap since they're far apart. Total = 5 + 5 = 10 points.

Visualization

Tap to expand

Understanding the Visualization

Place Sprinklers

Each circle represents a sprinkler with its coverage area

Find Bounding Boxes

For efficiency, we only check points within each sprinkler's square bounding area

Count Coverage

Use a set to count unique grid points that get watered by at least one sprinkler

Key Takeaway

🎯 Key Insight: Bounding box optimization reduces the search space from the entire coordinate plane to just the areas around each circle, making the solution much more efficient!

Time & Space Complexity

Time Complexity

⏱️

O(C × R²)

Where C is number of circles and R is the maximum radius. We check at most (2R+1)² points per circle.

✓ Linear Growth

Space Complexity

O(P)

Where P is the number of unique lattice points inside circles (for the hash set)

✓ Linear Space

Constraints

1 ≤ circles.length ≤ 200
circles[i].length == 3
1 ≤ x_i, y_i ≤ 100
1 ≤ r_i ≤ min(x_i, y_i)
Important: Points on the circumference are considered inside the circle

Asked in

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

The optimal solution uses bounding box optimization with a hash set to efficiently count unique lattice points. Instead of checking every possible coordinate, we calculate each circle's bounding rectangle and only test points within that region, using a set to automatically handle duplicate points from overlapping circles.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Points)	O(R² × C)	O(1)	Check every possible lattice point in a large range for each circle
Bounding Box + Hash Set (Optimal)	O(C × R²)	O(P)	Use bounding boxes to limit search area and hash set to avoid duplicates

Brute Force (Check All Points) — Algorithm Steps

Define a large search range for x and y coordinates
For each lattice point (x, y) in this range
Check if the point is inside any circle using distance formula
If inside at least one circle, increment the counter
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Define Search Grid

Create a large grid covering all possible points

Check Each Point

For every grid intersection, test against all circles

Count Covered Points

Increment counter when point is inside any circle

Code -

solution.c — C

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

int countLatticePoints(int circles[][3], int n) {
    int count = 0;
    // Check points in a large range
    for (int x = -1000; x <= 1000; x++) {
        for (int y = -1000; y <= 1000; y++) {
            // Check if point (x,y) is inside any circle
            for (int i = 0; i < n; i++) {
                int cx = circles[i][0], cy = circles[i][1], r = circles[i][2];
                if ((x - cx) * (x - cx) + (y - cy) * (y - cy) <= r * r) {
                    count++;
                    break;
                }
            }
        }
    }
    return count;
}

int main() {
    // Implementation for parsing input needed
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(R² × C)

Where R is the coordinate range and C is number of circles. We check R² points, each against C circles.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track count and current position

✓ Linear Space

Constraints

1 ≤ circles.length ≤ 200
circles[i].length == 3
1 ≤ x_i, y_i ≤ 100
1 ≤ r_i ≤ min(x_i, y_i)
Important: Points on the circumference are considered inside the circle

24.7K Views

Medium Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Points) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler