【牛客网动态规划专项】DP12 龙与地下城游戏问题

题目描述

解题思路

备忘录

dp是一个与map相同大小的矩阵：

• dp[i][j]：从map[i][j]出发走到map[n-1][m-1]（终点）所需的最少初始血量
• 原问题解：dp[0][0]

状态转移方程

考虑从map[i][j]出发走到map[n-1][m-1]所需的最少初始血量dp[i][j]，需要满足以下两个条件：

1. 从map[i][j]出发前，也就是一步也没走的时候，要保证血量大于等于1: $$dp[i][j]\ge 1$$
2. 走了一步之后，也就是已经走到$map[i][j]$位置、正准备接着走到下一个位置$map[i_{next}][j_{next}]$的时候，要保证当前剩余血量大于等于从下一个位置出发走到终点所需的最少初始血量：
   $$\begin{array}{rl}dp[i][j]+map[i][j]& \ge dp[i_{next}][j_{next}]\\ dp[i][j]& \ge dp[i_{next}][j_{next}]-map[i][j]\end{array}$$

将这两个条件合并起来就是：
$$dp[i][j]=max\left\{\begin{array}{c}\begin{array}{rl}& 1\\ & dp[i_{next}][j_{next}]-map[i][j]\end{array}\end{array}\right\}\text{\hspace{1em}(1)}$$
如果下一个位置$map[i_{next}][j_{next}]$有多种选择，可以分别对每一种选择计算需要的最少初始血量（公式1），然后选择最小的一个：
$$dp[i][j]=min\left\{\begin{array}{c}max\{1,dp[i_{next1}][j_{next1}]-map[i][j]\}\\ max\{1,dp[i_{next2}][j_{next2}]-map[i][j]\}\\ ...\end{array}\right\}\text{\hspace{1em}(2)}$$

根据上面的公式得出下面的状态转移方程：

1. 最后一个位置（$i=n-1,j=m-1$）

   dp[n-1][m-1] = max(1, 1-map[n-1][m-1])
   

   因为没有下一个位置了，所以上面的第二个条件退化为“保证当前剩余血量大于等于1”，即
   $$\begin{array}{rl}dp[n-1][m-1]+map[n-1][m-1]& \ge 1\\ dp[n-1][m-1]& \ge 1-map[n-1][m-1]\end{array}$$
2. 最后一列（$j=m-1$）

   for i from n-2 to 0: 
   	dp[i][m-1] = max(1, dp[i+1][m-1] - map[i][m-1])
   

   map最后一列的每一个位置都只能向下走，即 $dp[i_{next}][j_{next}]=dp[i+1][m-1]$
3. 最后一行（$i=n-1$）

   for j from m-2 to 0:
   	dp[n-1][j] = max(1, dp[n-1][j+1] - map[n-1][j]),
   

   map最后一行的每一个位置都只能向右走，即 $dp[i_{next}][j_{next}]=dp[n-1][j+1]$
4. 一般情况（$0\le i\le n-2,0\le j\le m-2$）

   for i from n-2 to 0:
   	for j from m-2 to 0:
   		down = max(1, dp[i+1][j]-map[i][j]);
   	    right = max(1, dp[i][j+1]-map[i][j]);
   	    dp[i][j] = min(down, right);
   

   下一个位置有两种选择：
   • 向下走，即 $dp[i_{next1}][j_{next1}]=dp[i+1][j]$
   • 向右走，即 $dp[i_{next2}][j_{next2}]=dp[i][j+1]$

C++代码实现

#include 
#include 
using namespace std;

int n, m; 
int** map; // map: n*m
void input(){
   cin >> n >> m;

   map = new int*[n];
   for(int i=0; i<n; i++){
       map[i] = new int[m];
   }

   for(int i=0; i<n; i++){
       for(int j=0; j<m; j++){
           cin >> map[i][j];
       }
   }
}

int** dp; // 与map相同大小，dp: n*m
int solve(){
   dp = new int*[n];
   for(int i=0; i<n; i++){
       dp[i] = new int[m];
   }

   // dp[i][j]: 从map[i][j]位置走到map[n-1][m-1]位置所需的最少初始血量

   // init
   dp[n-1][m-1] = max(1, 1-map[n-1][m-1]);
    
   for(int i=n-2; i>=0; i--){
       dp[i][m-1] = max(1, dp[i+1][m-1] - map[i][m-1]);
   }

   for(int j=m-2; j>=0; j--){
       dp[n-1][j] = max(1, dp[n-1][j+1] - map[n-1][j]);
   }

   // bottom-up clac
   for(int i=n-2; i>=0; i--){
       for(int j=m-2; j>=0; j--){
           int down = max(1, dp[i+1][j]-map[i][j]);
           int right = max(1, dp[i][j+1]-map[i][j]);
           dp[i][j] = min(down, right);
       }
   }

   return dp[0][0];
}

int main() {
   input();
   cout << solve();
}