Minimum Number of Food Buckets to Feed the Hamsters

Minimum Number of Food Buckets to Feed the Hamsters - Problem

You're managing a hamster habitat represented by a string where each position can either contain a hamster ('H') or be empty ('.'). Your goal is to strategically place food buckets in empty positions to feed all the hamsters using the minimum number of buckets possible.

A hamster can be fed if there's at least one food bucket in an adjacent position (either immediately to its left or right). For example, if there's a hamster at position i, placing a food bucket at position i-1 or i+1 will satisfy that hamster's needs.

The Challenge: Find the minimum number of food buckets needed to feed all hamsters, or return -1 if it's impossible to feed them all.

Examples:
• "H.H" → Need 1 bucket in the middle: "HFH"
• "HHH" → Impossible! Adjacent hamsters can't share food buckets
• "H..H" → Need 2 buckets: "HF.FH" or optimize to 1: "H.FH"

Input & Output

example_1.py — Basic Case

$ Input: hamsters = "H.H"

› Output: 1

💡 Note: Place one food bucket at position 1. The bucket feeds both hamsters at positions 0 and 2.

example_2.py — Impossible Case

$ Input: hamsters = "HHH"

› Output: -1

💡 Note: It's impossible to feed all hamsters because consecutive hamsters cannot share the same food bucket, and there are no empty positions.

example_3.py — Optimal Placement

$ Input: hamsters = "H..H"

› Output: 1

💡 Note: We can place one food bucket at position 1 or 2. Either position feeds both hamsters, so the minimum is 1.

Constraints

1 ≤ hamsters.length ≤ 10⁵
hamsters[i] is either 'H' or '.'
Each hamster must be fed by at least one adjacent bucket
Food buckets can only be placed in empty positions ('.')

Visualization

Tap to expand

Understanding the Visualization

Scan the Street

Walk from left to right, checking each house (hamster)

Smart Light Placement

When you find a dark house, place the light to illuminate maximum future houses

Avoid Redundancy

Skip houses that are already illuminated by previous lights

Handle Impossible Cases

Some configurations (like adjacent houses with no space) are impossible to light

Key Takeaway

🎯 Key Insight: The greedy approach works because placing a bucket to the right (when possible) never makes the solution worse, and often makes it better by potentially feeding future hamsters.

Asked in

f Facebook 45 a Amazon 38 G Google 32 ⊞ Microsoft 28

The optimal solution uses a greedy algorithm that scans left to right, placing food buckets optimally when encountering unfed hamsters. The key insight is to always prefer placing buckets to the right side, as this can potentially feed future hamsters, minimizing the total count. Time complexity: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n)	O(n)	Try every possible combination of bucket placements and find the minimum that works
Greedy Algorithm (Optimal)	O(n)	O(1)	Scan left to right, placing buckets optimally when needed

Brute Force (Try All Combinations) — Algorithm Steps

Find all empty positions where buckets can be placed
Generate all possible combinations of bucket placements
For each combination, check if all hamsters are fed
Keep track of the minimum number of buckets that works
Return the minimum or -1 if no combination works

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Empty Positions

Find all positions where buckets can be placed (marked with '.')

Generate Combinations

Create all possible ways to place 0, 1, 2, ... buckets

Check Each Combination

For each combination, verify if all hamsters can be fed

Return Minimum

Return the smallest number of buckets that works

Code -

solution.c — C

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

bool canFeedAll(int* bucketPositions, int numBuckets, char* hamsters, int len) {
    bool* buckets = calloc(len, sizeof(bool));
    for (int i = 0; i < numBuckets; i++) {
        buckets[bucketPositions[i]] = true;
    }
    
    for (int i = 0; i < len; i++) {
        if (hamsters[i] == 'H') {
            bool canFeed = false;
            if (i > 0 && buckets[i-1]) canFeed = true;
            if (i < len-1 && buckets[i+1]) canFeed = true;
            if (!canFeed) {
                free(buckets);
                return false;
            }
        }
    }
    free(buckets);
    return true;
}

bool tryAllCombinations(int* positions, int totalPos, int k, int start, int* current, char* hamsters, int len) {
    if (k == 0) {
        return canFeedAll(current, 0, hamsters, len);
    }
    
    for (int i = start; i <= totalPos - k; i++) {
        current[0] = positions[i];
        if (tryAllCombinations(positions, totalPos, k-1, i+1, current+1, hamsters, len)) {
            return true;
        }
    }
    return false;
}

int minimumBuckets(char* hamsters) {
    int len = strlen(hamsters);
    int* emptyPositions = malloc(len * sizeof(int));
    int numEmpty = 0;
    
    for (int i = 0; i < len; i++) {
        if (hamsters[i] == '.') {
            emptyPositions[numEmpty++] = i;
        }
    }
    
    int* current = malloc(numEmpty * sizeof(int));
    
    for (int numBuckets = 0; numBuckets <= numEmpty; numBuckets++) {
        if (tryAllCombinations(emptyPositions, numEmpty, numBuckets, 0, current, hamsters, len)) {
            free(emptyPositions);
            free(current);
            return numBuckets;
        }
    }
    
    free(emptyPositions);
    free(current);
    return -1;
}

int main() {
    char hamsters[1001];
    fgets(hamsters, sizeof(hamsters), stdin);
    
    // Remove newline and quotes
    hamsters[strcspn(hamsters, "\n")] = 0;
    if (hamsters[0] == '"') {
        memmove(hamsters, hamsters+1, strlen(hamsters));
        hamsters[strlen(hamsters)-1] = 0;
    }
    
    printf("%d\n", minimumBuckets(hamsters));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We try all 2^n possible combinations of placing buckets in empty positions

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for the input string and temporary combinations

⚡ Linearithmic Space

34.2K Views

Medium-High Frequency

~18 min Avg. Time

1.4K 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler