@@ -97,22 +97,136 @@ table.dungeon, .dungeon th, .dungeon td {
9797
9898<!-- 这里可写通用的实现逻辑 -->
9999
100+ ** 方法一：动态规划**
101+
102+ 定义 $dp[ i] [ j ] $ 表示从 $(i, j)$ 到终点所需的最小初始值，那么 $dp[ i] [ j ] $ 的值可以由 $dp[ i+1] [ j ] $ 和 $dp[ i] [ j+1 ] $ 得到，即：
103+
104+ $$
105+ dp[i][j] = \max(\min(dp[i+1][j], dp[i][j+1]) - dungeon[i][j], 1)
106+ $$
107+
108+ 初始时 $dp[ m] [ n-1 ] $ 和 $dp[ m-1] [ n ] $ 都为 $1$，其他位置的值为最大值。
109+
110+ 时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为地牢的行数和列数。
111+
100112<!-- tabs:start -->
101113
102114### ** Python3**
103115
104116<!-- 这里可写当前语言的特殊实现逻辑 -->
105117
106118``` python
107-
119+ class Solution :
120+ def calculateMinimumHP (self dungeon : List[List[int ]]) -> int :
121+ m, n = len (dungeon), len (dungeon[0 ])
122+ dp = [[inf] * (n + 1 ) for _ in range (m + 1 )]
123+ dp[m][n - 1 ] = dp[m - 1 ][n] = 1
124+ for i in range (m - 1 , - 1 , - 1 ):
125+ for j in range (n - 1 , - 1 , - 1 ):
126+ dp[i][j] = max (
127+ 1 , min (dp[i + 1 ][j], dp[i][j + 1 ]) - dungeon[i][j])
128+ return dp[0 ][0 ]
108129```
109130
110131### ** Java**
111132
112133<!-- 这里可写当前语言的特殊实现逻辑 -->
113134
114135``` java
136+ class Solution {
137+ public int calculateMinimumHP (int [][] dungeon ) {
138+ int m = dungeon. length, n = dungeon[0 ]. length;
139+ int [][] dp = new int [m + 1 ][n + 1 ];
140+ for (var e : dp) {
141+ Arrays . fill(e, 1 << 30 );
142+ }
143+ dp[m][n - 1 ] = dp[m - 1 ][n] = 1 ;
144+ for (int i = m - 1 ; i >= 0 ; -- i) {
145+ for (int j = n - 1 ; j >= 0 ; -- j) {
146+ dp[i][j] = Math . max(1 , Math . min(dp[i + 1 ][j], dp[i][j + 1 ]) - dungeon[i][j]);
147+ }
148+ }
149+ return dp[0 ][0 ];
150+ }
151+ }
152+ ```
153+
154+ ### ** C++**
155+
156+ ``` cpp
157+ class Solution {
158+ public:
159+ int calculateMinimumHP(vector<vector<int >>& dungeon) {
160+ int m = dungeon.size(), n = dungeon[ 0] .size();
161+ int dp[ m + 1] [ n + 1 ] ;
162+ memset(dp, 0x3f, sizeof dp);
163+ dp[ m] [ n - 1 ] = dp[ m - 1] [ n ] = 1;
164+ for (int i = m - 1; ~ i; --i) {
165+ for (int j = n - 1; ~ j; --j) {
166+ dp[ i] [ j ] = max(1, min(dp[ i + 1] [ j ] , dp[ i] [ j + 1 ] ) - dungeon[ i] [ j ] );
167+ }
168+ }
169+ return dp[ 0] [ 0 ] ;
170+ }
171+ };
172+ ```
173+
174+ ### **Go**
175+
176+ ```go
177+ func calculateMinimumHP(dungeon [][]int) int {
178+ m, n := len(dungeon), len(dungeon[0])
179+ dp := make([][]int, m+1)
180+ for i := range dp {
181+ dp[i] = make([]int, n+1)
182+ for j := range dp[i] {
183+ dp[i][j] = 1 << 30
184+ }
185+ }
186+ dp[m][n-1], dp[m-1][n] = 1, 1
187+ for i := m - 1; i >= 0; i-- {
188+ for j := n - 1; j >= 0; j-- {
189+ dp[i][j] = max(1, min(dp[i+1][j], dp[i][j+1])-dungeon[i][j])
190+ }
191+ }
192+ return dp[0][0]
193+ }
194+
195+ func max(a, b int) int {
196+ if a > b {
197+ return a
198+ }
199+ return b
200+ }
115201
202+ func min(a, b int) int {
203+ if a < b {
204+ return a
205+ }
206+ return b
207+ }
208+ ```
209+
210+ ### ** C#**
211+
212+ ``` cs
213+ public class Solution {
214+ public int CalculateMinimumHP (int [][] dungeon ) {
215+ int m = dungeon .Length , n = dungeon [0 ].Length ;
216+ int [][] dp = new int [m + 1 ][];
217+ for (int i = 0 ; i < m + 1 ; ++ i ) {
218+ dp [i ] = new int [n + 1 ];
219+ Array .Fill (dp [i ], 1 << 30 );
220+ }
221+ dp [m ][n - 1 ] = dp [m - 1 ][n ] = 1 ;
222+ for (int i = m - 1 ; i >= 0 ; -- i ) {
223+ for (int j = n - 1 ; j >= 0 ; -- j ) {
224+ dp [i ][j ] = Math .Max (1 , Math .Min (dp [i + 1 ][j ], dp [i ][j + 1 ]) - dungeon [i ][j ]);
225+ }
226+ }
227+ return dp [0 ][0 ];
228+ }
229+ }
116230```
117231
118232### ** ...**
0 commit comments