【】 Leetcode 1383. Máximo rendimiento de un equipo

Los temas son los siguientes:

Hay  n ingenieros numeradas de 1 a  n y dos matrices:  speed y  efficiency, donde  speed[i] y  efficiency[i] representan la velocidad y eficiencia para el i-ésimo ingeniero respectivamente. Devuelve el máximo rendimiento de un equipo compuesto en la mayoría de  k los ingenieros, ya que la respuesta puede ser un número enorme, devuelva este módulo 10 ^ 9 + 7.

El rendimiento de un equipo es la suma de las velocidades de sus ingenieros multiplicado por la eficiencia mínima entre sus ingenieros. 

Ejemplo 1:

Entrada: n = 6, velocidad = [2,10,3,1,5,8], la eficiencia = [5,4,3,9,7,2], k = 2 
de salida: 60 
Explicación: 
Tenemos el máximo rendimiento del equipo mediante la selección de ingeniero 2 (con velocidad = 10 y la eficiencia = 4) y el ingeniero de 5 (con velocidad = 5 y la eficiencia = 7). Es decir, rendimiento = (10 + 5) * min (4, 7) = 60.

Ejemplo 2:

Entrada: n = 6, velocidad = [2,10,3,1,5,8], la eficiencia = [5,4,3,9,7,2], k = 3 
de salida: 68 
Explicación: 
Este es el mismo ejemplo, como la primera, pero k = 3. podemos seleccionar ingeniero de 1, 2 ingeniero e ingeniero 5 para obtener el máximo rendimiento del equipo. Es decir, rendimiento = (2 + 10 + 5) * min (5, 4, 7) = 68.

Ejemplo 3:

Entrada: n = 6, velocidad = [2,10,3,1,5,8], la eficiencia = [5,4,3,9,7,2], k = 4 
de salida: 72

limitaciones:

• 1 <= n <= 10^5
• speed.length == n
• efficiency.length == n
• 1 <= speed[i] <= 10^5
• 1 <= efficiency[i] <= 10^8
• 1 <= k <= n

Ideas resolución de problemas: La cuestión clave es encontrar el ingeniero k en la eficiencia para satisfacer las condiciones mínimas que determinan los ingenieros menos eficientes como el punto de referencia, el valor máximo del cálculo es más alta que la siguiente persona en la eficiencia y la velocidad de Ingenieros puede ser.

Código es el siguiente:

clase Solution (objeto):
     def maxPerformance (self, n, velocidad, eficiencia, k):
         """ 
        : tipo n: int 
        : tipo de velocidad: Lista [int] 
        : eficiencia Tipo: Lista [int] 
        : tipo k: int 
        : RTYPE: int 
        """ 
        par = []
         para s, e en zip (velocidad, eficiencia): 
            pair.append ((s, e)) 

        def CMPF (v1, v2):
             si ! v1 [1] = v2 [1 ]:
                 retorno v1 [1] - v2 [1 ]
             retorno v2 [0] - v1 [0] 
        pair.sort (cmp= CMPF)
         importación bisect 

        res = 0 
        total de = Ninguno 
        speed.sort () 
        para i en gama (LEN (par)): 
            inx = bisect.bisect_left (velocidad, par [i] [0]) 
            flag = (inx + k - 1)> = len (velocidad)
             del velocidad [inx]
             si total de == Ninguno: 
                total de = suma (velocidad [len (velocidad) -k + 1 : len (velocidad)])
             elif i + k> len (par): 
                total de - =pair [i] [0]
             elif bandera: 
                total de - = par [i] [0] 
                total de + = velocidad [len (velocidad) - k + 1 ] 

            res = max (res, (en total + pair [i] [0]) * par [i] [1 ])
             # del velocidad [inx] 

        retorno res% (10 ** 9 + 7)