[leetcode-174]Dungeon Game(java)

问题描述：问题描述

分析：这道题第一眼看上去就是二维DP问题，但是我之前是从(0,0)到(row-1,col-1)的遍历过程，但是这样一来的话，就会在某一项出现问题，详见代码2；出现问题之后，我想那肯定要用DFS了，发现果然超时TLE。最后看了网友的答案是从后向前搜索，这样就很巧妙了避免了代码2中的问题。非常神奇。
递推关系式为：dp[i][j] = max(min(dp[i+1][j],dp[i][j])-dungeon[i][j]],1)

代码如下：336ms

public class Solution {
       public int calculateMinimumHP(int[][] dungeon) {
        int row = dungeon.length;
        int col = dungeon[0].length;

        dungeon[row-1][col-1] = Math.max(1-dungeon[row-1][col-1],1);
        //init last row
        for(int i = col-2;i>=0;i--){
            dungeon[row-1][i] = Math.max(dungeon[row-1][i+1]-dungeon[row-1][i],1);
        }
        //init last col
        for(int i = row-2;i>=0;i--){
            dungeon[i][col-1] = Math.max(dungeon[i+1][col-1]-dungeon[i][col-1],1);
        }
        for(int i = row-2;i>=0;i--){
            for(int j = col-2;j>=0;j--){
                dungeon[i][j] = Math.max(Math.min(dungeon[i+1][j],dungeon[i][j+1])-dungeon[i][j],1);
            }
        }
        return dungeon[0][0];
    }
}

代码2如下：

//当出现[[1,-3,3],[0,-2,0],[-3,-3,-3]]测试用例时出错
//原因是这个测试用例将会导致某节点的上节点为Node(3,4)，而左节点为Node(2,1)
//这样一来的话，我们不能确定当前节点应取上节点还是取下节点。因为这关系到以后的节点的选取。
public class Solution {
      class Node{
        int maxPoint;
        int curPoint;
        Node(int maxPoint,int curPoint){
            this.maxPoint = maxPoint;
            this.curPoint = curPoint;
        }
        Node(Node p){
            this.maxPoint = p.maxPoint;
            this.curPoint = p.curPoint;
        }
    }
    public int calculateMinimumHP(int[][] dungeon) {
        //使用二维DP算法，dp[i][j] = max(dp[i-1][j],dp[i][j-1])+dungeon[i][j];
        int row = dungeon.length;
        int col = dungeon[0].length;

        Node[][] dp = new Node[row][col];
        dp[0][0] = new Node(1,1);
        if(dungeon[0][0]>0){
            dp[0][0].curPoint = 1+dungeon[0][0];
        }else{
            dp[0][0].maxPoint = 1-dungeon[0][0];
        }
        //init first row
        for(int j = 1;j<col;j++){
            dp[0][j] = new Node(dp[0][j-1]);
            updatePoint(dp[0][j],dungeon[0][j]);
        }
        //init first col
        for(int i = 1;i<row;i++){
            dp[i][0] = new Node(dp[i-1][0]);
            updatePoint(dp[i][0],dungeon[i][0]);
        }

        for(int i = 1;i<row;i++){
            for(int j = 1;j<col;j++){
                Node up = new Node(dp[i-1][j]);
                updatePoint(up,dungeon[i][j]);
                Node left = new Node(dp[i][j-1]);
                updatePoint(left,dungeon[i][j]);

                dp[i][j] = up.maxPoint<left.maxPoint?up:left;
            }
        }
        return dp[row-1][col-1].maxPoint;
    }
    public void updatePoint(Node p,int cur){
        int val = p.curPoint+cur;
        if(val<1){
            p.curPoint = 1;
            p.maxPoint += (1-val);
        }else
            p.curPoint = val;
    }
}

代码3：小数据集可以通过，大数据集TLE

    int maxPoint=Integer.MAX_VALUE;
    int[][] dungeon;
    int endRow,endCol;
    public int calculateMinimumHP(int[][] dungeon) {
        this.dungeon = dungeon;
        endRow = dungeon.length;
        endCol = dungeon[0].length;
        dfs(0,0,1,1);
        return maxPoint;
    }
    private void dfs(int row,int col,int maxhp,int curhp){
        int val = curhp+dungeon[row][col];
        if(val<0){
            maxhp+=(1-val);
            curhp = 1;
        }else{
            curhp = val;
        }
        if(row+1<endRow)
            dfs(row+1,col,maxhp, curhp);
        if(col+1<endCol)
            dfs(row,col+1,maxhp,curhp);
        if(row==endRow-1&&col==endCol-1){
            if(maxhp<maxPoint)
                maxPoint = maxhp;
        }
    }