174.Dungeon Game---dp

题目链接

题目大意：从左上角到右下角，每一个格子都有各自的权值，如果权值为负，则当到达时，要失血；如果权值为正，则当到达时，要加血。当到达某个格子时，当前血量<=0，则死亡，到达不了右下角，所以此时要计算从左上角到右下角，初始应该最少携带多少血（即经过所有路径后所计算出的值），才不会死亡，能正常到达右下角。

法一：dfs，模板深搜，果断超时。要注意：更新点不是整条路径的和（与64题比较）的最小值，而是整条路径中所达到的最大的失血量，如果最大失血量>=0，则本身只需要携带1个血即可；否则本身携带的血应该=abs(最大失血量)+1。代码如下：

     public int calculatedMinimumHP(int[][] dungeon) {
         boolean vis[][] = new boolean[dungeon.length][dungeon[0].length];
         int f[][] = {{1, 0}, {0, 1}};
         vis[0][0] = false;
         return dfs(dungeon, 0, 0, dungeon[0][0], Integer.MAX_VALUE, dungeon[0][0], vis, f);
     }
     public int dfs(int[][] dungeon, int x, int y, int sum, int res, int blood, boolean vis[][], int f[][]) {
         if(x == dungeon.length - 1 && y == dungeon[0].length - 1) {
             //递归结束点是每条线路的过程中的最大失血量
             if(blood < 0) {//如果失血量为负数，则是绝对值+1
                 if(Math.abs(blood) < res) {
                     res = Math.abs(blood) + 1;
                  }
             }
             else {//如果失血量>=0，则是1，因为当失血量为0时，也会死亡
                 res = 1;
             }
             return res;
         }
         for(int i = 0; i < 2; i++) {
             int cnt_x = x + f[i][0];
             int cnt_y = y + f[i][1];
             if(cnt_x < dungeon.length && cnt_y < dungeon[0].length && vis[cnt_x][cnt_y] == false) {
                 vis[cnt_x][cnt_y] = true;
                 res = dfs(dungeon, cnt_x, cnt_y, sum + dungeon[cnt_x][cnt_y], res, blood < (sum + dungeon[cnt_x][cnt_y]) ? blood : (sum + dungeon[cnt_x][cnt_y]), vis, f);
                 vis[cnt_x][cnt_y] = false;
             }
         }
         return res;
     }

法二（借鉴）：dp，类似于64的二维dp，64是从左上往右下，而这题是从右下往左上。dp[i][j]表示从坐标[i,j]到右下角的路径中需要的最少血量，这样每次计算时，都可以用到下面和右面的dp值，从中取最小再将当前值减去即可。其中要追的地方与dfs相似，在每一个格子中，都要始终保持至少1个血量。dp公式：dp[i][j] = min(dp[i + 1][j], dp[i][j + 1]) - du[i][j]。代码如下（耗时2ms）：

     public int calculatedMinimumHP(int[][] dungeon) {
         int dp[][] = new int[dungeon.length][dungeon[0].length];
         //初始化最后一列
         //由于走到每个格子时，都要保持至少一个血量，所以应该用到max(1, ...)
         dp[dungeon.length - 1][dungeon[0].length - 1] = Math.max(1, 1 - dungeon[dungeon.length - 1][dungeon[0].length - 1]);
         for(int i = dungeon.length - 2; i >= 0; i--) {
             dp[i][dungeon[0].length - 1] = Math.max(1, dp[i + 1][dungeon[0].length - 1] - dungeon[i][dungeon[0].length - 1]);
         }
         //初始化最后一行
         for(int i = dungeon[0].length - 2; i >= 0; i--) {
             dp[dungeon.length - 1][i] = Math.max(1, dp[dungeon.length - 1][i + 1] - dungeon[dungeon.length - 1][i]);
         }
         //计算dp
         for(int i = dungeon.length - 2; i >= 0; i--) {
             for(int j = dungeon[0].length - 2; j >= 0; j--) {
                 //从下边和右边中取出最小者，然后减去当前值
                 dp[i][j] = Math.max(1, Math.min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j]);
             }
         }
         return dp[0][0];
     }