Given an array stalls[] which denotes the position of a stall and an integer k which denotes the number of aggressive cows. The task is to assign stalls to k cows such that the minimum distance between any two of them is the maximum possible.
Examples:
Input: stalls[] = [1, 2, 4, 8, 9], k = 3
Output: 3
Explanation: We can place cow 1 at position 1, cow 2 at position 4 and cow 3 at position 9. So, the maximum possible minimum distance between two cows is 3.
Input: stalls[] = [6, 7, 9, 11, 13, 15], k = 4
Output: 2
Explanation: We can place cow 1 at position 6, cow 2 at position 9, cow 3 at position 11 and cow 4 at position 15. So, the maximum possible minimum distance between two cows is 2.
[Naive Approach] By iterating over all possible distances
The idea is to iterate over all possible distances starting from 1 up to the difference between the farthest stalls. First, we sort the array to ensure the stalls are in the correct sequence. Then, for each distance, we try to place the cows greedily - placing the first cow in the first stall and the next ones only if the gap from the last placed cow is at least the current distance. If all cows can be placed for a certain distance, we update our result. The process continues until all distances are checked.
C++
// C++ program to find maximum possible minimum distance
// between any two cows by iterating over all distances
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// function to check if we can place k cows
// with at least dist distance apart
bool check(vector<int> &stalls, int k, int dist) {
// Place first cow at 0th index
int cnt = 1;
int prev = stalls[0];
for (int i = 1; i < stalls.size(); i++) {
// If the current stall is at least dist away
// from the previous one place the cow here
if (stalls[i] - prev >= dist) {
prev = stalls[i];
cnt++;
}
}
// Return true if we are able to place all 'k' cows
return (cnt >= k);
}
int aggressiveCows(vector<int> &stalls, int k) {
// sorting the array to ensure stalls in sequence
sort(stalls.begin(), stalls.end());
int res = 0;
// Minimum and maximum possible minimum distance
// between two stalls
int minDist = 1;
int maxDist = stalls.back() - stalls[0];
// Iterating through all possible distances
for (int i = minDist; i <= maxDist; i++) {
// If we can place k cows with the
// current distance i, update the res
if (check(stalls, k, i))
res = i;
}
return res;
}
int main() {
vector<int> stalls = {1, 2, 4, 8, 9};
int k = 3;
int ans = aggressiveCows(stalls, k);
cout << ans;
return 0;
}
// C program to find maximum possible minimum distance
// between any two cows by iterating over all distances
#include <stdio.h>
#include <stdlib.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
// function to check if we can place k cows
// with at least dist distance apart
int check(int stalls[], int size, int k, int dist) {
// Place first cow at 0th index
int cnt = 1;
int prev = stalls[0];
for (int i = 1; i < size; i++) {
// If the current stall is at least dist away
// from the previous one place the cow here
if (stalls[i] - prev >= dist) {
prev = stalls[i];
cnt++;
}
}
// Return true if we are able to place all 'k' cows
return (cnt >= k);
}
int aggressiveCows(int stalls[], int size, int k) {
// sorting the array to ensure stalls in sequence
qsort(stalls, size, sizeof(int), (int (*)(const void *, const void *))compare);
int res = 0;
// Minimum and maximum possible minimum distance
// between two stalls
int minDist = 1;
int maxDist = stalls[size - 1] - stalls[0];
// Iterating through all possible distances
for (int i = minDist; i <= maxDist; i++) {
// If we can place k cows with the
// current distance i, update the res
if (check(stalls, size, k, i))
res = i;
}
return res;
}
int main() {
int stalls[] = {1, 2, 4, 8, 9};
int k = 3;
int size = sizeof(stalls) / sizeof(stalls[0]);
int ans = aggressiveCows(stalls, size, k);
printf("%d\n", ans);
return 0;
}
// Java program to find maximum possible minimum distance
// between any two cows by iterating over all distances
import java.util.Arrays;
class GfG {
// function to check if we can place k cows
// with at least dist distance apart
static boolean check(int[] stalls, int k, int dist) {
// Place first cow at 0th index
int cnt = 1;
int prev = stalls[0];
for (int i = 1; i < stalls.length; i++) {
// If the current stall is at least dist away
// from the previous one place the cow here
if (stalls[i] - prev >= dist) {
prev = stalls[i];
cnt++;
}
}
// Return true if we are able to place all 'k' cows
return (cnt >= k);
}
static int aggressiveCows(int[] stalls, int k) {
// sorting the array to ensure stalls in sequence
Arrays.sort(stalls);
int res = 0;
// Minimum and maximum possible minimum distance
// between two stalls
int minDist = 1;
int maxDist = stalls[stalls.length - 1] - stalls[0];
// Iterating through all possible distances
for (int i = minDist; i <= maxDist; i++) {
// If we can place k cows with the
// current distance i, update the res
if (check(stalls, k, i))
res = i;
}
return res;
}
public static void main(String[] args) {
int[] stalls = {1, 2, 4, 8, 9};
int k = 3;
int ans = aggressiveCows(stalls, k);
System.out.println(ans);
}
}
# Python program to find maximum possible minimum distance
# between any two cows by iterating over all distances
# function to check if we can place k cows
# with at least dist distance apart
def check(stalls, k, dist):
# Place first cow at 0th index
cnt = 1
prev = stalls[0]
for i in range(1, len(stalls)):
# If the current stall is at least dist away
# from the previous one place the cow here
if stalls[i] - prev >= dist:
prev = stalls[i]
cnt += 1
# Return true if we are able to place all 'k' cows
return cnt >= k
def aggressiveCows(stalls, k):
# sorting the array to ensure stalls in sequence
stalls.sort()
res = 0
# Minimum and maximum possible minimum distance
# between two stalls
minDist = 1
maxDist = stalls[-1] - stalls[0]
# Iterating through all possible distances
for i in range(minDist, maxDist + 1):
# If we can place k cows with the
# current distance i, update the res
if check(stalls, k, i):
res = i
return res
if __name__ == "__main__":
stalls = [1, 2, 4, 8, 9]
k = 3
ans = aggressiveCows(stalls, k)
print(ans)
// C# program to find maximum possible minimum distance
// between any two cows by iterating over all distances
using System;
class GfG {
// function to check if we can place k cows
// with at least dist distance apart
static bool check(int[] stalls, int k, int dist) {
// Place first cow at 0th index
int cnt = 1;
int prev = stalls[0];
for (int i = 1; i < stalls.Length; i++) {
// If the current stall is at least dist away
// from the previous one place the cow here
if (stalls[i] - prev >= dist) {
prev = stalls[i];
cnt++;
}
}
// Return true if we are able to place all 'k' cows
return (cnt >= k);
}
static int aggressiveCows(int[] stalls, int k) {
// sorting the array to ensure stalls in sequence
Array.Sort(stalls);
int res = 0;
// Minimum and maximum possible minimum distance
// between two stalls
int minDist = 1;
int maxDist = stalls[stalls.Length - 1] - stalls[0];
// Iterating through all possible distances
for (int i = minDist; i <= maxDist; i++) {
// If we can place k cows with the
// current distance i, update the res
if (check(stalls, k, i))
res = i;
}
return res;
}
static void Main() {
int[] stalls = {1, 2, 4, 8, 9};
int k = 3;
int ans = aggressiveCows(stalls, k);
Console.WriteLine(ans);
}
}
// JavaScript program to find maximum possible minimum distance
// between any two cows by iterating over all distances
// function to check if we can place k cows
// with at least dist distance apart
function check(stalls, k, dist) {
// Place first cow at 0th index
let cnt = 1;
let prev = stalls[0];
for (let i = 1; i < stalls.length; i++) {
// If the current stall is at least dist away
// from the previous one place the cow here
if (stalls[i] - prev >= dist) {
prev = stalls[i];
cnt++;
}
}
// Return true if we are able to place all 'k' cows
return (cnt >= k);
}
function aggressiveCows(stalls, k) {
// sorting the array to ensure stalls in sequence
stalls.sort((a, b) => a - b);
let res = 0;
// Minimum and maximum possible minimum distance
// between two stalls
let minDist = 1;
let maxDist = stalls[stalls.length - 1] - stalls[0];
// Iterating through all possible distances
for (let i = minDist; i <= maxDist; i++) {
// If we can place k cows with the
// current distance i, update the res
if (check(stalls, k, i))
res = i;
}
return res;
}
let stalls = [1, 2, 4, 8, 9];
let k = 3;
let ans = aggressiveCows(stalls, k);
console.log(ans);
Time Complexity: O(n*(MAX - MIN)), where n is the size of the array, MAX is the maximum element in the array and MIN is minimum element in the array.
Auxiliary Space: O(1).
[Expected Approach] Using Binary Search
The minimum distance between the cows has a monotonic property.
- If we can place all the cows with a minimum distance d, then we can also place them with any smaller distance than d. The reason is by reducing the minimum gap, we can place more number of cows as lower gaps allow us to place cows even more closer.
- If we can't place all the cows with a minimum distance d, then we can't place them with any larger distance than d. The reason is if the gap is already too large to place the cows, then larger gap will also not work.
Therefore, we can use binary search to find the maximum possible minimum distance, and to check the for any distance, we place the first cow in the first stall and the next ones only if the gap from the last placed cow is at least that distance. If all cows can be placed for a certain distance, then it is a feasible distance.
C++
// C++ program to find maximum possible minimum distance
// between any two cows using binary search
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// function to check if we can place k cows
// with at least dist distance apart
bool check(vector<int> &stalls, int k, int dist) {
// Place first cow at 0th index
int cnt = 1;
int prev = stalls[0];
for (int i = 1; i < stalls.size(); i++) {
// If the current stall is at least dist away
// from the previous one place the cow here
if (stalls[i] - prev >= dist) {
prev = stalls[i];
cnt++;
}
}
// Return true if we are able to place all 'k' cows
return (cnt >= k);
}
int aggressiveCows(vector<int> &stalls, int k) {
// sorting the array to ensure stalls in sequence
sort(stalls.begin(), stalls.end());
int res = 0;
// Search Space for Binary Search
int lo = 1;
int hi = stalls.back() - stalls[0];
while(lo <= hi) {
int mid = lo + (hi - lo)/2;
// If the mid ditance is possible, update
// the result and search for larger ditance
if(check(stalls, k, mid)) {
res = mid;
lo = mid + 1;
}
else {
hi = mid - 1;
}
}
return res;
}
int main() {
vector<int> stalls = {1, 2, 4, 8, 9};
int k = 3;
int ans = aggressiveCows(stalls, k);
cout << ans;
return 0;
}
// C program to find maximum possible minimum distance
// between any two cows using binary search
#include <stdio.h>
int compare(const void *a, const void *b) {
return (*(int*)a - *(int*)b);
}
// function to check if we can place k cows
// with at least dist distance apart
int check(int stalls[], int n, int k, int dist) {
// Place first cow at 0th index
int cnt = 1;
int prev = stalls[0];
for (int i = 1; i < n; i++) {
// If the current stall is at least dist away
// from the previous one place the cow here
if (stalls[i] - prev >= dist) {
prev = stalls[i];
cnt++;
}
}
// Return true if we are able to place all 'k' cows
return (cnt >= k);
}
int aggressiveCows(int stalls[], int n, int k) {
// sorting the array to ensure stalls in sequence
qsort(stalls, n, sizeof(int), compare);
int res = 0;
// Search Space for Binary Search
int lo = 1;
int hi = stalls[n - 1] - stalls[0];
while(lo <= hi) {
int mid = lo + (hi - lo) / 2;
// If the mid distance is possible, update
// the result and search for larger distance
if(check(stalls, n, k, mid)) {
res = mid;
lo = mid + 1;
}
else {
hi = mid - 1;
}
}
return res;
}
int main() {
int stalls[] = {1, 2, 4, 8, 9};
int k = 3;
int n = sizeof(stalls) / sizeof(stalls[0]);
int ans = aggressiveCows(stalls, n, k);
printf("%d\n", ans);
return 0;
}
// Java program to find maximum possible minimum distance
// between any two cows using binary search
import java.util.Arrays;
class GfG {
// function to check if we can place k cows
// with at least dist distance apart
static boolean check(int[] stalls, int k, int dist) {
// Place first cow at 0th index
int cnt = 1;
int prev = stalls[0];
for (int i = 1; i < stalls.length; i++) {
// If the current stall is at least dist away
// from the previous one place the cow here
if (stalls[i] - prev >= dist) {
prev = stalls[i];
cnt++;
}
}
// Return true if we are able to place all 'k' cows
return (cnt >= k);
}
static int aggressiveCows(int[] stalls, int k) {
// sorting the array to ensure stalls in sequence
Arrays.sort(stalls);
int res = 0;
// Search Space for Binary Search
int lo = 1;
int hi = stalls[stalls.length - 1] - stalls[0];
while(lo <= hi) {
int mid = lo + (hi - lo) / 2;
// If the mid distance is possible, update
// the result and search for larger distance
if(check(stalls, k, mid)) {
res = mid;
lo = mid + 1;
}
else {
hi = mid - 1;
}
}
return res;
}
public static void main(String[] args) {
int[] stalls = {1, 2, 4, 8, 9};
int k = 3;
int ans = aggressiveCows(stalls, k);
System.out.println(ans);
}
}
# Python program to find maximum possible minimum distance
# between any two cows using binary search
def check(stalls, k, dist):
# Place first cow at 0th index
cnt = 1
prev = stalls[0]
for i in range(1, len(stalls)):
# If the current stall is at least dist away
# from the previous one place the cow here
if stalls[i] - prev >= dist:
prev = stalls[i]
cnt += 1
# Return true if we are able to place all 'k' cows
return cnt >= k
def aggressiveCows(stalls, k):
# sorting the array to ensure stalls in sequence
stalls.sort()
res = 0
# Search Space for Binary Search
lo = 1
hi = stalls[-1] - stalls[0]
while lo <= hi:
mid = lo + (hi - lo) // 2
# If the mid distance is possible, update
# the result and search for larger distance
if check(stalls, k, mid):
res = mid
lo = mid + 1
else:
hi = mid - 1
return res
if __name__ == "__main__":
stalls = [1, 2, 4, 8, 9]
k = 3
ans = aggressiveCows(stalls, k)
print(ans)
// C# program to find maximum possible minimum distance
// between any two cows using binary search
using System;
class GfG {
// function to check if we can place k cows
// with at least dist distance apart
static bool check(int[] stalls, int k, int dist) {
// Place first cow at 0th index
int cnt = 1;
int prev = stalls[0];
for (int i = 1; i < stalls.Length; i++) {
// If the current stall is at least dist away
// from the previous one place the cow here
if (stalls[i] - prev >= dist) {
prev = stalls[i];
cnt++;
}
}
// Return true if we are able to place all 'k' cows
return (cnt >= k);
}
static int aggressiveCows(int[] stalls, int k) {
// sorting the array to ensure stalls in sequence
Array.Sort(stalls);
int res = 0;
// Search Space for Binary Search
int lo = 1;
int hi = stalls[stalls.Length - 1] - stalls[0];
while(lo <= hi) {
int mid = lo + (hi - lo) / 2;
// If the mid distance is possible, update
// the result and search for larger distance
if(check(stalls, k, mid)) {
res = mid;
lo = mid + 1;
}
else {
hi = mid - 1;
}
}
return res;
}
static void Main() {
int[] stalls = {1, 2, 4, 8, 9};
int k = 3;
int ans = aggressiveCows(stalls, k);
Console.WriteLine(ans);
}
}
// JavaScript program to find maximum possible minimum distance
// between any two cows using binary search
function check(stalls, k, dist) {
// Place first cow at 0th index
let cnt = 1;
let prev = stalls[0];
for (let i = 1; i < stalls.length; i++) {
// If the current stall is at least dist away
// from the previous one place the cow here
if (stalls[i] - prev >= dist) {
prev = stalls[i];
cnt++;
}
}
// Return true if we are able to place all 'k' cows
return (cnt >= k);
}
function aggressiveCows(stalls, k) {
// sorting the array to ensure stalls in sequence
stalls.sort((a, b) => a - b);
let res = 0;
// Search Space for Binary Search
let lo = 1;
let hi = stalls[stalls.length - 1] - stalls[0];
while (lo <= hi) {
let mid = Math.floor(lo + (hi - lo) / 2);
// If the mid distance is possible, update
// the result and search for larger distance
if (check(stalls, k, mid)) {
res = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
return res;
}
const stalls = [1, 2, 4, 8, 9];
const k = 3;
const ans = aggressiveCows(stalls, k);
console.log(ans);
Time Complexity: O(n * log(MAX - MIN)) - where n is the size of the array, MAX is the maximum element in the array and MIN is minimum element in the array.
Auxiliary Space: O(1)
Similar Reads
Binary Search on Answer Tutorial with Problems Binary Search on Answer is the algorithm in which we are finding our answer with the help of some particular conditions. We have given a search space in which we take an element [mid] and check its validity as our answer, if it satisfies our given condition in the problem then we store its value and
15+ min read
Time Crunch Challenge Geeks for Geeks is organizing a hackathon consisting of N sections, each containing K questions. The duration of the hackathon is H hours. Each participant can determine their speed of solving questions, denoted as S (S = questions-per-hour). During each hour, a participant can choose a section and
10 min read
Find minimum subarray length to reduce frequency Given an array arr[] of length N and a positive integer k, the task is to find the minimum length of the subarray that needs to be removed from the given array such that the frequency of the remaining elements in the array is less than or equal to k. Examples: Input: n = 4, arr[] = {3, 1, 3, 6}, k =
10 min read
Maximize minimum sweetness in cake cutting Given that cake consists of N chunks, whose individual sweetness is represented by the sweetness[] array, the task is to cut the cake into K + 1 pieces to maximize the minimum sweetness. Examples: Input: N = 6, K = 2, sweetness[] = {6, 3, 2, 8, 7, 5}Output: 9Explanation: Divide the cake into [6, 3],
7 min read
Maximize minimum element of an Array using operations Given an array A[] of N integers and two integers X and Y (X ≤ Y), the task is to find the maximum possible value of the minimum element in an array A[] of N integers by adding X to one element and subtracting Y from another element any number of times, where X ≤ Y. Examples: Input: N= 3, A[] = {1,
8 min read
Maximize the minimum element and return it Given an array A[] of size N along with W, K. We can increase W continuous elements by 1 where we are allowed to perform this operation K times, the task is to maximize the minimum element and return the minimum element after operations. Examples: Input: N = 6, K = 2, W = 3, A[] = {2, 2, 2, 2, 1, 1}
8 min read
Find the maximum value of the K-th smallest usage value in Array Given an array arr[] of size N and with integers M, K. You are allowed to perform an operation where you can increase the value of the least element of the array by 1. You are to do this M times. The task is to find the largest possible value for the Kth smallest value among arr[] after M operations
7 min read
Aggressive Cows Given an array stalls[] which denotes the position of a stall and an integer k which denotes the number of aggressive cows. The task is to assign stalls to k cows such that the minimum distance between any two of them is the maximum possible.Examples: Input: stalls[] = [1, 2, 4, 8, 9], k = 3Output:
15+ min read
Minimum time to complete at least K tasks when everyone rest after each task Given an array arr[] of size n representing the time taken by a person to complete a task. Also, an array restTime[] which denotes the amount of time one person takes to rest after finishing a task. Each person is independent of others i.e. they can work simultaneously on different tasks at the same
8 min read
Maximum count of integers to be chosen from given two stacks having sum at most K Given two stacks stack1[] and stack2[] of size N and M respectively and an integer K, The task is to count the maximum number of integers from two stacks having sum less than or equal to K. Examples: Input: stack1[ ] = { 60, 90, 120 }stack2[ ] = { 100, 10, 10, 250 }, K = 130Output: 3Explanation: Tak
9 min read