Skip to content

Commit 47339b2

Browse files
committed
feat: add solutions to lc problem: No.0174
No.0174.Dungeon Game
1 parent a2826d4 commit 47339b2

File tree

8 files changed

+294
-28
lines changed

8 files changed

+294
-28
lines changed

solution/0100-0199/0174.Dungeon Game/README.md

Lines changed: 115 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -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
### **...**

solution/0100-0199/0174.Dungeon Game/README_EN.md

Lines changed: 103 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,13 +49,115 @@
4949
### **Python3**
5050

5151
```python
52-
52+
class Solution:
53+
def calculateMinimumHP(self, dungeon: List[List[int]]) -> int:
54+
m, n = len(dungeon), len(dungeon[0])
55+
dp = [[inf] * (n + 1) for _ in range(m + 1)]
56+
dp[m][n - 1] = dp[m - 1][n] = 1
57+
for i in range(m - 1, -1, -1):
58+
for j in range(n - 1, -1, -1):
59+
dp[i][j] = max(
60+
1, min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j])
61+
return dp[0][0]
5362
```
5463

5564
### **Java**
5665

5766
```java
67+
class Solution {
68+
public int calculateMinimumHP(int[][] dungeon) {
69+
int m = dungeon.length, n = dungeon[0].length;
70+
int[][] dp = new int[m + 1][n + 1];
71+
for (var e : dp) {
72+
Arrays.fill(e, 1 << 30);
73+
}
74+
dp[m][n - 1] = dp[m - 1][n] = 1;
75+
for (int i = m - 1; i >= 0; --i) {
76+
for (int j = n - 1; j >= 0; --j) {
77+
dp[i][j] = Math.max(1, Math.min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j]);
78+
}
79+
}
80+
return dp[0][0];
81+
}
82+
}
83+
```
84+
85+
### **C++**
86+
87+
```cpp
88+
class Solution {
89+
public:
90+
int calculateMinimumHP(vector<vector<int>>& dungeon) {
91+
int m = dungeon.size(), n = dungeon[0].size();
92+
int dp[m + 1][n + 1];
93+
memset(dp, 0x3f, sizeof dp);
94+
dp[m][n - 1] = dp[m - 1][n] = 1;
95+
for (int i = m - 1; ~i; --i) {
96+
for (int j = n - 1; ~j; --j) {
97+
dp[i][j] = max(1, min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j]);
98+
}
99+
}
100+
return dp[0][0];
101+
}
102+
};
103+
```
104+
105+
### **Go**
106+
107+
```go
108+
func calculateMinimumHP(dungeon [][]int) int {
109+
m, n := len(dungeon), len(dungeon[0])
110+
dp := make([][]int, m+1)
111+
for i := range dp {
112+
dp[i] = make([]int, n+1)
113+
for j := range dp[i] {
114+
dp[i][j] = 1 << 30
115+
}
116+
}
117+
dp[m][n-1], dp[m-1][n] = 1, 1
118+
for i := m - 1; i >= 0; i-- {
119+
for j := n - 1; j >= 0; j-- {
120+
dp[i][j] = max(1, min(dp[i+1][j], dp[i][j+1])-dungeon[i][j])
121+
}
122+
}
123+
return dp[0][0]
124+
}
125+
126+
func max(a, b int) int {
127+
if a > b {
128+
return a
129+
}
130+
return b
131+
}
132+
133+
func min(a, b int) int {
134+
if a < b {
135+
return a
136+
}
137+
return b
138+
}
139+
```
58140

141+
### **C#**
142+
143+
```cs
144+
public class Solution {
145+
public int CalculateMinimumHP(int[][] dungeon) {
146+
int m = dungeon.Length, n = dungeon[0].Length;
147+
int[][] dp = new int[m + 1][];
148+
for (int i = 0; i < m + 1; ++i) {
149+
dp[i] = new int[n + 1];
150+
Array.Fill(dp[i], 1 << 30);
151+
}
152+
dp[m][n - 1] = dp[m - 1][n] = 1;
153+
for (int i = m - 1; i >= 0; --i) {
154+
for (int j = n - 1; j >= 0; --j) {
155+
dp[i][j] = Math.Max(1, Math.Min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j]);
156+
}
157+
}
158+
return dp[0][0];
159+
}
160+
}
59161
```
60162

61163
### **...**
Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
class Solution {
2+
public:
3+
int calculateMinimumHP(vector<vector<int>>& dungeon) {
4+
int m = dungeon.size(), n = dungeon[0].size();
5+
int dp[m + 1][n + 1];
6+
memset(dp, 0x3f, sizeof dp);
7+
dp[m][n - 1] = dp[m - 1][n] = 1;
8+
for (int i = m - 1; ~i; --i) {
9+
for (int j = n - 1; ~j; --j) {
10+
dp[i][j] = max(1, min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j]);
11+
}
12+
}
13+
return dp[0][0];
14+
}
15+
};
Lines changed: 11 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,22 +1,17 @@
1-
using System;
2-
31
public class Solution {
42
public int CalculateMinimumHP(int[][] dungeon) {
5-
var len1 = dungeon.Length;
6-
var len2 = len1 == 0 ? 0 : dungeon[0].Length;
7-
var f = new long[len1, len2];
8-
for (var i = len1 - 1; i >= 0; --i)
9-
{
10-
for (var j = len2 - 1; j >= 0; --j)
11-
{
12-
var down = (i == len1 - 1) ? long.MaxValue : f[i + 1, j];
13-
var right = (j == len2 - 1) ? long.MaxValue : f[i, j + 1];
14-
f[i, j] = Math.Min(down, right);
15-
if (f[i, j] == long.MaxValue) f[i, j] = 1;
16-
f[i, j] -= dungeon[i][j];
17-
if (f[i, j] < 1) f[i, j] = 1;
3+
int m = dungeon.Length, n = dungeon[0].Length;
4+
int[][] dp = new int[m + 1][];
5+
for (int i = 0; i < m + 1; ++i) {
6+
dp[i] = new int[n + 1];
7+
Array.Fill(dp[i], 1 << 30);
8+
}
9+
dp[m][n - 1] = dp[m - 1][n] = 1;
10+
for (int i = m - 1; i >= 0; --i) {
11+
for (int j = n - 1; j >= 0; --j) {
12+
dp[i][j] = Math.Max(1, Math.Min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j]);
1813
}
1914
}
20-
return (int) f[0, 0];
15+
return dp[0][0];
2116
}
2217
}
Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
func calculateMinimumHP(dungeon [][]int) int {
2+
m, n := len(dungeon), len(dungeon[0])
3+
dp := make([][]int, m+1)
4+
for i := range dp {
5+
dp[i] = make([]int, n+1)
6+
for j := range dp[i] {
7+
dp[i][j] = 1 << 30
8+
}
9+
}
10+
dp[m][n-1], dp[m-1][n] = 1, 1
11+
for i := m - 1; i >= 0; i-- {
12+
for j := n - 1; j >= 0; j-- {
13+
dp[i][j] = max(1, min(dp[i+1][j], dp[i][j+1])-dungeon[i][j])
14+
}
15+
}
16+
return dp[0][0]
17+
}
18+
19+
func max(a, b int) int {
20+
if a > b {
21+
return a
22+
}
23+
return b
24+
}
25+
26+
func min(a, b int) int {
27+
if a < b {
28+
return a
29+
}
30+
return b
31+
}

solution/0100-0199/0174.Dungeon Game/Solution.java

Lines changed: 8 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,14 @@
11
class Solution {
22
public int calculateMinimumHP(int[][] dungeon) {
3-
int row = dungeon.length, column = dungeon[0].length;
4-
int[][] dp = new int[row + 1][column + 1];
5-
for (int i = 0; i <= row; i++) {
6-
Arrays.fill(dp[i], Integer.MAX_VALUE);
3+
int m = dungeon.length, n = dungeon[0].length;
4+
int[][] dp = new int[m + 1][n + 1];
5+
for (var e : dp) {
6+
Arrays.fill(e, 1 << 30);
77
}
8-
dp[row][column - 1] = dp[row - 1][column] = 1;
9-
for (int i = row - 1; i > -1; i--) {
10-
for (int j = column - 1; j > -1; j--) {
11-
int min = Math.min(dp[i][j + 1], dp[i + 1][j]);
12-
dp[i][j] = Math.max(min - dungeon[i][j], 1);
8+
dp[m][n - 1] = dp[m - 1][n] = 1;
9+
for (int i = m - 1; i >= 0; --i) {
10+
for (int j = n - 1; j >= 0; --j) {
11+
dp[i][j] = Math.max(1, Math.min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j]);
1312
}
1413
}
1514
return dp[0][0];
Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
class Solution:
2+
def calculateMinimumHP(self, dungeon: List[List[int]]) -> int:
3+
m, n = len(dungeon), len(dungeon[0])
4+
dp = [[inf] * (n + 1) for _ in range(m + 1)]
5+
dp[m][n - 1] = dp[m - 1][n] = 1
6+
for i in range(m - 1, -1, -1):
7+
for j in range(n - 1, -1, -1):
8+
dp[i][j] = max(
9+
1, min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j])
10+
return dp[0][0]

solution/2400-2499/2486.Append Characters to String to Make Subsequence/README.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@
5757

5858
**方法一:双指针**
5959

60-
定义两个指针 $i$ 和 $j$,分别指向字符串 $s$ 和 $t$ 的首字符。遍历字符串 $t$,当 $s[i] \neq t[j]$ 时,$i$ 后移,直到 $s[i] = t[j]$ 或者 $i$ 到达字符串 $s$ 的末尾。如果 $i$ 到达字符串 $s$ 的末尾,说明 $t$ 中的字符 $t[j]$ 无法在 $s$ 中找到对应的字符,返回 $t$ 中剩余的字符数。否则,$i$ 和 $j$ 同时后移,继续遍历字符串 $t$。
60+
定义两个指针 $i$ 和 $j$,分别指向字符串 $s$ 和 $t$ 的首字符。遍历字符串 $t$,当 $s[i] \neq t[j]$ 时,指针 $i$ 后移,直到 $s[i] = t[j]$ 或者 $i$ 到达字符串 $s$ 的末尾。如果 $i$ 到达字符串 $s$ 的末尾,说明 $t$ 中的字符 $t[j]$ 无法在 $s$ 中找到对应的字符,返回 $t$ 中剩余的字符数。否则,将指针 $i$ 和 $j$ 同时后移,继续遍历字符串 $t$。
6161

6262
时间复杂度 $(m + n)$,空间复杂度 $O(1)$。其中 $m$ 和 $n$ 分别是字符串 $s$ 和 $t$ 的长度。
6363

0 commit comments

Comments
 (0)