Mochila nueve tensiones tres: múltiple problema de la mochila: un número finito de elementos permitidos para elegir

Hay n tipo de bienes y una capacidad de mochila V.

Hasta pedazos el i-ésimo elemento de Si, cada volumen es VI, un wi valor.

¿Qué solución de los elementos en la mochila, no puede exceder el volumen total de la capacidad del artículo de la mochila, y la suma del valor máximo.

El valor de salida máximo.

Formato de entrada

La primera línea de dos números enteros, N, V, separados por espacios, representan cada uno un tipo de bienes y un volumen de mochila.

Entonces hay N filas, cada fila de tres números enteros vi, wi, Si, separados por espacios, respectivamente, representa el volumen de la i-ésimo elemento, el valor y la cantidad.

Formato de salida

Output Un entero que representa el valor máximo.

Rango de datos

0 <N≤1000

0 <V≤20000

0 <vi, wi, si≤20000

Ejemplo de entrada

4 5

1 2 3

2 4 1

3 4 3

4 5 2

Ejemplo de salida

10

Sólo el equivalente de múltiples problema de la mochila problema de la mochila será completamente en el número de elementos disponibles por el infinito se convierte en finito. Así que antes de que el problema de la mochila llena la forma más fácil es no re-ciclo de optimización tercer cambió un poco:

for (int k = 1; k <= s [i] && k <= j / v [i]; ++ k)

1, el método de optimización binaria, tiempo de complejidad: O (N * LOGs * V)

. 1 #include <la iostream>
 2 #include <vector>
 . 3 #include <algoritmo>
 . 4  el uso de  espacio de nombres STD;
 . 5  struct Bueno {
 6.      Int VI, Wi;
 . 7  };
 . 8  const  int ARRAY_SIZE = 2,001 ;
 . 9  int F [ARRAY_SIZE], N, V, V, W, S;
 10 Vector <Good> buque;
 . 11  / * 
12 es  método de optimización binario
 13 es  V, W, S
 14  cada artículo se divide en partes de s, se necesita un número máximo de log (s) representado
 15  Ejemplo: un total de siete artículos, puede ser 1,2,4 (pow (2, k) ) en combinación
 16 Respectivamente, a un artículo, el artículo 2, como un grupo de cuatro artículos,
 17  es de aproximadamente siete artículo se divide en tres elementos, volumen y valor, respectivamente:
 18 es  V, W; V 2 * 2 * W ;. 4 * v, 4 * w. Traducido a 01 mochila problema.
. 19  * / 
20 es  int main () {
 21 es      CIN N >> >> V;
 22 es      para ( int I = 0 ; I <N; ++ I) {
 23 es          CIN W >> >> >> V S;
 24          para ( int K = . 1 ; K <= S; K * = 2 ) {
 25              S - = K;
 26 es              vessel.push_back (V * {K, K * W});
 27          }
 28         si (s> 0 )
 29              vessel.push_back ({s * v, s * w});
30      }
 31      // 01背包问题算法
32      para (Bueno bueno: buque)
 33          para ( int j = V; j> = good.vi; - j)
 34              f [j] = max (f [j], f [j - good.vi] + good.wi);
35      cout << f [V];
36 }

2, cola de optimización monótona

NOTA: Monótono Queue: Obtener el mínimo actual o máximo secuencia de longitud "m" de las subsecuencias. incremento y decremento monótona la cola sólo dos tipos de colas. Monótono empuje en la cola es el valor del índice en lugar de la secuencia original.

Cuando empuje el subíndice "i":

(1) Cuando deque.front () <tiempo = im, el pop;

(2) Cuando f [deque.back ()]> f [i], Pop, el pop es más grande que el pequeño hasta la fecha;

(3) de empuje 下 标 "i".

Finalmente deque.front () es la corriente de la secuencia de longitud mínima "m" de las subsecuencias.

Los casos de prueba:

10 100

8 7 1

2 2 5

2 2 3

8 6 250

10 7 200

5 2 400

2 1 948

1 1 1

7 4 285

1 1 3

#include <la iostream> 
#include <algoritmo>
 el uso de  espacio de nombres STD;
 / * 
F: antes de que el i-ésimo elemento, mochilas volumen 0-V, correspondiente al valor máximo 
g: i-1 antes de un artículo, mochilas volumen 0-V, el correspondiente El valor máximo 
* / 
const  int ARRAY_SIZE = 20001 ;
 int F [ARRAY_SIZE], G [ARRAY_SIZE], Q [ARRAY_SIZE], N, V, V, W, S;
 int main () { 
    CIN >> N >> V;
     para ( int I = 0 ; I <N; ++ I) { 
        CIN >> >> W >> V S; 
        Copy (F, F + ARRAY_SIZE, G);
         para ( int= J 0 ; J <V; ++ J) {
             int HH = 0 , TT = - 1. ;
             Para ( int K = J; K <= V; = K + V) { 
                F [K] = G [K] ;
                 IF (HH <&& TT = K - V S *> Q [HH])
                     ++ HH; // quitar la cabeza de los elementos de la cola, dentro de la porción cabecera de secuencia actual de la cola es el índice de un cierto rango del valor máximo 
                IF (HH <= TT ) 
                    F [K] = max (F [K], G [Q [HH]] + (K - Q [HH]) / V * W); // con la actualización de valor máximo algunos F [K] 
                el tiempo (HH < = tt && g [q [tt ]] - (q [tt] - j) / v * w <= g [k] - (k - j) / v *W)
                     --tt; // eliminar la cola no será utilizado en el elemento de 
                Q [TT ++] = K; // Empuje nuevo valor de índice 
            } 
        } 
    } 
    COUT << F [V]; 
} 
const  int ARRAY_SIZE = 20.001 ;
 int F [ARRAY_SIZE], G [ARRAY_SIZE], N, V, V, W, S; 
la deque < int > Q;
 int main () { 
    CIN >> N >> V;
     para ( int I = 0 ; I <N; ++ I) { 
        CIN >> >> V >> W S;
        Copy (F, F + ARRAY_SIZE, G);
         para ( int J = 0 ; J <V; ++ J) {
             para ( int K = J; K <= V; = K + V) { 
                F [K] = G [K];
                 IF (! q.empty () && K - V S *> q.front ()) 
                    q.pop_front (); // retiran el cabezal del elemento de la cola, la cabeza actual de la porción de cola de un cierto rango es la secuencia máximo subíndice 
                IF (! q.empty ()) 
                    F [K] = max (F [K], G [q.front ()] + (K - q.front ()) / V * W); // actualizar el valor máximo en F [K] 
                el mientras(Q.empty () && G [q.back ()] - (q.back () - J) / V * W <= G [K] - (K - J) / V * W) 
                    q.pop_back (); // eliminado de una cola no será utilizado 
                q.push_back (K); // Empuje nuevo valor de índice 
            } 
        } 
    } 
    COUT << F [V]; 
}