House Robber IV

House Robber IV - Problem

There are several consecutive houses along a street, each of which has some money inside. There is also a robber, who wants to steal money from the homes, but he refuses to steal from adjacent homes.

The capability of the robber is the maximum amount of money he steals from one house of all the houses he robbed.

You are given an integer array nums representing how much money is stashed in each house. More formally, the i^th house from the left has nums[i] dollars.

You are also given an integer k, representing the minimum number of houses the robber will steal from. It is always possible to steal at least k houses.

Return the minimum capability of the robber out of all the possible ways to steal at least k houses.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,7,11,15], k = 1

› Output: 2

💡 Note: We can rob house 0 alone with capability 2, which is the minimum possible

Example 2 — Multiple Houses Required

$ Input: nums = [2,3,5,9], k = 2

› Output: 5

💡 Note: Rob houses [2,5] with capability max(2,5)=5, or houses [3,9] with capability max(3,9)=9. Minimum is 5

Example 3 — Edge Case

$ Input: nums = [1,2,3], k = 1

› Output: 1

💡 Note: Rob only house 0 with value 1, giving capability 1

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ (nums.length + 1) / 2

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 a Amazon 15 M Microsoft 10

The key insight is to use binary search on the answer space. If we can rob k houses with capability X, we can also do it with any capability > X. The optimal approach uses binary search on capability values combined with a greedy validation check. Time: O(n log(max-min)), Space: O(1)

Common Approaches

✓ Optimized

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

Dp 1d

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

Binary Search on Answer with Greedy Check

⏱️ Time: O(n log(max-min)) Space: O(1)

Binary search on the answer space (minimum capability). For each candidate capability, use a greedy approach to check if we can rob at least k houses without exceeding that capability.

Brute Force with Backtracking

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

Generate all valid combinations of non-adjacent houses with at least k houses. For each valid combination, find the maximum value (capability) and track the minimum capability across all combinations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* coinChange(int* coins, int coinSize, int target) {
    int* dp = (int*)calloc(target + 1, sizeof(int));
    dp[0] = 1;
    for (int i = 0; i < coinSize; i++) {
        for (int amount = coins[i]; amount <= target; amount++) {
            dp[amount] += dp[amount - coins[i]];
        }
    }
    return dp;
}

int* solution(int* numWays, int numWaysSize, int* returnSize) {
    if (numWaysSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int* denominations = (int*)malloc(numWaysSize * sizeof(int));
    int count = 0;
    
    // Check each potential denomination
    for (int candidate = 1; candidate <= numWaysSize; candidate++) {
        // Skip if we can't make this amount
        if (numWays[candidate - 1] == 0) continue;
        
        // Calculate current ways using existing denominations
        int* currentDp;
        if (count == 0) {
            currentDp = (int*)calloc(candidate + 1, sizeof(int));
            currentDp[0] = 1;
        } else {
            currentDp = coinChange(denominations, count, candidate);
        }
        
        // If we need more ways than currently possible, add this denomination
        if (currentDp[candidate] < numWays[candidate - 1]) {
            denominations[count++] = candidate;
        }
        
        free(currentDp);
    }
    
    // Final validation
    if (count > 0) {
        int* finalDp = coinChange(denominations, count, numWaysSize);
        for (int i = 1; i <= numWaysSize; i++) {
            if (finalDp[i] != numWays[i - 1]) {
                free(finalDp);
                *returnSize = 0;
                free(denominations);
                return NULL;
            }
        }
        free(finalDp);
    }
    
    *returnSize = count;
    return count > 0 ? denominations : NULL;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int numWays[100];
    int size = 0;
    
    if (strcmp(line, "[]\n") != 0) {
        char* token = strtok(line + 1, ",]");
        while (token != NULL) {
            numWays[size++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int returnSize;
    int* result = solution(numWays, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    if (result) free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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