Análisis de algoritmos y experimento de diseño: 01 mochila

Descripción del problema:

Hay N artículos y una mochila con una capacidad de V. El peso del elemento i-ésimo es el peso [i], y el valor es el valor [i]. Resolver qué artículos están empacados en la mochila puede hacer que el peso total de estos artículos no exceda la capacidad de la mochila, y el valor total es el mayor. Tenga en cuenta que, a diferencia del problema de la mochila, cada artículo tiene solo dos opciones: carga completa y sin carga, y cada artículo solo se puede cargar una vez.

Descripción del algoritmo:

Use f (i, v) para indicar el valor máximo que se puede obtener cuando los primeros elementos i se cargan selectivamente en una mochila con una capacidad restante de v. Aquí separamos el ítem i-ésimo del ítem i-1. anterior. El ítem i-ésimo solo se puede cargar o no.

1. Si no está instalado, la capacidad restante no disminuirá y el valor no cambiará, por lo que en este caso f (i, v) = f (i-1, v)

2. Si está instalado, la capacidad disminuye y el valor aumenta, por lo que en este caso f (i, v) = f (i-1, vw octavo t [i]) + valor [i]

Desde una perspectiva de arriba hacia abajo, si se carga el ítem i-ésimo, el valor máximo de los primeros ítems i-1 en el caso de capacidad restante reducida debe resolverse en el siguiente nivel. El valor máximo de un artículo con la capacidad restante sin cambios.

Por lo tanto, para la carga y descarga del ítem i-ésimo, solo necesitamos tomar el máximo de los dos. Para que pueda obtener la ecuación de transición de estado:

f (i, v) = f (i-1, v)                                           (v <peso [i], es decir, la capacidad restante no es suficiente para colocar elementos)

f (i, v) = f (i-1, vw octavo t [i]) + valor [i]                (v> = peso [i], es decir, la capacidad restante es suficiente)

Dado que cada fila de datos depende solo de la fila anterior, se puede optimizar utilizando una matriz continua

Código:

 

#include <iostream> 
#include <vector> 
#include <algorithm>
 usando el  espacio de nombres std;
// f [i] [v] = max {f [i-1] [v], f [i-1] [vw [i]] + val [i]}
 // f [v] = max (f [peso-v [i]] + valor [i], f [v]) 
int resolver ( int n, int capacidad, vector < int > y peso, vector < int > y valor) 
{ 
    if (n < 0 || capacidad <= 0 )
         devuelve  0 ; 
    vector < int > f (capacidad + 1 );
    para (int i = 0 ; i <n; i ++ ) 
    { 
        for ( int v = capacidad; v> 0 ; v-- ) 
        { 
            if (v> = peso [i]) f [v] = max (f [v-weight [i]] + valor [i], f [v]); 
        } 
    } 
    return f [capacidad]; 
} 

int main () 
{ 
    int n, capacidad; 
    cin >> n >> capacidad; 
    vector < int > peso (n); 
    vector < int > valor (n);
    para ( int i = 0; i <n; i ++ ) 
    { 
        cin >> peso [i] >> valor [i]; 
    } 

    int ans = resolver (n, capacidad, peso, valor); 
    cout << ans << endl;
    devuelve  0 ; 
}