【La espada LeetCode se refiere a la oferta47】Valor máximo del regalo (dp simple)

1. El tema

2. Ideas

pregunta basica Cuando obtenga el título, el "valor máximo" y las preguntas de ruta, puede encontrar que la ruta diferente (dp) es la misma que la anterior [LeetCode62] Se estipula que desde la esquina superior izquierda, solo puede moverse un espacio hacia la derecha o hacia abajo a la vez. , por lo que cuando la pregunta se considera desde el estado actual, se debe agregar el valor de dp de la cuadrícula superior y el valor de dp de la izquierda (porque existe la cantidad de métodos de ruta), pero esta pregunta es para tomar max (porque aquí hay un camino, el camino maximiza el valor del regalo).

(1) Determinar el estado
Estado $f(yo,j)$ significa alcanzar la corriente$(yo,j)$ La suma máxima de regalos que se pueden obtener en la posición coordenada.

(2) Ecuación de transición de estado
$$f(yo,j)=\mathrm{máx}\left[f\right(yo-1,j),f(yo,j-1\left)\right]+g(yo,j)$$ Entre ellos$g(yo,j)$ es el valor de regalo de la grilla actual.

(3) Límite + condiciones iniciales
dp[o][0]y valores de dp para la primera columna y la primera fila.

(4) Orden de cálculo Los datos al
calcular el subíndice irequieren i-1algunos datos, por lo que es necesario recorrer la isuma de menor a mayor j.

3. Código

class Solution {
    
    
public:
    int maxValue(vector<vector<int>>& grid) {
    
    
        //dp[i][j]表示目前到该位置的最大价值
        int m = grid.size();
        int n = grid[0].size();
        vector<vector<int>> dp(m, vector<int>(n, 0));
        dp[0][0] = grid[0][0];
        for(int i = 1; i < n; i++){
    
    
            dp[0][i] = dp[0][i - 1] + grid[0][i];
        }
        for(int j = 1; j < m; j++){
    
    
            dp[j][0] = dp[j - 1][0] + grid[j][0];
        }
        for(int i = 1; i < m; i++){
    
    
            for(int j = 1; j < n; j++){
    
    
                dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
            }
        }
        return dp[m - 1][n - 1];
    }
};

Dado que [i][j]solo se utilizan los datos de la cuadrícula superior e izquierda en cada posición, la complejidad del espacio también se puede optimizar a través de [matriz rodante]. Aquí hay una solución de optimización de "Swords Offer":

#include <vector>     
#include <iostream>   
#include <string>     
#include <string.h>   
#include <algorithm> 
using namespace std;  

int getMaxValue(const int *val,int rows,int cols){
    
                         
    if((val == NULL)||(rows <= 0)||(cols <= 0))return 0;

    //只用一行缓存来缓存上一行的最大值
    int *buffer = new int[cols];

    for(int i = 0;i != rows;i++){
    
     
        for(int j = 0;j != cols;j++){
    
     
            int up = 0,left = 0;
            //取上面一格的最大值
            if(i != 0){
    
     
                up = buffer[j]; 
            }         

            //因为左边一格的最大值会及时更新到缓存，所以这里取的是左边一格的数据                                                                                                                                                            
            if(j != 0){
    
     
                left = buffer[j-1]; 
            }         

            int tmp = max(up,left)+val[i*cols+j]; 
            //对当前行的数据实时更新到缓存
            buffer[j] = tmp;
        }             
    }                 

    int resu = buffer[cols-1];
    delete[] buffer;  
    return resu;      
}                     

int main(){
    
                         
    int *test = new int[16];
    test[0] = 1;      
    test[1] = 10;     
    test[2] = 3;      
    test[3] = 100;    
    test[4] = 12;     
    test[5] = 2;      
    test[6] = 9;      
    test[7] = 6;      
    test[8] = 5;      
    test[9] = 7;      
    test[10] = 4;     
    test[11] = 11;    
    test[12] = 3;     
    test[13] = 7;     
    test[14] = 16;    
    test[15] = 5;     

    cout << getMaxValue(test,4,4) << endl;
    return 0;         
}