[置顶] 动态规划之矩阵路径问题
给定一个二维数组map，含义是一张地图，如下矩阵。
-2 -3 3
-5 -10 1
0 30 -5
骑士从左上角出发，每次只能向右或者向下走，最后到达右下角见到公主。地图每个位置如果是负数，骑士损失血量，如果是正数，骑士增加血量。其实走到任何一个位置血量都不能少一1。问骑士出发最低血量。
这是最小路径和的一个变形问题，首先按照最小路径和的思路来解决试试。
/* 龙与地下城问题使用动态规划方法，dp[i][j]代表走到m[i][j]的最低血量是多少。 不过这个动态规划有点逆向思维，不能按常规顺序，从dp数组的左上角出发。一下是从左上角出发 的代码打印出来的矩阵。 */
public int minHP(int [][] m){
if(m==null||m.length==0||m[0]==null||m[0].length==0){
return 1;
}
int row = m.length;
int col = m[0].length;
int dp[][] = new int[row][col];
dp[0][0]=m[0][0];
for(int i = 1;i<col;i++){
dp[0][i]=dp[0][i-1]+m[0][i];
}
for(int i=1;i<row;i++){
dp[i][0]=dp[i-1][0]+m[i][0];
}
for(int i = 1; i<col; i++){
for(int j = 1; j<row; j++){
dp[i][j]+=Math.max(dp[i-1][j]+m[i][j],dp[i][j-1]+m[i][j]);
}
}
for(int i = 0;i<row;i++){
for(int j = 0;j<col;j++){
System.out.print(" " + dp[i][j]);
}
System.out.println();
}
return dp[row-1][col-1]>=0?0:(dp[row-1][col-1])*-1;
}dp数组输出结果
-2 -5 -2
-7 -15 -1
-7 23 18
public int minHPshu(int [][] m){
if(m==null||m.length==0||m[0]==null||m[0].length==0){
return 1;
}
int row = m.length;
int col = m[0].length;
int dp[][] = new int[row--][col--];
dp[row][col]=m[row][col]>0?1:-m[row][col]+1;
for(int j= col-1;j>=0;j--){
// 先算出最后一行的值，这是动态规划的基本思路，先算出第一行或是第一列的值
dp[row][j] = Math.max(dp[row][j+1]-m[row][j],1);
}
int right = 0;
int down = 0;
for(int i=row-1;i>=0;i--){
// 随着遍历逐渐算出最后一列的数，写在此处可以节省一个单独的for循环
dp[i][col]=Math.max(dp[i+1][col]-m[i][col],1);
for(int j=col-1;j>=0;j--){
//以下两行为动态规划的核心代码
right=Math.max(dp[i][j+1]-m[i][j], 1);
down=Math.max(dp[i+1][j]-m[i][j], 1);
dp[i][j]=Math.min(right, down);
}
}
//遍历2维数组
for(int i = 0;i<row+1;i++){
for(int j = 0;j<col+1;j++){
System.out.print(" " + dp[i][j]);
}
System.out.println();
}
return dp[0][0];
}
打印dp：
7 5 2
6 11 5
1 1 6
所以一目了然可以dp[0][0]即为所求。
以上为普通的动态规划，时间复杂度为O(M*N) 两层for循环嵌套的复杂度为O(M*N), 额外空间复杂度为O(M*N)。当然这绝对不是最好的，空间压缩之后可以把额外空间复杂度降至O(min{M,N})。代码如下，对比即可看出与不用空间压缩的不同：
public int minHPshuYouhua(int [][] m){
if(m==null||m.length==0||m[0]==null||m[0].length==0){
return 1;
}
int row = m.length;
int col = m[0].length;
int more = Math.max(row, col);
int less = Math.min(row, col);
boolean rowMore = row > col? true : false;
int dp[] = new int[less];
dp[less-1]=m[row-1][col-1]>0?1:-m[row-1][col-1]+1;
for(int j= less-2;j>=0;j--){
// 先算出最后一行的值，这是动态规划的基本思路，先算出第一行或是第一列的值
// 空间压缩之后需要重新动态定位行号与列号
row = rowMore ? more -1:j;
col = rowMore ? j : more -1;
dp[j] = Math.max(dp[j+1]-m[row][col],1);
}
int right = 0;
int down = 0;
for(int i=more-2;i>=0;i--){
// 随着遍历逐渐算出最后一列的数，写在此处可以节省一个单独的for循环
row = rowMore?i : more-1;
col = rowMore?more-1:i;
dp[less-1]=Math.max(dp[less-1]-m[row][col],1);
for(int j=less-2;j>=0;j--){
//以下两行为动态规划的核心代码
//以下两行为压缩前 作比较
/*right=Math.max(dp[i][j+1]-m[i][j], 1);
down=Math.max(dp[i+1][j]-m[i][j], 1);*/
right=Math.max(dp[j+1]-m[i][j], 1);
//压缩后重新刷新dp的值
down=Math.max(dp[j]-m[i][j], 1);
dp[j]=Math.min(right, down);
}
}
return dp[0];
}