codeforces 730 Botellas J

enlaces a los temas: https://codeforces.com/contest/730/problem/J

Significado de las preguntas:

　　N darle una botella de agua, una botella de agua ai, bi capacidad. Para instalar toda el agua en la botella lo menos posible.

　　Cada unidad móvil es un agua consume una unidad de tiempo, por lo menos bajo la premisa de la botella, pida el tiempo mínimo requerido para mover el agua.

análisis:

　　dp

　　El establecimiento de un tridimensional dp [i] [j] [ k] ( Esta pregunta sólo para tarjeta de un espacio 1E8

　　Cuando ① dp [i] [j] [k] indica las botellas i delanteros, j-ésimo seleccionado, la capacidad total de la botella es k, todos de la botella de agua y el máximo

　　Cuando ② dp [i] [j] [k] indica las botellas i delanteros, j-ésimo botella capacidad total de seleccionado de k, se necesita un mínimo coste

　　Aquí para explicar el costo de ② mencionó:

　　Cada botella es no sólo la elección y la elección de dos estados

　　Seleccionar las palabras del agua en la botella no tiene que mover, entonces el agua no va a producir el coste

　　No se selecciona, a continuación, la botella de agua que necesita para pasar a otra botella, entonces el agua generará costes

Una práctica:

#include <. bits / STDC ++ h>
 #define ios std :: ios :: sync_with_stdio (false)
 #define rep (i, a, n) for (int i = a; i <= n; i ++)
 #define mm ( a, n) memset (a, n, sizeof (a))
 usando  espacio de nombres std;
const  int inf ( 0x3f3f3f3f );
const  int N = 1e2 + 1 ;
struct nodo {
     int x, y;
    bool  operador <( const nodo y a) const {
         si (y == ay) de retorno x> ax;
        regresar y> ay;
    }
}un]; 
int dp [N] [N] [N * N];
int pre [N];
int main () 
{ 
    ios; 
    int n, suma = 0 , res = 0 , necesidad; 
    cin >> n; 
    rep (i, 1 , n) cin >> a [i] .x, sum + = a [i] .x; 
    rep (i, 1 , n) cin >> a [i] .y; 
    tipo (a + 1 , a + 1 + n); 
    rep (i, 1 , n) 
    { 
        res + = a [i] .y;
        si (res> = suma)
        { 
            Necesidad = i; 
            romper ; 
        } 
    } 
    Mm (dp, - inf); 
    rep (i, 1 , n) pre [i] = pre [i - 1 ] + a [i] .y; 
    dp [ 0 ] [ 0 ] [ 0 ] = 0 ; 
    rep (i, 1 , n) 
        rep (j, 0 , min (i, necesidad)) 
            representante (k, 0 , pre [i]) 
            { 
                dp [i] [j] [k] = dp [i - 1Si] [j] [k];
                (j - 1 > = 0 && k - a [i] .y> = 0 ) 
                dp [i] [j] [k] = max (dp [i] [j] [k], dp [i - 1 ] [j - 1 ] [k - a [i] .y] + a [i] .x);  
            } 
    Int ma = 0 ; 
    rep (i, suma, pre [n]) ma = max (ma, dp [n] [necesidad] [i]); 
    cout << << necesidad "  " << suma - ma << ' \ n ' ;
    volver  0 ; 
}

La práctica dos:

#include <. bits / STDC ++ h>
 #define ios std :: ios :: sync_with_stdio (false)
 #define rep (i, a, n) for (int i = a; i <= n; i ++)
 #define mm ( a, n) memset (a, n, sizeof (a))
 usando  espacio de nombres std;
const  int inf ( 0x3f3f3f3f );
const  int N = 1e2 + 1 ;
struct nodo {
     int x, y;
    bool  operador <( const nodo y a) const {
         si (y == ay) de retorno x> ax;
        regresar y> ay;
    }
}un]; 
int dp [N] [N] [N * N];
int pre [N];
int main () 
{ 
    ios; 
    int n, suma = 0 , res = 0 , necesidad; 
    cin >> n; 
    rep (i, 1 , n) cin >> a [i] .x, sum + = a [i] .x; 
    rep (i, 1 , n) cin >> a [i] .y; 
    tipo (a + 1 , a + 1 + n); 
    rep (i, 1 , n) 
    { 
        res + = a [i] .y;
        si (res> = suma) 
        { 
            necesidad = i; 
            romper ; 
        } 
    } 
    Mm (dp, inf); 
    rep (i, 1 , n) pre [i] = pre [i - 1 ] + a [i] .y; 
    dp [ 0 ] [ 0 ] [ 0 ] = 0 ; 
    rep (i, 1 , n) 
    { 
        rep (j, 0 , min (i, necesidad)) 
        { 
            rep (k, 0 , pre [i]) 
            { 
                dp [i] [j] [k] = dp [i - 1] [j] [k] + a [i] .x;
                si (j - 1 > = 0 && k - a [i] .y> = 0 ) 
                dp [i] [j] [k] = min (dp [i] [j] [k], dp [i - 1 ] [j - 1 ] [k - a [i] .y]);  
            } 
        } 
    } 
    Int ma = inf; 
    rep (i, suma, pre [n]) ma = min (ma, dp [n] [necesidad] [i]); 
    cout << << necesidad "  " << << ma ' \ n ' ;
    volver  0 ; 
}