[Programación dinámica] [leetcode] Pila de cajas

tema:

Pila de cajas. Te da una pila de n cajas, el ancho de la caja es wi, la profundidad es di y la altura es hi. Las cajas no se pueden voltear Al apilar cajas, el ancho, alto y profundidad de las cajas de abajo deben ser mayores que las de las cajas de arriba. Descubra una forma de construir la pila más alta de cajas. La altura de la pila de cajas es la suma de las alturas de cada caja.

La entrada usa la matriz [wi, di, hi] para representar cada cuadro.

Ejemplo 1:

 Entrada: cuadro = [[1, 1, 1], [2, 2, 2], [3, 3, 3]]
 Salida: 6
Ejemplo 2:

 Entrada: cuadro = [[1, 1, 1], [2, 3, 4], [2, 6, 7], [3, 4, 5]]
 Salida: 10
consejos:

• El número de cajas no es más de 3000.

fuente:

Pregunta de la entrevista 08.13. Pila de cajas

Ideas de resolución de problemas: programación dinámica

La idea de esta pregunta es la misma que la del sobre de la  muñeca rusa  Defina una matriz dp, dp [i] representa la altura más alta con la i-ésima caja como base. Ordene la matriz de entrada y calcule dp [i] a su vez:

dp [i] = max (dp [0], dp [1], dp [2], ..., dp [i-1]) + casilla [i] .altura. (Cada dp en max debe cumplir con la condición de superposición de cajas. Para que la fórmula sea concisa y clara, esta condición no se agrega).

class Solution {
public:
    int result;
    int pileBox(vector<vector<int>>& box) {
        sort(box.begin(), box.end());
        vector<int> dp(box.size(), 0);
        for (int i = 0; i < box.size(); i++) {
            int max = box[i][2];
            for (int j = 0; j < i; j++) {
                if (box[j][0] < box[i][0] && box[j][1] < box[i][1] && box[j][2] < box[i][2]) {
                    int t = dp[j] + box[i][2];
                    if (max < t) max = t;
                }
            }
            dp[i] = max;
        }
        int max = 0;
        for (int i = 0; i < dp.size(); i++) {
            if (max < dp[i]) max = dp[i];
        }
        return max;
    }
};

Esta pregunta apareció en el tema de retroceso. Empecé a hacerlo con retroceso primero. Después de todo, era una búsqueda de fuerza bruta y el resultado se agotó. El siguiente es mi código de retroceso. Si alguien propone un plan de optimización, deje un mensaje en el área de comentarios.

class Solution {
public:
    int result;
    int pileBox(vector<vector<int>>& box) {
        sort(box.begin(), box.end());
        result = 0;
        for (int i = 0; i < box.size(); i++) {
            back(box, i, i+1, box[i][2]);
        }
        return result;
    }
    void back(const vector<vector<int>>& box, int last, int start, int height) {
        if (result < height) result = height;
        if (start == box.size()) {
            return;
        }
        for (int i = start; i < box.size(); i++) {
            if (box[i][0] > box[last][0] && box[i][1] > box[last][1] && box[i][2] > box[last][2]) {
                back(box, i, i+1, height+box[i][2]);
            }
        }
    }
};