Dada una variedad de trabajos con diferentes requisitos de tiempo. Hay K asignados idénticos disponibles y también se nos indica cuánto tiempo tarda un asignado en hacer una unidad del trabajo. Encuentre el tiempo mínimo para terminar todos los trabajos con las siguientes restricciones.
- A un cesionario solo se le pueden asignar trabajos contiguos. Por ejemplo, a un asignado no se le pueden asignar los trabajos 1 y 3, pero no el 2.
- Dos asignados no pueden compartir (o coasignar) un trabajo, es decir, un trabajo no puede asignarse parcialmente a un asignado y parcialmente a otro.
Aporte :
K: Number of assignees available.
T: Time taken by an assignee to finish one unit
of job
job[]: An array that represents time requirements of
different jobs.
Ejemplos:
Input: k = 2, T = 5, job[] = {4, 5, 10}
Output: 50
The minimum time required to finish all the jobs is 50.
There are 2 assignees available. We get this time by
assigning {4, 5} to first assignee and {10} to second
assignee.
Input: k = 4, T = 5, job[] = {10, 7, 8, 12, 6, 8}
Output: 75
We get this time by assigning {10} {7, 8} {12} and {6, 8}
Le recomendamos encarecidamente que minimice su navegador y que pruebe esto usted mismo primero.
La idea es utilizar la búsqueda binaria. Piense si tenemos una función (por ejemplo, isPossible()) que nos diga si es posible terminar todos los trabajos dentro de un tiempo determinado y una cantidad de asignaciones disponibles. Podemos resolver este problema haciendo una búsqueda binaria de la respuesta. Si el punto medio de la búsqueda binaria no es posible, busque en la segunda mitad, de lo contrario, busque en la primera mitad. El límite inferior para la búsqueda binaria para el tiempo mínimo se puede establecer en 0. El límite superior se puede obtener sumando todos los tiempos de trabajo dados.
Ahora, ¿cómo implementar isPossible()? Esta función se puede implementar utilizando Greedy Approach. Dado que queremos saber si es posible finalizar todos los trabajos dentro de un tiempo determinado, recorremos todos los trabajos y seguimos asignando trabajos al asignado actual uno por uno mientras se puede asignar un trabajo dentro del límite de tiempo dado. Cuando el tiempo empleado por el asignado actual exceda el tiempo dado, cree un nuevo asignado y comience a asignarle trabajos. Si el número de asignados es mayor que k, devuelve falso, de lo contrario, devuelve verdadero.
C++
// C++ program to find minimum time to finish all jobs with
// given number of assignees
#include<bits/stdc++.h>
using namespace std;
// Utility function to get maximum element in job[0..n-1]
int getMax(int arr[], int n)
{
int result = arr[0];
for (int i=1; i<n; i++)
if (arr[i] > result)
result = arr[i];
return result;
}
// Returns true if it is possible to finish jobs[] within
// given time 'time'
bool isPossible(int time, int K, int job[], int n)
{
// cnt is count of current assignees required for jobs
int cnt = 1;
int curr_time = 0; // time assigned to current assignee
for (int i = 0; i < n;)
{
// If time assigned to current assignee exceeds max,
// increment count of assignees.
if (curr_time + job[i] > time) {
curr_time = 0;
cnt++;
}
else { // Else add time of job to current time and move
// to next job.
curr_time += job[i];
i++;
}
}
// Returns true if count is smaller than k
return (cnt <= K);
}
// Returns minimum time required to finish given array of jobs
// k --> number of assignees
// T --> Time required by every assignee to finish 1 unit
// m --> Number of jobs
int findMinTime(int K, int T, int job[], int n)
{
// Set start and end for binary search
// end provides an upper limit on time
int end = 0, start = 0;
for (int i = 0; i < n; ++i)
end += job[i];
int ans = end; // Initialize answer
// Find the job that takes maximum time
int job_max = getMax(job, n);
// Do binary search for minimum feasible time
while (start <= end)
{
int mid = (start + end) / 2;
// If it is possible to finish jobs in mid time
if (mid >= job_max && isPossible(mid, K, job, n))
{
ans = min(ans, mid); // Update answer
end = mid - 1;
}
else
start = mid + 1;
}
return (ans * T);
}
// Driver program
int main()
{
int job[] = {10, 7, 8, 12, 6, 8};
int n = sizeof(job)/sizeof(job[0]);
int k = 4, T = 5;
cout << findMinTime(k, T, job, n) << endl;
return 0;
}
Java
// Java program to find minimum time
// to finish all jobs with given
// number of assignees
class GFG
{
// Utility function to get
// maximum element in job[0..n-1]
static int getMax(int arr[], int n)
{
int result = arr[0];
for (int i=1; i<n; i++)
if (arr[i] > result)
result = arr[i];
return result;
}
// Returns true if it is possible to finish jobs[]
// within given time 'time'
static boolean isPossible(int time, int K,
int job[], int n)
{
// cnt is count of current
// assignees required for jobs
int cnt = 1;
// time assigned to current assignee
int curr_time = 0;
for (int i = 0; i < n;)
{
// If time assigned to current assignee
// exceeds max, increment count of assignees.
if (curr_time + job[i] > time) {
curr_time = 0;
cnt++;
}
// Else add time of job to current
// time and move to next job.
else
{
curr_time += job[i];
i++;
}
}
// Returns true if count
// is smaller than k
return (cnt <= K);
}
// Returns minimum time required to
// finish given array of jobs
// k --> number of assignees
// T --> Time required by every assignee to finish 1 unit
// m --> Number of jobs
static int findMinTime(int K, int T, int job[], int n)
{
// Set start and end for binary search
// end provides an upper limit on time
int end = 0, start = 0;
for (int i = 0; i < n; ++i)
end += job[i];
// Initialize answer
int ans = end;
// Find the job that takes maximum time
int job_max = getMax(job, n);
// Do binary search for
// minimum feasible time
while (start <= end)
{
int mid = (start + end) / 2;
// If it is possible to finish jobs in mid time
if (mid >= job_max && isPossible(mid, K, job, n))
{
// Update answer
ans = Math.min(ans, mid);
end = mid - 1;
}
else
start = mid + 1;
}
return (ans * T);
}
// Driver program
public static void main(String arg[])
{
int job[] = {10, 7, 8, 12, 6, 8};
int n = job.length;
int k = 4, T = 5;
System.out.println(findMinTime(k, T, job, n));
}
}
// This code is contributed by Anant Agarwal.
Python3
# Python program to find minimum # time to finish all jobs with # given number of assignees # Utility function to get maximum # element in job[0..n-1] def getMax(arr, n): result = arr[0] for i in range(1, n): if arr[i] > result: result = arr[i] return result # Returns true if it is possible # to finish jobs[] within given # time 'time' def isPossible(time, K, job, n): # cnt is count of current # assignees required for jobs cnt = 1 # time assigned to current assignee curr_time = 0 i = 0 while i < n: # If time assigned to current # assignee exceeds max, increment # count of assignees. if curr_time + job[i] > time: curr_time = 0 cnt += 1 else: # Else add time of job to current # time and move to next job. curr_time += job[i] i += 1 # Returns true if count is smaller than k return cnt <= K # Returns minimum time required # to finish given array of jobs # k --> number of assignees # T --> Time required by every assignee to finish 1 unit # m --> Number of jobs def findMinTime(K, T, job, n): # Set start and end for binary search # end provides an upper limit on time end = 0 start = 0 for i in range(n): end += job[i] ans = end # Initialize answer # Find the job that takes maximum time job_max = getMax(job, n) # Do binary search for minimum feasible time while start <= end: mid = int((start + end) / 2) # If it is possible to finish jobs in mid time if mid >= job_max and isPossible(mid, K, job, n): ans = min(ans, mid) # Update answer end = mid - 1 else: start = mid + 1 return ans * T # Driver program if __name__ == '__main__': job = [10, 7, 8, 12, 6, 8] n = len(job) k = 4 T = 5 print(findMinTime(k, T, job, n)) # this code is contributed by PranchalK
C#
// C# program to find minimum time
// to finish all jobs with given
// number of assignees
using System;
class GFG
{
// Utility function to get
// maximum element in job[0..n-1]
static int getMax(int []arr, int n)
{
int result = arr[0];
for (int i=1; i<n; i++)
if (arr[i] > result)
result = arr[i];
return result;
}
// Returns true if it is possible to
// finish jobs[] within given time 'time'
static bool isPossible(int time, int K,
int []job, int n)
{
// cnt is count of current
// assignees required for jobs
int cnt = 1;
// time assigned to current assignee
int curr_time = 0;
for (int i = 0; i < n;)
{
// If time assigned to current assignee
// exceeds max, increment count of assignees.
if (curr_time + job[i] > time) {
curr_time = 0;
cnt++;
}
// Else add time of job to current
// time and move to next job.
else
{
curr_time += job[i];
i++;
}
}
// Returns true if count
// is smaller than k
return (cnt <= K);
}
// Returns minimum time required to
// finish given array of jobs
// k --> number of assignees
// T --> Time required by every assignee to finish 1 unit
// m --> Number of jobs
static int findMinTime(int K, int T, int []job, int n)
{
// Set start and end for binary search
// end provides an upper limit on time
int end = 0, start = 0;
for (int i = 0; i < n; ++i)
end += job[i];
// Initialize answer
int ans = end;
// Find the job that takes maximum time
int job_max = getMax(job, n);
// Do binary search for
// minimum feasible time
while (start <= end)
{
int mid = (start + end) / 2;
// If it is possible to finish jobs in mid time
if (mid >= job_max && isPossible(mid, K, job, n))
{
// Update answer
ans = Math.Min(ans, mid);
end = mid - 1;
}
else
start = mid + 1;
}
return (ans * T);
}
// Driver program
public static void Main()
{
int []job = {10, 7, 8, 12, 6, 8};
int n = job.Length;
int k = 4, T = 5;
Console.WriteLine(findMinTime(k, T, job, n));
}
}
// This code is contributed by Sam007.
Javascript
<script>
// Javascript program to find minimum time
// to finish all jobs with given
// number of assignees
// Utility function to get
// maximum element in job[0..n-1]
function getMax(arr, n)
{
let result = arr[0];
for (let i=1; i<n; i++)
if (arr[i] > result)
result = arr[i];
return result;
}
// Returns true if it is possible to
// finish jobs[] within given time 'time'
function isPossible(time, K, job, n)
{
// cnt is count of current
// assignees required for jobs
let cnt = 1;
// time assigned to current assignee
let curr_time = 0;
for (let i = 0; i < n;)
{
// If time assigned to current assignee
// exceeds max, increment count of assignees.
if (curr_time + job[i] > time) {
curr_time = 0;
cnt++;
}
// Else add time of job to current
// time and move to next job.
else
{
curr_time += job[i];
i++;
}
}
// Returns true if count
// is smaller than k
return (cnt <= K);
}
// Returns minimum time required to
// finish given array of jobs
// k --> number of assignees
// T --> Time required by every assignee to finish 1 unit
// m --> Number of jobs
function findMinTime(K, T, job, n)
{
// Set start and end for binary search
// end provides an upper limit on time
let end = 0, start = 0;
for (let i = 0; i < n; ++i)
end += job[i];
// Initialize answer
let ans = end;
// Find the job that takes maximum time
let job_max = getMax(job, n);
// Do binary search for
// minimum feasible time
while (start <= end)
{
let mid = parseInt((start + end) / 2, 10);
// If it is possible to finish jobs in mid time
if (mid >= job_max && isPossible(mid, K, job, n))
{
// Update answer
ans = Math.min(ans, mid);
end = mid - 1;
}
else
start = mid + 1;
}
return (ans * T);
}
let job = [10, 7, 8, 12, 6, 8];
let n = job.length;
let k = 4, T = 5;
document.write(findMinTime(k, T, job, n));
</script>
Producción:
75
Gracias a Gaurav Ahirwar por sugerir la solución anterior.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA