Erect the Fence II - Practice Coding Problems

Erect the Fence II - Problem

You're a landscape architect tasked with creating the most efficient circular fence around a beautiful garden! Given the coordinates of n trees scattered throughout the garden, you need to find the smallest possible circle that can enclose all the trees.

Your fence must be a perfect circle, and every tree must either be inside the circle or exactly on its border. No tree can be left outside! Your goal is to minimize the radius to use the least amount of fencing material.

Input: A 2D array trees where trees[i] = [xi, yi] represents the coordinates of the i-th tree.

Output: Return [x, y, r] where (x, y) is the center of the optimal circle and r is its radius.

Note: Answers within 10^-5 of the actual answer will be accepted due to floating-point precision.

Input & Output

example_1.py — Basic Triangle

$ Input: trees = [[1,1],[2,2],[2,0]]

› Output: [1.5, 1.0, 1.118033988749895]

💡 Note: The three trees form a triangle. The minimum enclosing circle passes through all three points, with center at the circumcenter and radius equal to the circumradius.

example_2.py — Collinear Points

$ Input: trees = [[1,2],[2,3],[4,5],[7,8]]

› Output: [4.0, 5.0, 4.24264068711928]

💡 Note: When points are roughly collinear, the optimal circle has diameter connecting the two farthest points. Center is midpoint of the diameter.

example_3.py — Single Point

$ Input: trees = [[0,0]]

› Output: [0, 0, 0]

💡 Note: Edge case: single tree requires no fence (radius = 0), circle center is at the tree location.

Constraints

1 ≤ trees.length ≤ 3000
-100 ≤ xi, yi ≤ 100
All trees are at distinct locations
Answers within 10^-5 of the actual answer will be accepted

Visualization

Tap to expand

Brute Force: Try all O(n³) combinations → O(n⁴) time2. Incremental: Build circle by adding points → O(n²) time3. Welzl's Magic: Random order + recursive boundary → O(n) expected!💡 Key insight: Most random points won't be on the optimal boundary

Understanding the Visualization

Geometric Foundation

Any circle is uniquely determined by at most 3 points on its boundary. This reduces our search space dramatically.

Incremental Strategy

Process trees one by one. If a new tree fits inside the current fence, we're good. If not, it must be on the new optimal fence boundary.

Randomization Magic

By processing trees in random order, we ensure that the probability of hitting a boundary point decreases exponentially, giving us linear expected time.

Recursive Elegance

When we find an outside point, we recursively solve a smaller problem with that point fixed on the boundary.

Key Takeaway

🎯 Key Insight: The minimum enclosing circle problem showcases how geometric insights (≤3 boundary points) combined with algorithmic cleverness (randomization) can transform an O(n⁴) brute force into an O(n) expected solution. Welzl's algorithm is a masterpiece of computational geometry!

Asked in

G Google 15 ⊞ Microsoft 8 a Amazon 5 f Meta 3

The optimal approach uses Welzl's Algorithm, a randomized incremental algorithm with O(n) expected time complexity. The key insight is that the minimum enclosing circle is determined by at most 3 boundary points, and most randomly ordered points won't force boundary updates.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Combinations)	O(n⁴)	O(1)	Try all possible combinations of 2-3 points to define circles
Welzl's Algorithm (Optimal)	O(n)	O(n)	Randomized incremental algorithm with expected O(n) time complexity

Brute Force (All Combinations) — Algorithm Steps

Try all single points (degenerate case)
Try all pairs of points (diameter circle)
Try all triplets of points (circumcircle)
For each circle, check if all points are inside
Return the circle with minimum radius

Visualization

Tap to expand

Step-by-Step Walkthrough

Test Diameter Circles

For each pair of points, create a circle with them as diameter endpoints

Test Circumcircles

For each triplet of points, find the unique circle passing through all three

Validate Each Circle

Check if all remaining points lie inside or on the circle boundary

Track Minimum

Keep the valid circle with the smallest radius found so far

Code -

solution.c — C

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

int numPointsInCircle(int** trees, int treesSize, double* center, double radius) {
    int count = 0;
    for (int i = 0; i < treesSize; i++) {
        double dx = trees[i][0] - center[0];
        double dy = trees[i][1] - center[1];
        if (dx*dx + dy*dy <= radius*radius + 1e-7) {
            count++;
        }
    }
    return count;
}

int getCircleCenter(int* p1, int* p2, int* p3, double* result) {
    double ax = p1[0], ay = p1[1];
    double bx = p2[0], by = p2[1];
    double cx = p3[0], cy = p3[1];
    
    double d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
    if (fabs(d) < 1e-7) return 0;
    
    result[0] = ((ax*ax + ay*ay) * (by - cy) + (bx*bx + by*by) * (cy - ay) + (cx*cx + cy*cy) * (ay - by)) / d;
    result[1] = ((ax*ax + ay*ay) * (cx - bx) + (bx*bx + by*by) * (ax - cx) + (cx*cx + cy*cy) * (bx - ax)) / d;
    
    return 1;
}

double* outerTrees(int** trees, int treesSize, int* treesColSize, int* returnSize) {
    *returnSize = 3;
    double* result = (double*)malloc(3 * sizeof(double));
    
    if (treesSize == 1) {
        result[0] = trees[0][0];
        result[1] = trees[0][1];
        result[2] = 0;
        return result;
    }
    
    if (treesSize == 2) {
        result[0] = (trees[0][0] + trees[1][0]) / 2.0;
        result[1] = (trees[0][1] + trees[1][1]) / 2.0;
        result[2] = sqrt(pow(trees[0][0] - result[0], 2) + pow(trees[0][1] - result[1], 2));
        return result;
    }
    
    double minRadius = DBL_MAX;
    
    for (int i = 0; i < treesSize; i++) {
        for (int j = i + 1; j < treesSize; j++) {
            double cx = (trees[i][0] + trees[j][0]) / 2.0;
            double cy = (trees[i][1] + trees[j][1]) / 2.0;
            double r = sqrt(pow(trees[i][0] - cx, 2) + pow(trees[i][1] - cy, 2));
            
            double center[2] = {cx, cy};
            if (numPointsInCircle(trees, treesSize, center, r) == treesSize && r < minRadius) {
                minRadius = r;
                result[0] = cx;
                result[1] = cy;
                result[2] = r;
            }
            
            for (int k = j + 1; k < treesSize; k++) {
                double circCenter[2];
                if (getCircleCenter(trees[i], trees[j], trees[k], circCenter)) {
                    double radius = sqrt(pow(trees[i][0] - circCenter[0], 2) + pow(trees[i][1] - circCenter[1], 2));
                    if (numPointsInCircle(trees, treesSize, circCenter, radius) == treesSize && radius < minRadius) {
                        minRadius = radius;
                        result[0] = circCenter[0];
                        result[1] = circCenter[1];
                        result[2] = radius;
                    }
                }
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

O(n³) combinations to try, O(n) to verify each circle contains all points

✓ Linear Growth

Space Complexity

O(1)

Only storing current best circle and temporary calculations

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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 (All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler