LintCode 1346: Dungeon Game (DP好题)

最新推荐文章于 2024-10-01 18:52:56 发布

原创最新推荐文章于 2024-10-01 18:52:56 发布 · 置顶 · 300 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#algorithm #动态规划

探讨如何计算骑士在迷宫中救援公主所需的最小初始生命值，避免途中被恶魔击败，采用动态规划方法解决这一经典算法问题。

Description

中文English

The demons had captured the princess (P) and imprisoned her in the bottom-right corner of a dungeon. The dungeon consists of M x N rooms laid out in a 2D grid. Our valiant knight (K) was initially positioned in the top-left room and must fight his way through the dungeon to rescue the princess.

The knight has an initial health point represented by a positive integer. If at any point his health point drops to 0 or below, he dies immediately.

Some of the rooms are guarded by demons, so the knight loses health (negative integers) upon entering these rooms; other rooms are either empty (0's) or contain magic orbs that increase the knight's health (positive integers).

In order to reach the princess as quickly as possible, the knight decides to move only rightward or downward in each step.

Write a function to determine the knight's minimum initial health so that he is able to rescue the princess.

For example, given the dungeon below, the initial health of the knight must be at least 7 if he follows the optimal path RIGHT-> RIGHT -> DOWN -> DOWN.

| -2(K)   | -3     | 3        |
| -5      | -10    | 1        |
| 10      | 30     | -5(P)    |

The knight's health has no upper bound.
Any room can contain threats or power-ups, even the first room the knight enters and the bottom-right room where the princess is imprisoned.

解法1：DP。

注意这题不能用BFS。因为BFS是求最短路径或者可行解。而这里是求最优路径或最优值。这里最优路径未必最短，用BFS不可行，但是用DP是可行的。

DP思路就是从后往前倒推。dp[i][j]表示房间[i][j]王子初来的时候的最小应该满足的血值。

1）注意从公主的右侧和下侧房间开始，王子的血应该是1。

2）每个房间的王子初来的血值应该等于其右侧和下侧房间的血的最小值减去该房间本来的血值，但至少要为1。

3）每个房间的初始值设为INT_MAX。

class Solution {
public:
    /**
     * @param dungeon: a 2D array
     * @return: return a integer
     */
    int calculateMinimumHP(vector<vector<int>> &dungeon) {
        int nRow = dungeon.size();
        int nCol = dungeon[0].size();
        
        vector<vector<int>> dp(nRow + 1, vector<int>(nCol + 1, INT_MAX));
        dp[nRow][nCol - 1] = 1;
        dp[nRow - 1][nCol] = 1;
        
        for (int i = nRow - 1; i >= 0; --i) {
            for (int j = nCol - 1; j >= 0; --j) {
                dp[i][j] = max(1, min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j]);
            }
        }
        
        return dp[0][0];
    }
};

解法2：DP+空间优化

class Solution {
public:
    /**
     * @param dungeon: a 2D array
     * @return: return a integer
     */
    int calculateMinimumHP(vector<vector<int>> &dungeon) {
        int nRow = dungeon.size();
        int nCol = dungeon[0].size();
        
        vector<int> dp(nCol + 1, INT_MAX);
        dp[nCol - 1] = 1;

        for (int i = nRow - 1; i >= 0; --i) {
            for (int j = nCol - 1; j >= 0; --j) {
                dp[j] = max(1, min(dp[j], dp[j + 1]) - dungeon[i][j]);
            }
        }
        
        return dp[0];
    }
};

为什么这里空间可以优化呢？这个实际上和01背包问题的优化是一样的，

注意
dp[j] = max(1, min(dp[j], dp[j + 1]) - dungeon[i][j]);
和
dp[i][j] = max(1, min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j]);
是等价的。

对解法1来说，因为i和j都是从大到小，所以每次都是先计算dp[i+1][j], dp[i][j+1]，然后再计算dp[i][j]。
对于每个i，j循环结束后，得到dp[i][0]，即房间[i][0]的王子初入血值。
而这个也就是解法2中，每个i，j循环结束后得到的dp[j]的值。

解法3：二分+DP

总体效率不如解法1和解法2。下次做。