algoritmo voraz para resolver

Hoy hizo una empresa preguntas T, que es un problema de programación es el algoritmo voraz para resolver el problema, que es similar al problema de la mochila clásica. Justo antes visto, escrita cuando la impresión con el 80% lo hacen realmente, y me siento muy agradable para grabarlo.

El título original no recuerdo, escribir un tema similar.

problema de la mochila es un problema de optimización combinatoria se describe como sigue: dado un tamaño fijo, es posible peso transportado W mochila y un valor de ajuste del peso del artículo, para encontrar una solución óptima de estos paquetes que el peso de los artículos cargada no excede W y un valor máximo total.

1, el análisis de problemas

Datos: Número de artículo n = 5, el peso de artículos pesos = [2,2,6,5,4], el valor de los valores de mercancías = [6,3,5,4,6], la capacidad total de la mochila W = 10.

2, problemas de pensamiento

  * En primer lugar calcular el precio de cada artículo, es el peso / el valor obtenido para cada elemento de coste, el depósito en una matriz, de acuerdo con el orden ascendente. Después de atravesar la matriz, hasta que la capacidad de> = 0, se incrementa el valor de máx.

  * Código es el siguiente:

dejar que el precio = [2,2,3,1,5,2]; // Precio 
dejó nums = [2,3,1,5,4,3]; // número correspondiente al 
dejar que el dinero = 6; // existe la cantidad de 

tanxin (. precio, los nums, dinero) 
tanxin función (. precio, los nums, dinero) { 
    // el valor de retorno a 
    la decepción max = 0; 
    // lo mucho que queda ahora 
    al dejar que endMoney = dinero; 
    ARR Let = []; 
    / / precio de recorrido, el precio, la cantidad, y la proporción de una matriz de memoria en 
    price.forEach ((ELE, IDX) => { 
        arr.push ({ 
            :. precio [IDX], 'precio.' 
            'NUM': los nums [IDX], 
            'Bili' :. precio [idx] / los nums [IDX] 
        }) 
    }) 
    // hacer algún tipo, desde pequeñas a grandes 
    arr.sort ((a, B) => { 
       a.bili retorno - b.bili 
    }) 
    / / atravesar la matriz de elementos 
    ARR .forEach ((ele, idx) = > { 
        // necesidad de definir cuando es mayor que 0, o se habrá añadido para ir 
        SI (endMoney - ele.price> = 0) { 
            // resto del dinero para reducir 
            endMoney = endMoney - ele .price; 
            aumento el número máximo de elementos puede ser comprado // 
            max + = ele.num 
        } 
    }) 
    la console.log (max) 
}

  

Supongo que te gusta

Origin www.cnblogs.com/linxf/p/12589624.html
Recomendado
Clasificación