Count Lattice Points Inside a Circle

Count Lattice Points Inside a Circle - Problem

Given a 2D integer array circles where circles[i] = [xi, yi, ri] represents the center (xi, yi) and radius ri of the ith circle drawn on a grid, return the number of lattice points that are present inside at least one circle.

A lattice point is a point with integer coordinates. Points that lie on the circumference of a circle are also considered to be inside it.

Input & Output

Example 1 — Two Circles with Overlap

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

› Output: 16

💡 Note: Circle 1 centered at (2,2) with radius 1 covers points like (1,2), (2,1), (2,2), (2,3), (3,2). Circle 2 centered at (3,4) with radius 1 covers points like (2,4), (3,3), (3,4), (3,5), (4,4). Total unique lattice points is 16.

Example 2 — Single Small Circle

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

› Output: 5

💡 Note: Circle centered at (1,1) with radius 1 covers lattice points: (0,1), (1,0), (1,1), (1,2), (2,1). Total is 5 points.

Example 3 — Multiple Overlapping Circles

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

› Output: 12

💡 Note: Three circles with radius 1 each, positioned diagonally. Some points are covered by multiple circles but counted only once. Total unique lattice points is 12.

Constraints

1 ≤ circles.length ≤ 200
circles[i].length == 3
-100 ≤ x_i, y_i ≤ 100
1 ≤ r_i ≤ min(x_i, y_i) + 100

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

The key insight is to use the distance formula to check if lattice points fall within circles. The optimal approach processes each circle individually and uses a set to automatically handle duplicate points. Best approach is Circle-by-Circle with Set: Time O(n × r²), Space O(k) where k is the number of unique points.

Common Approaches

✓ Brute Force - Check All Points

⏱️ Time: O(n × w × h) Space: O(1)

Find the bounding box that contains all circles, then check every lattice point in that area to see if it falls inside at least one circle. Use the distance formula to determine if a point is within a circle's radius.

Circle-by-Circle with Set

⏱️ Time: O(n × r²) Space: O(k)

Instead of checking all points in the bounding box, iterate through each circle and find all lattice points within its bounds. Use a set to automatically handle duplicates when points are covered by multiple circles.

Brute Force - Check All Points — Algorithm Steps

Step 1: Find the bounding box containing all circles
Step 2: For each lattice point in the bounding box, check if it's inside any circle
Step 3: Count unique points that are inside at least one circle

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Bounding Box

Determine the rectangle that contains all circles

Check Each Point

For every lattice point, test if it's inside any circle

Count Results

Sum up all points that are inside at least one circle

Code -

solution.c — C

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

#define MAX_POINTS 100000

static struct {
    int x, y;
} latticePoints[MAX_POINTS];
static int pointCount = 0;

bool hasPoint(int x, int y) {
    for (int i = 0; i < pointCount; i++) {
        if (latticePoints[i].x == x && latticePoints[i].y == y) {
            return true;
        }
    }
    return false;
}

void addPoint(int x, int y) {
    if (!hasPoint(x, y)) {
        latticePoints[pointCount].x = x;
        latticePoints[pointCount].y = y;
        pointCount++;
    }
}

int solution(int circles[][3], int circleCount) {
    pointCount = 0;
    
    for (int i = 0; i < circleCount; i++) {
        int x = circles[i][0];
        int y = circles[i][1];
        int r = circles[i][2];
        
        // Check all points in the bounding box of the circle
        for (int px = x - r; px <= x + r; px++) {
            for (int py = y - r; py <= y + r; py++) {
                // Check if point (px, py) is inside or on the circle
                if ((px - x) * (px - x) + (py - y) * (py - y) <= r * r) {
                    addPoint(px, py);
                }
            }
        }
    }
    
    return pointCount;
}

int main() {
    static int circles[1000][3];
    int circleCount = 0;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse circles array
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            circles[circleCount][0] = (int)strtol(ptr, &ptr, 10);
            if (*ptr == ',') ptr++;
            circles[circleCount][1] = (int)strtol(ptr, &ptr, 10);
            if (*ptr == ',') ptr++;
            circles[circleCount][2] = (int)strtol(ptr, &ptr, 10);
            circleCount++;
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
        } else {
            ptr++;
        }
    }
    
    printf("%d\n", solution(circles, circleCount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × w × h)

For each circle (n), we check all points in bounding box (width × height)

✓ Linear Growth

Space Complexity

O(1)

Only using variables for coordinates, no extra data structures

✓ Linear Space

12.0K Views

Medium Frequency

~25 min Avg. Time

340 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 - Check All Points — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler