Minimum Path Sum [LeetCode]

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

Summary: DP, calucate the minimun sum from start point to every cell unitil we traverse every cell, then just output the last cell.

void goRight(int row_index, int column_index, int **grid_sum, vector<vector<int> > &grid) {
column_index ++ ;
int sum = grid_sum[row_index][column_index - 1] + grid[row_index][column_index];
if(grid_sum[row_index][column_index] == -1 || sum < grid_sum[row_index][column_index])
grid_sum[row_index][column_index] = sum;
}

void goDown(int row_index, int column_index, int **grid_sum, vector<vector<int> > &grid ) {
row_index ++;
int sum = grid_sum[row_index -1][column_index] + grid[row_index][column_index];
if(grid_sum[row_index][column_index] == -1 || sum < grid_sum[row_index][column_index])
grid_sum[row_index][column_index] = sum;
}

int minPathSum(vector<vector<int> > &grid) {
if( grid.size() <= 0 || grid[0].size() <=0){
return 0;
}else if ( grid.size() == 1){
int sum = 0;
for (auto item : grid[0])
sum += item;
return sum;
}else if (grid.size() > 1 && grid[0].size() == 1) {
int sum = 0 ;
for ( auto item : grid)
sum += item[0];
return sum;
}else {
int row_size = grid.size();
int column_size = grid[0].size();

int  ** grid_sum = new int *[row_size];
for( int i=0; i< row_size; i++ )
{
grid_sum[i] = new int [column_size]  ;
}

for(int i =0 ; i< row_size; i ++){
for(int j =0; j < column_size; j++)
grid_sum[i][j] = -1;
}

for(int i = 0; i <= (row_size -1 + column_size -1); i++) {
if (i == 0) {
int row_index = 0;
int column_index = 0;
grid_sum[0][0] = grid[0][0];
if(row_index + 1 < row_size)
goDown(row_index, column_index, grid_sum, grid);
if(column_index + 1 < column_size)
goRight(row_index, column_index, grid_sum, grid);
}else {
int row_index = 0;
int column_index = 0;
for(row_index = 0; row_index <= i; row_index ++ ){
if(row_index >= row_size )
continue;
column_index = i - row_index;
if(column_index >= column_size)
continue;

if(row_index + 1 < row_size)
goDown(row_index, column_index, grid_sum, grid);
if(column_index + 1 < column_size)
goRight(row_index, column_index, grid_sum, grid);
}
}
}

int sum = grid_sum[row_size - 1][column_size - 1];
for( int i=0; i< row_size; i++ ) {
delete [] grid_sum[i];
}
delete grid_sum;
return sum;
}
}