文章目录

• 思路
• • 递归
  • 动规
• 效果
• 代码
• • 动规
  • 递归

思路

递归

递归思路可参考 此处
时间复杂度：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);
}