Heaters

Heaters - Problem

Winter is coming! During the contest, your first job is to design a standard heater with a fixed warm radius to warm all the houses.

Every house can be warmed, as long as the house is within the heater's warm radius range. Given the positions of houses and heaters on a horizontal line, return the minimum radius standard of heaters so that those heaters could cover all houses.

Notice that all the heaters follow your radius standard, and the warm radius will be the same.

Input & Output

Example 1 — Basic Case

$ Input: houses = [1,2,3], heaters = [2]

› Output: 1

💡 Note: The only heater is at position 2. House at 1 needs radius 1, house at 2 needs radius 0, house at 3 needs radius 1. Maximum radius needed is 1.

Example 2 — Multiple Heaters

$ Input: houses = [1,2,3,4], heaters = [1,4]

› Output: 1

💡 Note: Houses at positions 1 and 4 are covered by heaters. House at 2 is closest to heater at 1 (distance 1), house at 3 is closest to heater at 4 (distance 1). Maximum radius needed is 1.

Example 3 — Single House

$ Input: houses = [1], heaters = [1,2,3,4]

› Output: 0

💡 Note: The house at position 1 has a heater at the exact same position, so radius 0 is sufficient.

Constraints

1 ≤ houses.length, heaters.length ≤ 3 × 10⁴
1 ≤ houses[i], heaters[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12

The key insight is to find the minimum distance from each house to its closest heater, then return the maximum of these distances. The optimal approach uses binary search after sorting heaters for O(n log m + m log m) time complexity.

Common Approaches

✓ Hash Map

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

Binary Search with Sorting

⏱️ Time: O(n log m + m log m) Space: O(1)

First sort the heaters array. For each house, use binary search to find the closest heater position, then calculate the minimum distance. The maximum such distance is our answer.

Brute Force

⏱️ Time: O(n×m) Space: O(1)

For every house, calculate the distance to every heater and find the minimum distance. The maximum of all these minimum distances is our answer.

Two Pointers Approach

⏱️ Time: O(n log n + m log m) Space: O(1)

Sort both houses and heaters arrays. Use two pointers to efficiently find the closest heater for each house by moving through both sorted arrays simultaneously.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int min_val(int a, int b) {
    return a < b ? a : b;
}

int max_val(int a, int b) {
    return a > b ? a : b;
}

int solution(int* houses, int housesSize, int* heaters, int heatersSize) {
    qsort(heaters, heatersSize, sizeof(int), compare);
    int maxRadius = 0;
    
    for (int i = 0; i < housesSize; i++) {
        int house = houses[i];
        // Binary search to find closest heater
        int left = 0, right = heatersSize - 1;
        int closestDist = INT_MAX;
        
        while (left <= right) {
            int mid = (left + right) / 2;
            int dist = abs_val(heaters[mid] - house);
            closestDist = min_val(closestDist, dist);
            
            if (heaters[mid] < house) {
                left = mid + 1;
            } else if (heaters[mid] > house) {
                right = mid - 1;
            } else {
                closestDist = 0;
                break;
            }
        }
        
        // Also check adjacent positions
        if (left < heatersSize) {
            closestDist = min_val(closestDist, abs_val(heaters[left] - house));
        }
        if (right >= 0) {
            closestDist = min_val(closestDist, abs_val(heaters[right] - house));
        }
        
        maxRadius = max_val(maxRadius, closestDist);
    }
    
    return maxRadius;
}

int parseArray(char* line, int* arr) {
    int count = 0;
    char* ptr = line;
    
    while (*ptr) {
        while (*ptr && !isdigit(*ptr) && *ptr != '-') ptr++;
        if (*ptr) {
            arr[count++] = atoi(ptr);
            while (*ptr && (isdigit(*ptr) || *ptr == '-')) ptr++;
        }
    }
    return count;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int houses[1000], heaters[1000];
    int housesSize = parseArray(line1, houses);
    int heatersSize = parseArray(line2, heaters);
    
    int result = solution(houses, housesSize, heaters, heatersSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

38.0K Views

Medium Frequency

~25 min Avg. Time

1.1K 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