矩阵的最小路径和

     

//矩阵的最小路径和
public class minMatrixLength{
	//(1)动态规划法(非压缩矩阵 时间复杂度O(M*N)，空间复杂度O(M*N))
	public static int getminMatrixLength(int[][]matrix)
	{
		if(matrix==null||matrix.length==0||matrix[0]==null||matrix[0].length==0)
		{
			return 0;
		}
		int row=matrix.length; //矩阵的行数
		int col=matrix[0].length; //矩阵的列数
		int [][]dp=new int[row][col]; //存储到各个节点的最短路径
		dp[0][0]=matrix[0][0];
		for(int i=1;i<row;i++)
		{
			dp[i][0]=dp[i-1][0]+matrix[i][0]; //第一列
		}
		for(int j=1;j<col;j++)
		{
			dp[0][j]=dp[0][j-1]+matrix[0][j];//第一行
		}
		//动态规划法求到各个节点的最短路径矩阵
		for(int i=1;i<row;i++)
		{
			for(int j=1;j<col;j++)
			{
				dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j])+matrix[i][j];
			}
		}
		return dp[row-1][col-1]; //返回矩阵右下角的最后一个数

	}
	//(2)动态规划法(滚动法)(压缩矩阵 时间复杂度O(M*N)，空间复杂度min(M,N))
	public static int getminMatrixLength2(int[][]matrix)
	{
      if(matrix==null||matrix.length==0||matrix[0]==null||matrix[0].length==0)
	  {
			return 0;
	  }
	  int more=Math.max(matrix.length,matrix[0].length);//行数与列数较大的那个为more
	  int less=Math.min(matrix.length,matrix[0].length);//行数与列数较小的那个为less
	  boolean rowmore=more==matrix.length; //行数是不是大于等于列数
	  int[]arr=new int[less]; //辅助数组的长度为行数和列数中的最小值
	  arr[0]=matrix[0][0];   //第一个数赋予初始值
	  for(int i=1;i<less;i++)
	  {
	  	arr[i]=arr[i-1]+(rowmore?matrix[0][i]:matrix[i][0]);//第一行或者第一列的值
	  }
      for(int i=1;i<more;i++)
      {
      	arr[0]=arr[0]+(rowmore?matrix[i][0]:matrix[0][i]);//向下或者向右滚动
      	 for(int j=1;j<less;j++)
      	 {
      	 	arr[j]=Math.min(arr[j-1],arr[j])+(rowmore?matrix[i][j]:matrix[j][i]);//向下或者向右滚动
      	 }
      }

       return arr[less-1];
	}

	public static void main(String[]args)
	{
		int [][]matrix={{1,3,5,9},
		                {8,1,3,4},
		                {5,0,6,1},
		                {8,8,4,0}
		              };
        //方法一
		System.out.println(getminMatrixLength(matrix));
		//方法二
		System.out.println(getminMatrixLength2(matrix));

	}
}