leetcode每日一题 使用golang和java实现 地下城游戏

地下城游戏题目要求

一些恶魔抓住了公主（P）并将她关在了地下城的右下角。地下城是由 M x N 个房间组成的二维网格。我们英勇的骑士（K）最初被安置在左上角的房间里，他必须穿过地下城并通过对抗恶魔来拯救公主。

骑士的初始健康点数为一个正整数。如果他的健康点数在某一时刻降至 0 或以下，他会立即死亡。

有些房间由恶魔守卫，因此骑士在进入这些房间时会失去健康点数（若房间里的值为负整数，则表示骑士将损失健康点数）；其他房间要么是空的（房间里的值为 0），要么包含增加骑士健康点数的魔法球（若房间里的值为正整数，则表示骑士将增加健康点数）。

为了尽快到达公主，骑士决定每次只向右或向下移动一步。

编写一个函数来计算确保骑士能够拯救到公主所需的最低初始健康点数。

说明:
骑士的健康点数没有上限。
任何房间都可能对骑士的健康点数造成威胁，也可能增加骑士的健康点数，包括骑士进入的左上角房间以及公主被监禁的右下角房间。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/dungeon-game
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题过程

首先我们可以看出来这是一个dp（动态规划）问题。由于我们想要求一个骑士所需要的最小的健康点数问题，所以应该是一个反向dp问题，即在每种方式下所需要的最小的初始值。
使用golang实现

func calculateMinimumHP(dungeon [][]int) int {
    m := len(dungeon) 
    n := len(dungeon[0]) 
    dp := make([][]int, m+1)
    for i :=0; i< m; i++{
        dp[i] = make([]int, n+1)
    }
    dp[m-1][n-1] = dungeon[m-1][n-1]
    if dp[m-1][n-1]>0{
        dp[m-1][n-1] = 0
    }
    for i:= m-2;i>=0; i-- {
        dp[i][n-1] =dp[i+1][n-1] + dungeon[i][n-1]
        if dp[i][n-1]>=1{
            dp[i][n-1] = 0
        }
    }
    for j:= n-2; j>=0; j--{
        dp[m-1][j]= dp[m-1][j+1] + dungeon[m-1][j]
        if dp[m-1][j] >=1{
            dp[m-1][j]= 0
        }
    }
    for i:= m-2; i>=0 ; i-- {
        for j := n-2; j >=0 ; j--{
            dp[i][j] = max(dp[i][j+1], dp[i+1][j]) + dungeon[i][j]
            if dp[i][j]>=1{
                dp[i][j]=0
            }
        }
    }
    if dp[0][0] < 0{
        return  1 - dp[0][0]
    }
    return dp[0][0] + 1
}

func max(a,b int) int{
    if a > b{
        return a
    }
    return b
}

使用java实现

class Solution {
    public int calculateMinimumHP(int[][] dungeon) {
        int row = dungeon.length, col = dungeon[0].length;
        if (dungeon[row - 1][col - 1] > 0) dungeon[row - 1][col - 1] = 0;
        for (int i = row - 2; i >= 0; i--){
            dungeon[i][col - 1] = dungeon[i][col - 1] + dungeon[i + 1][col - 1];
            if (dungeon[i][col - 1] > 0) dungeon[i][col - 1] = 0;
        }
        for (int i = col - 2; i >= 0; i--){
            dungeon[row - 1][i] = dungeon[row - 1][i] + dungeon[row - 1][i + 1];
            if (dungeon[row - 1][i] > 0) dungeon[row - 1][i] = 0;
        }
        for (int i = row - 2; i >= 0; i--){
            for (int j = col - 2; j >= 0; j--){
                dungeon[i][j] = dungeon[i][j] + Math.max(dungeon[i + 1][j], dungeon[i][j + 1]);
                if (dungeon[i][j] > 0) dungeon[i][j] = 0;
            }
        }
        int min = 1;
        if(dungeon[0][0]<0){
            min = - dungeon[0][0] + 1;
        }
        
        return min;
    }
}

首先，我们把二维数组的每个数字都变成从该位置起，到公主的房间这一最短路径所需要的健康值，例如如下实例：

原题中所给的每个房间的健康值增减为

-2	-3	3
-5	-10	1
10	30	-5

转化完成后，出现如下：

-6	-4	-1
-5	-10	-4
0	0	-5

即每个位置到达公主房间所需要的最小的健康值，但是由于健康值为0就是死亡，所以骑士在每个位置所需要的健康值为所需要的数字的相反数+1。

dp的基本思想

动态规划算法于分治法相似，都是将待求解的问题分成若干个子问题。在本题中的体现为：将每一步都求出最优解，然后组合起来寻求最优解。