Heaters - Practice Coding Problems

Heaters - Problem

Winter is Coming - The Heater Coverage Problem!

You're tasked with designing a heating system for a neighborhood! Given houses and heaters positioned along a straight line, you need to find the minimum radius that allows all heaters to warm every house.

The Challenge: All heaters must use the same radius, and every house must be within at least one heater's warming range.

Input: Two arrays - houses (positions of houses) and heaters (positions of heaters)
Output: The minimum radius needed to cover all houses

Example: If houses are at [1, 2, 3] and heaters at [2], then radius 1 covers all houses (heater at 2 can warm houses 1, 2, and 3).

Input & Output

example_1.py — Basic Case

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

› Output: 1

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

example_2.py — Multiple Heaters

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

› Output: 1

💡 Note: Houses 1 and 4 are covered by heaters directly (radius 0). House 2 is 1 unit from heater at 1. House 3 is 1 unit from heater at 4. Maximum radius needed is 1.

example_3.py — Edge Case

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

› Output: 3

💡 Note: The heater at position 2 needs radius 1 to reach house at 1, and radius 3 to reach house at 5. Maximum radius needed is 3.

Visualization

Tap to expand

Understanding the Visualization

Position Analysis

Map out all house and heater positions on a line

Find Nearest

For each house, identify the closest heater(s)

Calculate Radius

The maximum distance from any house to its nearest heater is the answer

Key Takeaway

🎯 Key Insight: Sort both arrays, then use two pointers to efficiently find each house's nearest heater. The maximum distance becomes our minimum required radius!

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of n houses, we check distance to all m heaters

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ houses.length, heaters.length ≤ 3 × 10⁴
1 ≤ houses[i], heaters[i] ≤ 10⁹
All values in houses are unique
All values in heaters are unique

Asked in

G Google 24 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses two pointers after sorting both arrays. Key insight: for each house, the nearest heater is either to its left or right in the sorted heater array. This achieves O(n log n + m log m) time complexity, much better than the brute force O(n×m) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Distance)	O(n × m)	O(1)	For each house, check distance to every heater and find the minimum
Two Pointers (Optimal)	O(n log n + m log m)	O(1)	Sort both arrays and use two pointers to efficiently find nearest heaters
Sorting + Binary Search	O(n log m + m log m)	O(1)	Sort heaters, then use binary search to find nearest heater for each house

Brute Force (Check Every Distance) — Algorithm Steps

For each house, initialize minimum distance as infinity
Check distance from current house to every heater
Keep track of the minimum distance for this house
Update the global maximum radius needed
Return the maximum radius across all houses

Visualization

Tap to expand

Step-by-Step Walkthrough

Check House 1

Calculate distance from house 1 to all heaters, find minimum

Check House 2

Calculate distance from house 2 to all heaters, find minimum

Find Maximum

The maximum of all minimum distances is the answer

Code -

solution.c — C

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

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

int findRadius(int* houses, int housesSize, int* heaters, int heatersSize) {
    int maxRadius = 0;
    
    for (int i = 0; i < housesSize; i++) {
        int minDistance = INT_MAX;
        for (int j = 0; j < heatersSize; j++) {
            int distance = abs_diff(houses[i], heaters[j]);
            if (distance < minDistance) {
                minDistance = distance;
            }
        }
        if (minDistance > maxRadius) {
            maxRadius = minDistance;
        }
    }
    
    return maxRadius;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of n houses, we check distance to all m heaters

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ houses.length, heaters.length ≤ 3 × 10⁴
1 ≤ houses[i], heaters[i] ≤ 10⁹
All values in houses are unique
All values in heaters are unique

26.4K 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 Every Distance) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler