动态规划+使用数组

1. Dungeon Game

1. 题目要求
   地牢由M x N房间在2维网格。我们英勇的骑士(K)最初定位在左上的房间,要到达地牢右下角拯救公主。骑士有一个初始健康点（一个正整数）。如果在任何时候或低于他的健康点下降到0,他立即死亡。一些房间有恶魔守卫,所以骑士失去健康(负整数)进入这些房间,其他房间都是空的(0)或含有神奇的魔法球,增加骑士的健康(正整数)。
   编写一个函数来确定骑士能够拯救公主的最小初始健康。
2. 解题思路
   使用二维数组H，H[i][j]表示骑士要想救出公主在改点时应具备的最低健康值。从后往前求解H，先求出边界值， 再求解中间值，取往下走和往右走的最小值。

public int calculateMinimumHP(int[][] dungeon) {
        if(dungeon == null || dungeon.length == 0 || dungeon[0].length ==0)
            return 0;
        int row = dungeon.length;
        int col = dungeon[0].length;
        int H[][] = new int[row][col];
        H[row-1][col-1] = Math.max((1 - dungeon[row-1][col-1]),1);
        for(int i = row - 2; i >=0; i--){
            H[i][col - 1] = Math.max((H[i+1][col-1] - dungeon[i][col-1]),1);
        }

        for(int i = col - 2; i >=0; i--){
            H[row-1][i] = Math.max((H[row-1][i+1] - dungeon[row-1][i]),1);
        }

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

2. Minimum Path Sum

1. 问题描述
   给定一个m x n网格充满了非负数字,找到一条从左上角到右下角最小化所有数字的总和。
2. 解题思路
   思路一:使用动态规划，创建二维数组P，P[i][j]表示从左上角到改点的最小路径。P[i][j] = grid[i][j] + Math.min(P[i-1][j],P[i][j-1])

public int minPathSum(int[][] grid) {
        if(grid == null || grid.length == 0 || grid[0].length == 0)
            return 0;
        int col = grid[0].length;
        int row = grid.length;
        int P[][] = new int[row][col];
        P[0][0] = grid[0][0];
        for(int i = 1; i <= col-1; i++){
            P[0][i] = P[0][i-1] + grid[0][i];
        }

        for(int i = 1; i <= row-1; i++){
            P[i][0] = P[i-1][0] + grid[i][0];
        }

        for(int i = 1; i <= row-1; i++){
            for(int j = 1; j <= col-1; j++){
                P[i][j] = grid[i][j] + Math.min(P[i-1][j],P[i][j-1]);
            }
        }
        return P[row-1][col-1];
    }

思路二：使用动态规划，不使用数组，直接修改原数组。

public int minPathSum(int[][] grid) {
    int m = grid.length;// row
    int n = grid[0].length; // column
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (i == 0 && j != 0) {
                grid[i][j] = grid[i][j] + grid[i][j - 1];
            } else if (i != 0 && j == 0) {
                grid[i][j] = grid[i][j] + grid[i - 1][j];
            } else if (i == 0 && j == 0) {
                grid[i][j] = grid[i][j];
            } else {
                grid[i][j] = Math.min(grid[i][j - 1], grid[i - 1][j])
                        + grid[i][j];
            }
        }
    }

    return grid[m - 1][n - 1];
}

思路三：使用动态规划，不使用二维数组，直接修改原数组。

public int minPathSum(int[][] grid) {
        if(grid == null || grid.length == 0 || grid[0].length == 0)
            return 0;
        int col = grid[0].length;
        int row = grid.length;
        int P[] = new int[col];
        P[0] = grid[0][0];
        for(int i = 1; i <= col-1; i++){
            P[i] = P[i-1] + grid[0][i];
        }

        for(int i = 1; i <= row-1; i++){
            P[0] += grid[i][0];
            for(int j = 1; j <= col-1; j++){
                P[j] = grid[i][j] + Math.min(P[j],P[j-1]);
            }
        }

        return P[col-1];
    }

2.Unique Paths

1. 题目要求

   

2. 解题思路
   方法一：动态规划+二维数组

public int uniquePaths(int m, int n) {
        if(m==0 || n==0)
            return 0;
        if(m==1 || n==1)
            return 1;
        int path[][] = new int[m][n];
        path[0][0] = 1;
        for(int i = 1; i < n; i++){
            path[0][i] = 1;
        }
        for(int j = 1; j < m; j++){
            path[j][0] = 1;
        }
        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                path[i][j] = path[i-1][j] + path[i][j-1];
            }
        }
        return path[m-1][n-1];
    }

方法二：动态规划+一维数组

public int uniquePaths(int m, int n) {
        if(m==0 || n==0)
            return 0;
        if(m==1 || n==1)
            return 1;
        int path[] = new int[n];
        for(int i = 0; i < n; i++){
            path[i] = 1;
        }

        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                path[j] = path[j-1] + path[j];
            }
        }
        return path[n-1];
    }

3.Unique Paths II

1. 题目描述
   与上题情况相似，只是一些网格中存在障碍用1表示，其他用0表示。
2. 解题思路
   法一：动态规划+二维数组

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        if(obstacleGrid == null)
            return 0;
        if(obstacleGrid[0][0] == 1)
            return 0;
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int path[][] = new int[m][n];
        path[0][0] = 1;
        for(int i = 1; i < n; i++){
            path[0][i] = (path[0][i-1] == 1 && obstacleGrid[0][i] != 1)?1:0;
        }

        for(int j = 1; j < m; j++){
            path[j][0] = (path[j-1][0] == 1 && obstacleGrid[j][0] != 1)?1:0;
        }

        for(int i = 1; i < m; i++){
            for(int j = 1; j < n; j++){
                if(obstacleGrid[i][j]==1)
                    path[i][j] = 0;
                else
                    path[i][j] = path[i][j-1] +path[i-1][j];
            }
        }
        return path[m-1][n-1];
    }

法二：动态规划+一维数组

public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        if(obstacleGrid == null)
            return 0;
        if(obstacleGrid[0][0] == 1)
            return 0;
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int path[] = new int[n];
        path[0] = 1;
        for(int i = 1; i < n; i++){
            path[i] = (path[i-1] == 1 && obstacleGrid[0][i] != 1)?1:0;
        }
        for(int i = 1; i < m; i++){
            if(path[0]!=0 && obstacleGrid[i][0]!=1)
                path[0] = 1;
            else
                path[0] = 0;
            for(int j = 1; j < n; j++){
                if(obstacleGrid[i][j]==1)
                    path[j] = 0;
                else{
                    path[j] = path[j-1] +path[j];
                }

            }
        }
        return path[n-1];
    }