思路
递归
递归思路可参考 此处
时间复杂度:O(mn)
空间复杂度:O(mn)
递归超时,谨慎使用
其实,递归的代码可以参考动规的思路改写一下,说不定就不超时了
动规的实质就是下一状态的更新依赖于当前状态,而且此题的更新规则也比较简单,符合递归的逻辑,有兴趣的家人们可以试试
动规
动规思路参考 此处
时间复杂度:O(mn)
空间复杂度:O(m+n)
我的思路与题解稍有不同,但大体上是一样的
效果
动规
代码
动规
int minPathSum(int** grid, int gridSize, int* gridColSize) {
if (gridSize == 0 || gridColSize[0] == 0) {
return 0;
}
int row[gridColSize[0]];
int column[gridSize];
int flag=0;
//初始化
row[flag]=grid[flag][flag];
column[flag++]=row[flag];
for (int i = flag; i < gridColSize[0]; i++) {row[i] = row[i - 1] + grid[flag-1][i];}
for (int j = flag; j < gridSize; j++) {column[j] = column[j - 1] + grid[j][flag-1];}
//动规
while(flag<gridColSize[0] && flag<gridSize){
row[flag]=(column[flag]<row[flag]?column[flag]:row[flag])+grid[flag][flag];
column[flag++]=row[flag];
for(int i = flag; i < gridColSize[0]; i++){row[i] = (row[i-1]<row[i]?row[i-1]:row[i]) + grid[flag-1][i];}
for(int j = flag; j < gridSize; j++){column[j] = (column[j-1]<column[j]?column[j-1]:column[j]) + grid[j][flag-1];}
}
return gridSize>gridColSize[0]?column[gridSize-1]:row[gridColSize[0]-1];
}
递归
int next(int** grid, int rows, int columns, int x, int y){
int ret,left,right;
if(x==rows && y==columns){
ret=0;
}
else{
if(x<rows && y<columns){
left=next(grid,rows,columns,x+1,y);
right=next(grid,rows,columns,x,y+1);
ret=left<right?left:right;
}
else{
if(x==rows && y<columns){
ret=next(grid,rows,columns,x,y+1);
}
else{
ret=next(grid,rows,columns,x+1,y);
}
}
}
return ret+grid[x][y];
}
int minPathSum(int** grid, int gridSize, int* gridColSize){
return next(grid,gridSize-1,gridColSize[0]-1,0,0);
}