矩阵的最小路径和_有一个5x4的矩阵,从左上角的格子开始每次只能向右或者向下走,最后到达右下角

给定一个矩阵m，从左上角开始每次只能向右或向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，返回所有的路径中最小的路径和。

若给定的m如下：

1 4 9 8

9 5 8 12

14 5 11 12

22 13 15 12

路径1，4，5，5，11，12，12是所有路径和最小的，所以返回结果50.

经典动态规划方法。假设矩阵m的大小为M*N,行数为M，列数位N。则申请一个同样大小的矩阵dp，dp[i][j]的值表示从左上角位置走到(i,j)位置的最小路径和。对于m的第一行的所有位置来说，即(0,j),从(0,0)走到位置(0,j)位置只能向右走，所以(0,0)位置到(0,j)位置的路径和就是m[0][0...j]这些值得累加结果。同理，对于m的第一列也是一样的。则dp的第一行和第一列的值如下：

1 5 14 22

10

24

46

除了第一行和第一列的其他位置，都有左边位置(i,j-1)和上边位置(i-1,j).从(0,0)到(i,j)的路径必然经过位置(i-1,j)或位置(i,j-1),所以dp[i][j]=min(dp[i][j-1],dp[i-1][j])+m[i][j].

其时间复杂度为O(M*N),空间复杂度为O(M*N).

#include <iostream>
#include<cmath>
#include<stdlib.h>
 
#define MATRIX_ROW 4
#define MATRIX_COL 4
 
int minpathsum1(int matrix[][MATRIX_COL]);
 
using namespace std;
 
 
 
 
int main()
{
//    int **matrix;
//    matrix = new int*[MATRIX_ROW];
//    for(int i=0; i<MATRIX_ROW; i++)
//    {
//        matrix[i] = new int[MATRIX_COL];
//    }
 
    int matrix[MATRIX_ROW][MATRIX_COL] ={1,4,9,8,9,5,8,12,14,5,11,12,22,13,15,12};
 
    int result1;
    result1 = minpathsum1(matrix);
 
    cout<<"1 min path sum is:"<<result1<<endl;
 
//    for(int i=0; i<MATRIX_ROW; i++)
//        delete []matrix[i];
//    delete []matrix;
    return 0;
}
 
int minpathsum1(int matrix[][MATRIX_COL])
{
    if(matrix == NULL)
    {
        return 0;
    }
    int dp[MATRIX_ROW][MATRIX_COL]={0};
    dp[0][0] = matrix[0][0];
    for(int i=1;i<MATRIX_COL;i++)
    {
        dp[0][i] = dp[0][i-1]+matrix[0][i];
    }
    for(int j=1;j<MATRIX_ROW;j++)
    {
        dp[j][0] = dp[j-1][0]+ matrix[j][0];
    }
    for(int i=1;i<MATRIX_ROW;i++)
    {
        for(int j=1;j<MATRIX_COL;j++)
        {
            dp[i][j]=(dp[i-1][j]<dp[i][j-1]?dp[i-1][j]:dp[i][j-1])+matrix[i][j];
        }
    }
    return dp[MATRIX_ROW-1][MATRIX_COL-1];
}

动态规划可以对空间进行压缩，使得额外的空间复杂度减小至O(min(M,N)),

#include <iostream>
#include<cmath>
#include<stdlib.h>
 
#define MATRIX_ROW 4
#define MATRIX_COL 4
 
int minpathsum2(int matrix[][MATRIX_COL]);
 
using namespace std;
 
 
 
 
int main()
{
//    int **matrix;
//    matrix = new int*[MATRIX_ROW];
//    for(int i=0; i<MATRIX_ROW; i++)
//    {
//        matrix[i] = new int[MATRIX_COL];
//    }
 
    int matrix[MATRIX_ROW][MATRIX_COL] ={1,4,9,8,9,5,8,12,14,5,11,12,22,13,15,12};
 
    int result2;
    result2 = minpathsum2(matrix);
 
    cout<<"2 min path sum is:"<<result2<<endl;
 
 
//    for(int i=0; i<MATRIX_ROW; i++)
//        delete []matrix[i];
//    delete []matrix;
    return 0;
}
 
 
 
int minpathsum2(int matrix[][MATRIX_COL])
{
    if(matrix == NULL)
    {
        return 0;
    }
    int i=0;
    int j=0;
    int longlen = max(MATRIX_ROW,MATRIX_COL);
    int lesslen = min(MATRIX_ROW,MATRIX_COL);
    bool rowlong = (longlen == MATRIX_ROW);
    int minpath =0;
    int* arr = new int[lesslen];
    arr[0] = matrix[0][0];
    for(i=1;i<lesslen;i++)
    {
        arr[i] = arr[i-1]+(rowlong?matrix[0][i]:matrix[i][0]);
    }
    for(i=1;i<longlen;i++)
    {
        arr[0] += (rowlong?matrix[i][0]:matrix[0][i]);
        for(j=1;j<lesslen;j++)
        {
            arr[j] = min(arr[j-1],arr[j])+(rowlong?matrix[i][j]:matrix[j][i]);
        }
    }
    return arr[lesslen-1];
}