# 2604. Minimum Time to Eat All Grains

## Problem Description

In this problem, we are given two arrays representing the positions of `n` hens (`hens`) and `m` grains (`grains`) on a line respectively. The goal is to calculate the minimum time required for all hens to eat all the grains, assuming each hen can move one unit left or right in one second. Hens can move simultaneously and independently, and a hen can eat any grain if they share the same position on the line. Importantly, there's no limit to how many grains a single hen can eat, they just need to be at the same position. The question asks for the optimal strategy that minimizes the time for all the grains to be eaten.

## Intuition

The intuition behind the solution involves recognizing that since hens can move independently and multiple hens can eat from the same pile of grains, we want to minimize the distance each hen needs to move. To find the minimum time, we can use a binary search strategy, where the search space is the time it takes for the hens to eat all the grains. We are essentially asking "Can all grains be eaten within `t` seconds?" for various values of `t`.

The solution approach uses binary search to minimize the time by trying to find the smallest `t` such that all conditions are satisfied - which involves checking whether the hens can eat all grains within that time frame.

To facilitate the binary search check, we sort both the hens and grains because only the relative positions matter, not the specific values. After sorting, we iterate through each hen and determine if it can eat the available grains within `t` seconds. If a hen at position `x` encounters a grain at position `y`, and `y` is to the left of `x` (`y <= x`), then the hen can eat the grain if it can reach it within `t` seconds (`x - y <= t`). If the grain is to the right of the hen (`y > x`), then we check if the hen can reach it within `t` seconds (`y - x <= t`). If during this check for all hens, we find that all grains have been accounted for within `t` seconds, we consider it successful.

It's critical that this checking function is efficient because it is called many times during binary search. By moving our "grain pointer" `j` only to the right, we ensure we don't do redundant checks, thus optimizing the process.

## Solution Approach

In the implementation, our main goal is to determine the minimum time `t`, using binary search, during which all hens can eat all grains. To start, we need a `check(t)` function that takes `t` as an input and returns `True` if all grains can be eaten by hens within `t` seconds, else it returns `False`.

Here's a step-by-step breakdown of the `check(t)` function:

1. Sort both `hens` and `grains` in ascending order to efficiently pair hens with the nearest grains.

2. Use a variable `j` to keep track of the next grain to be checked.

3. Loop through each hen positioned at `x`, and for each, attempt to eat the grain located at `grains[j]`, which is `y`.

4. For each hen, check the position of the grain relative to the hen's position. There are two cases:

• If the grain is to the left of or at the hen's position (`y <= x`):
• Calculate the distance `d = x - y`. If `d > t`, `False` is returned, because the hen can't reach the grain within `t` seconds.
• Iterate over `grains` starting from `j` to the right, moving `j` forward as long as the distance for the hen to return from the grain to its original position and then to the next grain is less than or equal to `t`.
• If the grain is to the right of the hen (`y > x`):
• Increment `j` to the right as long as the distance from the hen to the next grain is less than or equal to `t`.
5. If by the end of this process `j == m`, which means all grains have been visited, return `True`. Otherwise, return `False`.

Now, this check over all possible hens and grains determines if it's feasible for all hens to eat all grains in `t` seconds. By running this check function within a binary search over the range being considered for `t`, which is [0, r], where `r` is an initially large range to cover all possible time scenarios, we can efficiently home in on the smallest `t` that returns `True`.

In Python's `bisect` module, `bisect_left` is used, which returns the index of the first item in the sorted array that is greater than or equal to the specified value. Here, that specified value is `True`, meaning we're searching for the smallest `t` where `check` returns `True`.

The binary search continues to adjust this range until the lower bound meets the criteria, which is the minimum time `t` that guarantees all grains are eaten.

This solution is efficient and leverages the capabilities of sorting and binary search to reduce an otherwise complicated simulation problem down to a manageable and computationally viable process.

### Example Walkthrough

Let's walk through a small example to illustrate the solution approach. Suppose we have `n = 2` hens and `m = 3` grains, with the hens positioned at `hens = [1, 4]` and the grains at `grains = [2, 3, 5]` on the line.

Firstly, we sort both arrays for efficient processing:

• Hens: `hens = [1, 4]` (already sorted)
• Grains: `grains = [2, 3, 5]` (already sorted)

Now we will define a range for our binary search. The maximum possible time `t` would be if the furthest grain is directly opposite the furthest hen, which in this case would be the hen at position `4` and the grain at position `5`, thus maximum time `t_max = 1`. We begin with `t` ranging from 0 to `t_max`.

We then start our binary search:

1. Middle of our range (`t = 0`) is checked first to see if it is possible for hens to eat all grains in `0` seconds, which is clearly not possible because the hens and grains are not at the same positions. Thus, `check(0)` returns `False`.

2. Since `t = 0` is not enough time, we need to increase `t`. The next value we check is `t = 1`, which is the midpoint of the updated range [1, 1]. We run `check(1)`:

• The first hen at position `1` can reach and eat the grain at position `2` within `1` second.
• The second hen at position `4` can reach and eat the grain at position `5` within `1` second. It can also backtrack to eat the grain at position `3` after eating the grain at position `5`.

After simulating the process, we find that all the grains can be eaten within `1` second. Thus, `check(1)` returns `True`.

Since `check(1)` returns `True`, we have found our solution: all hens can eat all grains in a minimum time of `1` second. There's no need to continue the binary search because we can't find a smaller non-negative value of `t` that satisfies the conditions.

To summarize with our example, we used binary search to determine that `1` second is the minimum time required for the hens at positions `1` and `4` to eat all grains at positions `2`, `3`, and `5`. This demonstrates the effectiveness of sorting and binary search in finding the optimal solution for the problem.

## Python Solution

``````1from bisect import bisect_left
2from typing import List
3
4class Solution:
5    def minimumTime(self, hens: List[int], grains: List[int]) -> int:
6        # Helper function to check if all grains can be picked within time 't'
7        # It simulates the picking process for a given time 't' and returns True if possible, False otherwise
8        def can_pick_all(t: int) -> bool:
10            m = len(grains)
11            for hen in hens:
12                if grain_index == m:
13                    return True  # All grains have been picked
14                next_grain = grains[grain_index]
15                if next_grain <= hen:
16                    diff = hen - next_grain
17                    if diff > t:
18                        return False  # hen is too far from the grain to pick it within time 't'
19                    while grain_index < m and grains[grain_index] <= hen:
20                        grain_index += 1
21                    while grain_index < m and min(diff, grains[grain_index] - hen) + grains[grain_index] - next_grain <= t:
22                        grain_index += 1
23                else:
24                    # The hen will pick the grains until it is closer to them than time 't'
25                    while grain_index < m and grains[grain_index] - hen <= t:
26                        grain_index += 1
27            return grain_index == m  # Check if all grains are picked
28
29        # Sort both hens and grains lists to make it easier to process them in order
30        hens.sort()
31        grains.sort()
32
33        # Compute the initial range for 't', which can be up to the furthest distance a hen might need to travel
34        range_max = abs(hens - grains) + grains[-1] - grains + 1
35
36        # Find the minimum time within which all grains can be picked using binary search
37        minimum_time = bisect_left(range(range_max), True, key=can_pick_all)
38
39        return minimum_time
40``````

## Java Solution

``````1import java.util.Arrays;
2
3class Solution {
4    private int[] hensPositions;
5    private int[] grainPositions;
6    private int totalGrains;
7
8    public int minimumTime(int[] hens, int[] grains) {
9        totalGrains = grains.length;
10        hensPositions = hens;
11        grainPositions = grains;
12        Arrays.sort(hensPositions);
13        Arrays.sort(grainPositions);
14
15        // Set the initial range of time to search for the minimum time needed.
16        // It's between 0 and the maximum possible distance a hen needs to travel minus the first gain position.
17        int left = 0;
18        int right = Math.abs(hensPositions - grainPositions) + grainPositions[totalGrains - 1] - grainPositions;
19
20        // Use binary search to find the minimum time needed.
21        while (left < right) {
22            int mid = (left + right) / 2;
23            if (isTimeSufficient(mid)) {
24                right = mid;
25            } else {
26                left = mid + 1;
27            }
28        }
29
30        // 'left' will hold the minimum time needed when the while-loop finishes.
31        return left;
32    }
33
34    private boolean isTimeSufficient(int allowedTime) {
35        int grainIndex = 0;
36
37        // Check if the time allowed is sufficient for each hen.
38        for (int henPosition : hensPositions) {
39            // If all grains have been checked, return true.
40            if (grainIndex == totalGrains) {
41                return true;
42            }
43
44            int grainPosition = grainPositions[grainIndex];
45            if (grainPosition <= henPosition) {
46                int distance = henPosition - grainPosition;
47                if (distance > allowedTime) {
48                    // If the current grain is too far for the time allowed, return false.
49                    return false;
50                }
51
52                // Find the next grain that is farther than the hen but within the allowed time.
53                while (grainIndex < totalGrains && grainPositions[grainIndex] <= henPosition) {
54                    grainIndex++;
55                }
56
57                // Attempt to get as close as possible to the current hen position without exceeding the allowed time.
58                while (grainIndex < totalGrains && Math.min(distance, grainPositions[grainIndex] - henPosition) + grainPositions[grainIndex] - grainPosition <= allowedTime) {
59                    grainIndex++;
60                }
61            } else {
62                // Find the grain that is within the allowed time for the current hen.
63                while (grainIndex < totalGrains && grainPositions[grainIndex] - henPosition <= allowedTime) {
64                    grainIndex++;
65                }
66            }
67        }
68
69        // Return true if all grains have been assigned, false otherwise.
70        return grainIndex == totalGrains;
71    }
72}
73``````

## C++ Solution

``````1#include <vector>
2#include <algorithm>
3
4class Solution {
5public:
6    // This method computes the minimum time needed for all hens to eat grains
7    // given their positions and the positions of the grains.
8    int minimumTime(vector<int>& hens, vector<int>& grains) {
9        // Sort the hens and grains in non-decreasing order
10        sort(hens.begin(), hens.end());
11        sort(grains.begin(), grains.end());
12
13        int numberOfGrains = grains.size();
14
15        // Setup the binary search boundaries
16        // The starting left boundary 'l' is set to 0 indicating the lowest possible time
17        // The starting right boundary 'r' is based on the furthest possible distance a hen
18        // might need to travel, which is from the first hen to the first grain location plus
19        // from the first grain location to the last grain location
20        int leftBoundary = 0;
21        int rightBoundary = abs(hens - grains) + grains[numberOfGrains - 1] - grains;
22
23        // Define the check loop as a lambda function to determine if a given time 't' is sufficient
24        auto check = [&](int time) -> bool {
25            int grainIndex = 0;
26            for (int henPos : hens) {
27                if (grainIndex == numberOfGrains) {
28                    return true;
29                }
30                int grainPos = grains[grainIndex];
31                if (grainPos <= henPos) {
32                    int distance = henPos - grainPos;
33                    if (distance > time) {
34                        return false;
35                    }
36                    // Move the grain index to the next grain past the current hen position
37                    while (grainIndex < numberOfGrains && grains[grainIndex] <= henPos) {
38                        ++grainIndex;
39                    }
40                    // Keep moving the grain index as long as the hen can reach the grain within the 'time'
41                    while (grainIndex < numberOfGrains && min(distance, grains[grainIndex] - henPos) +
42                           grains[grainIndex] - grainPos <= time) {
43                        ++grainIndex;
44                    }
45                } else {
46                    // Move the grain index as long as the hen can reach the grain within the 'time'
47                    while (grainIndex < numberOfGrains && grains[grainIndex] - henPos <= time) {
48                        ++grainIndex;
49                    }
50                }
51            }
52            // If we've assigned a grain to each hen within the time, return true
53            return grainIndex == numberOfGrains;
54        };
55
56        // Perform a binary search to find the minimum time required
57        while (leftBoundary < rightBoundary) {
58            int midTime = (leftBoundary + rightBoundary) / 2;
59            if (check(midTime)) {
60                // If midTime is enough for all hens to eat, try to find a smaller time
61                rightBoundary = midTime;
62            } else {
63                // If midTime is not enough, ignore the left half
64                leftBoundary = midTime + 1;
65            }
66        }
67        // Return the smallest time in which all hens can eat
68        return leftBoundary;
69    }
70};
71``````

## Typescript Solution

``````1function minimumTime(hens: number[], grains: number[]): number {
2    // Sort both hens and grains arrays in ascending order
3    hens.sort((a, b) => a - b);
4    grains.sort((a, b) => a - b);
5
6    const grainCount = grains.length;
7    // The range of possible minimum times starts at 0 and extends up to a logical upper bound
8    let lowerBound = 0;
9    let upperBound = Math.abs(hens - grains) + grains[grainCount - 1] - grains + 1;
10
11    // A helper function that checks if all hens can eat grains within the time 'timeLimit'
12    const canFeedWithinTimeLimit = (timeLimit: number): boolean => {
13        let grainIndex = 0;
14        for (const henPosition of hens) {
15            if (grainIndex === grainCount) {
16                // If all grains have been used, return true
17                return true;
18            }
19            const grainPosition = grains[grainIndex];
20            if (grainPosition <= henPosition) {
21                // Compute distance from hen to grain
22                const distance = henPosition - grainPosition;
23                if (distance > timeLimit) {
24                    // Hen can't reach grain within the time limit
25                    return false;
26                }
27                // Move up to the closest grain that the hen can reach within the time limit
28                while (grainIndex < grainCount && grains[grainIndex] <= henPosition) {
29                    grainIndex++;
30                }
31                // Move up to the grain that can be eaten in the optimal time
32                while (grainIndex < grainCount && Math.min(distance, grains[grainIndex] - henPosition) + grains[grainIndex] - grainPosition <= timeLimit) {
33                    grainIndex++;
34                }
35            } else {
36                // Move up to the grain that the hen can eat within the time limit
37                while (grainIndex < grainCount && grains[grainIndex] - henPosition <= timeLimit) {
38                    grainIndex++;
39                }
40            }
41        }
42        // Check if all grains are distributed
43        return grainIndex === grainCount;
44    };
45
46    // Perform a binary search to find the minimum time needed
47    while (lowerBound < upperBound) {
48        const mid = (lowerBound + upperBound) >> 1;
49        if (canFeedWithinTimeLimit(mid)) {
50            // If it's possible to feed within this time frame, search the lower half
51            upperBound = mid;
52        } else {
53            // Otherwise, search the upper half
54            lowerBound = mid + 1;
55        }
56    }
57
58    // Return the smallest time within which all hens can eat
59    return lowerBound;
60}
61``````

## Time and Space Complexity

### Time Complexity

The time complexity of the given code can be analyzed as follows:

1. Sorting both the `hens` and `grains` lists: `hens.sort()` and `grains.sort()` both have a time complexity of `O(n \log n)` and `O(m \log m)` respectively, where `n` is the number of hens and `m` is the number of grains.

2. Binary search: The `bisect_left` function performs binary search on a range of size `r`. The size of this range can be considered as `U` because it is determined by the maximum gap between positions of grains. Since it performs the check function at each step of the binary search, the time it takes is `O(\log U)` for the binary search times the complexity of the `check` function itself.

3. `check` function: Inside the binary search, the `check` function is called, which runs in `O(m + n)` because it goes through all grains and potentially all hens in the worst case.

Combining these factors, we get a total time complexity of `O(n \log n + m \log m + (m + n) \log U)`.

### Space Complexity

The space complexity of the given code can be analyzed as follows:

1. Sorting requires `O(1)` additional space if the sort is in-place (which Python's `sort` method is, for example).

2. The binary search uses `O(1)` space.

3. The `check` function uses `O(1)` space since it only uses a few variables and all operations are done in place.

Adding these up, we get a space complexity of `O(\log m + \log n)` for the recursion stack of the sorting algorithms if the sort implementation used is not in-place.

Got a question? Ask the Teaching Assistant anything you don't understand.

Still not clear? Ask in the Forum,  Discord or Submit the part you don't understand to our editors.

TA 👨‍🏫