This Java code finds the minimum time required to complete all roadworks when there are n cars and m total roads, where each car is proficient in some roads. It does this by:
1) Counting the number of roads each car is proficient in.
2) Using a binary search approach to find the minimum time, by checking if all roads can be completed within a given time using a function.
3) The function calculates the "free" and "needed" road slots based on the time, and checks if free is greater than needed, returning true if completion is possible.
4) The minimum time required is returned as the output.
This Java code finds the minimum time required to complete all roadworks when there are n cars and m total roads, where each car is proficient in some roads. It does this by:
1) Counting the number of roads each car is proficient in.
2) Using a binary search approach to find the minimum time, by checking if all roads can be completed within a given time using a function.
3) The function calculates the "free" and "needed" road slots based on the time, and checks if free is greater than needed, returning true if completion is possible.
4) The minimum time required is returned as the output.
This Java code finds the minimum time required to complete all roadworks when there are n cars and m total roads, where each car is proficient in some roads. It does this by:
1) Counting the number of roads each car is proficient in.
2) Using a binary search approach to find the minimum time, by checking if all roads can be completed within a given time using a function.
3) The function calculates the "free" and "needed" road slots based on the time, and checks if free is greater than needed, returning true if completion is possible.
4) The minimum time required is returned as the output.
This Java code finds the minimum time required to complete all roadworks when there are n cars and m total roads, where each car is proficient in some roads. It does this by:
1) Counting the number of roads each car is proficient in.
2) Using a binary search approach to find the minimum time, by checking if all roads can be completed within a given time using a function.
3) The function calculates the "free" and "needed" road slots based on the time, and checks if free is greater than needed, returning true if completion is possible.
4) The minimum time required is returned as the output.
static void minTimeRequired(int n, int m, int[] arr) {
// cnt to count the total number of
// road the ith car is proficient in int[] cnt = new int[n + 1];
// Calculating the total no. of
// proficient roads that each // car can do for (int i = 0; i < m; i++) { cnt[arr[i]]++; }
Function<Integer, Boolean> check = (time) ->
{ long free = 0, needed = 0;
for (int i = 1; i <= n; i++) {
if (time >= cnt[i]) { // Storing the number of // roads that can be done // if the provided time is // more than the number of // efficient roads assigned // to a car long extraTime = (time - cnt[i]);
// We are dividing the
// difference by 2 because // as it is mentioned in the // question if the car is // not proficient then 2 // sec are required to // complete a road. free += extraTime / 2; } else { // Storing the number of // roads that are left needed += cnt[i] - time; } }
// If free road slots are greater
// than or equal to the needed, // then it is possible to complete // all m roads in the given time
return needed <= free;
};
// Maximum required time in worst
// case is 2 * m, if you assign all // roads to a single car, and this car // is not proficient in any of // these roads. int l = 0, r = 2 * m; int minTime = -1;
// Binary Search on minTime
while (l <= r) { int mid = (l + r) / 2; if (check.apply(mid)) { // If we are able to complete // all roads using m unit of // time then check with lesser // time again minTime = mid;
r = mid - 1; } else { l = mid + 1; } }
System.out.println(minTime); } public static void main(String[] args) { int n = 2, m = 4; int[] arr = { 1, 2, 1, 2 };
