Minimum Time to Eat All Grains

Minimum Time to Eat All Grains - Problem

There are n hens and m grains on a line. You are given the initial positions of the hens and the grains in two integer arrays hens and grains of size n and m respectively.

Any hen can eat a grain if they are on the same position. The time taken for this is negligible. One hen can also eat multiple grains. In 1 second, a hen can move right or left by 1 unit. The hens can move simultaneously and independently of each other.

Return the minimum time to eat all grains if the hens act optimally.

Input & Output

Example 1 — Basic Assignment

$ Input: hens = [3,6], grains = [2,4,7,9]

› Output: 3

💡 Note: Hen at position 3 eats grains at [2,4] (time = |3-2| + |4-2| = 3), hen at position 6 eats grains at [7,9] (time = |6-7| + |9-7| = 3). Maximum time is 3.

Example 2 — Single Hen

$ Input: hens = [5], grains = [1,3,7]

› Output: 8

💡 Note: Single hen at 5 must eat all grains [1,3,7]. To collect all grains from position 1 to 7, hen can go left first (time = |5-1| + |7-1| = 4 + 6 = 10) or right first (time = |5-7| + |7-1| = 2 + 6 = 8). The minimum time is 8.

Example 3 — No Grains

$ Input: hens = [1,2,3], grains = []

› Output: 0

💡 Note: No grains to eat, so time required is 0.

Constraints

1 ≤ hens.length ≤ 20
1 ≤ grains.length ≤ 20
-10⁹ ≤ hens[i], grains[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 A Amazon 8

The key insight is to use binary search on the answer combined with dynamic programming to check feasibility. We binary search on the maximum time and use DP to verify if all grains can be assigned to hens within that time limit. Best approach is Binary Search + DP with Time: O(nm log(max_distance)), Space: O(nm).

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(nm log(max_distance)) Space: O(nm)

Binary search on the answer (maximum time). For each candidate time, use dynamic programming to check if it's possible to assign all grains to hens within that time limit.

Brute Force - Try All Assignments

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

For each possible assignment of grains to hens, calculate the time each hen needs and take the maximum. Try all assignments to find the global minimum.

Binary Search on Answer — Algorithm Steps

Sort both hens and grains arrays
Binary search on the maximum time (0 to max distance)
For each time, use DP to check if assignment is possible
Return the minimum feasible time

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search Setup

Set search range from 0 to maximum possible time

DP Feasibility Check

For each candidate time, check if assignment is possible

Narrow Range

Update search range based on feasibility result

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.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;
}

bool canAssign(int* hens, int hensSize, int* grains, int grainsSize, int maxTime) {
    bool dp[101][101];
    memset(dp, false, sizeof(dp));
    dp[0][0] = true;
    
    for (int i = 1; i <= hensSize; i++) {
        dp[i][0] = true;
        for (int j = 1; j <= grainsSize; j++) {
            dp[i][j] = dp[i-1][j];
            
            for (int k = 0; k < j; k++) {
                if (dp[i-1][k]) {
                    int timeNeeded = min_val(
                        abs_val(hens[i-1] - grains[k]) + abs_val(grains[j-1] - grains[k]),
                        abs_val(hens[i-1] - grains[j-1]) + abs_val(grains[j-1] - grains[k])
                    );
                    if (timeNeeded <= maxTime) {
                        dp[i][j] = true;
                        break;
                    }
                }
            }
        }
    }
    
    return dp[hensSize][grainsSize];
}

int solution(int* hens, int hensSize, int* grains, int grainsSize) {
    if (grainsSize == 0) return 0;
    
    qsort(hens, hensSize, sizeof(int), compare);
    qsort(grains, grainsSize, sizeof(int), compare);
    
    int left = 0;
    int right = abs_val(hens[0] - grains[grainsSize-1]) + abs_val(grains[grainsSize-1] - grains[0]);
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (canAssign(hens, hensSize, grains, grainsSize, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

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() {
    int hens[100], grains[100];
    int hensSize = 0, grainsSize = 0;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        hens[hensSize++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[],\n ");
    while (token != NULL) {
        grains[grainsSize++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", solution(hens, hensSize, grains, grainsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(nm log(max_distance))

Binary search log(max_distance) iterations, each taking O(nm) for DP check

✓ Linear Growth

Space Complexity

O(nm)

DP table to store assignment possibilities

✓ Linear Space

25.0K Views

Medium Frequency

~35 min Avg. Time

890 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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler