Erect the Fence II

Erect the Fence II - Problem

You are given a 2D integer array trees where trees[i] = [xi, yi] represents the location of the ith tree in the garden.

You are asked to fence the entire garden using the minimum length of rope possible. The garden is well-fenced only if all the trees are enclosed and the rope used forms a perfect circle.

A tree is considered enclosed if it is inside or on the border of the circle.

More formally, you must form a circle using the rope with a center (x, y) and radius r where all trees lie inside or on the circle and r is minimum.

Return the center and radius of the circle as a length 3 array [x, y, r]. Answers within 10⁻⁵ of the actual answer will be accepted.

Input & Output

Example 1 — Square Formation

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

› Output: [1.0,1.0,1.414213]

💡 Note: The smallest circle that encloses all four trees has center at (1,1) with radius approximately √2 ≈ 1.414213. This circle passes through points (2,2), (2,0), and (0,2).

Example 2 — Single Point

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

› Output: [1.0,2.0,0.0]

💡 Note: With only one tree, the smallest circle is centered at that tree's location with radius 0.

Example 3 — Two Points

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

› Output: [1.5,2.0,2.5]

💡 Note: For two points, the smallest circle has them as diameter endpoints. Center is midpoint (1.5,2.0) and radius is half the distance: √(9+16)/2 = 2.5.

Constraints

1 ≤ trees.length ≤ 3000
trees[i].length == 2
-1000 ≤ xi, yi ≤ 1000
All the given positions are unique

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8

The key insight is that the smallest enclosing circle is determined by at most 3 boundary points. The optimal approach is Welzl's algorithm which uses recursion with randomization to achieve expected linear time. Time: O(n), Space: O(n)

Common Approaches

✓ Two Pointers

⏱️ Time: N/A Space: N/A

Brute Force - Try All Centers

⏱️ Time: O(n³) Space: O(1)

For each possible center point, calculate the minimum radius needed to enclose all trees. This involves checking all pairs of points as potential centers and finding the radius that covers all points.

Welzl's Algorithm

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

Welzl's algorithm uses a recursive approach with randomization. It picks a random point and either includes it on the boundary of the smallest circle or finds that the smallest circle for the remaining points already contains it.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

bool checkSensor1Faulty(int* sensor1, int* sensor2, int n, int mismatchPos) {
    int i = 0, j = 0;
    while (i < n && j < n) {
        if (i == mismatchPos) {
            if (j < n - 1) {
                j++;
            }
            i++;
        } else {
            if (j >= n - 1) {
                break;
            }
            if (sensor1[i] != sensor2[j]) {
                return false;
            }
            i++;
            j++;
        }
    }
    return j == n - 1;
}

bool checkSensor2Faulty(int* sensor1, int* sensor2, int n, int mismatchPos) {
    int i = 0, j = 0;
    while (i < n && j < n) {
        if (i == mismatchPos) {
            if (j < n - 1) {
                j++;
            }
            i++;
        } else {
            if (j >= n - 1) {
                break;
            }
            if (sensor2[i] != sensor1[j]) {
                return false;
            }
            i++;
            j++;
        }
    }
    return j == n - 1;
}

int solution(int* sensor1, int* sensor2, int n) {
    // Find first mismatch
    int mismatchPos = -1;
    for (int i = 0; i < n; i++) {
        if (sensor1[i] != sensor2[i]) {
            mismatchPos = i;
            break;
        }
    }
    
    if (mismatchPos == -1) {
        return -1; // No mismatch found
    }
    
    bool sensor1Faulty = checkSensor1Faulty(sensor1, sensor2, n, mismatchPos);
    bool sensor2Faulty = checkSensor2Faulty(sensor1, sensor2, n, mismatchPos);
    
    if (sensor1Faulty && !sensor2Faulty) {
        return 1;
    } else if (sensor2Faulty && !sensor1Faulty) {
        return 2;
    } else {
        return -1;
    }
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    int sensor1[500], sensor2[500];
    int n = 0;
    
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, "[,]");
    while (token != NULL && n < 500) {
        if (strlen(token) > 0 && token[0] != '\n' && token[0] != ']') {
            sensor1[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int m = 0;
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[,]");
    while (token != NULL && m < 500) {
        if (strlen(token) > 0 && token[0] != '\n' && token[0] != ']') {
            sensor2[m++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", solution(sensor1, sensor2, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~35 min Avg. Time

324 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