Skip to content

Commit ba46fd1

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1335
No.1335.Minimum Difficulty of a Job Schedule
1 parent 5a9b264 commit ba46fd1

File tree

6 files changed

+305
-2
lines changed

6 files changed

+305
-2
lines changed

‎solution/1300-1399/1335.Minimum Difficulty of a Job Schedule/README.md

Lines changed: 114 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -67,22 +67,135 @@
6767

6868
<!-- 这里可写通用的实现逻辑 -->
6969

70+
**方法一：动态规划**
71+
72+
我们定义 $f[i][j]$ 表示完成前 $i$ 项工作，且一共用了 $j$ 天的最小难度。初始时 $f[0][0] = 0$，其余 $f[i][j]$ 均为 $\infty$。
73+
74+
考虑第 $j$ 天的工作安排，我们可以枚举第 $j$ 天完成的工作 $[k,..i]$，那么有状态转移方程：
75+
76+
$$
77+
f[i][j] = \min_{k \in [1,i]} \{f[k-1][j-1] + \max_{k \leq t \leq i} \{jobDifficulty[t]\}\}
78+
$$
79+
80+
最终答案即为 $f[n][d]$。
81+
82+
时间复杂度 $O(n^2 \times d)$，空间复杂度 $O(n \times d)$。其中 $n$ 和 $d$ 分别为工作数量和需要计划的天数。
83+
7084
<!-- tabs:start -->
7185

7286
### **Python3**
7387

7488
<!-- 这里可写当前语言的特殊实现逻辑 -->
7589

7690
```python
77-
91+
class Solution:
92+
def minDifficulty(self, jobDifficulty: List[int], d: int) -> int:
93+
n = len(jobDifficulty)
94+
f = [[inf] * (d + 1) for _ in range(n + 1)]
95+
f[0][0] = 0
96+
for i, x in enumerate(jobDifficulty, 1):
97+
for j in range(1, d + 1):
98+
mx = 0
99+
for k in range(i, 0, -1):
100+
mx = max(mx, jobDifficulty[k - 1])
101+
f[i][j] = min(f[i][j], f[k - 1][j - 1] + mx)
102+
return f[n][d] if f[n][d] != inf else -1
78103
```
79104

80105
### **Java**
81106

82107
<!-- 这里可写当前语言的特殊实现逻辑 -->
83108

84109
```java
110+
class Solution {
111+
public int minDifficulty(int[] jobDifficulty, int d) {
112+
int n = jobDifficulty.length;
113+
final int inf = 1 << 30;
114+
int[][] f = new int[n + 1][d + 1];
115+
for (int[] g : f) {
116+
Arrays.fill(g, inf);
117+
}
118+
f[0][0] = 0;
119+
for (int i = 1; i <= n; ++i) {
120+
for (int j = 1; j <= d; ++j) {
121+
int mx = 0;
122+
for (int k = i; k > 0; --k) {
123+
mx = Math.max(mx, jobDifficulty[k - 1]);
124+
f[i][j] = Math.min(f[i][j], f[k - 1][j - 1] + mx);
125+
}
126+
}
127+
}
128+
return f[n][d] < inf ? f[n][d] : -1;
129+
}
130+
}
131+
```
132+
133+
### **C++**
134+
135+
```cpp
136+
class Solution {
137+
public:
138+
int minDifficulty(vector<int>& jobDifficulty, int d) {
139+
int n = jobDifficulty.size();
140+
int f[n + 1][d + 1];
141+
memset(f, 0x3f, sizeof(f));
142+
f[0][0] = 0;
143+
for (int i = 1; i <= n; ++i) {
144+
for (int j = 1; j <= d; ++j) {
145+
int mx = 0;
146+
for (int k = i; k; --k) {
147+
mx = max(mx, jobDifficulty[k - 1]);
148+
f[i][j] = min(f[i][j], f[k - 1][j - 1] + mx);
149+
}
150+
}
151+
}
152+
return f[n][d] == 0x3f3f3f3f ? -1 : f[n][d];
153+
}
154+
};
155+
```
85156
157+
### **Go**
158+
159+
```go
160+
func minDifficulty(jobDifficulty []int, d int) int {
161+
n := len(jobDifficulty)
162+
f := make([][]int, n+1)
163+
const inf = 1 << 30
164+
for i := range f {
165+
f[i] = make([]int, d+1)
166+
for j := range f[i] {
167+
f[i][j] = inf
168+
}
169+
}
170+
f[0][0] = 0
171+
for i := 1; i <= n; i++ {
172+
for j := 1; j <= d; j++ {
173+
mx := 0
174+
for k := i; k > 0; k-- {
175+
mx = max(mx, jobDifficulty[k-1])
176+
f[i][j] = min(f[i][j], f[k-1][j-1]+mx)
177+
}
178+
}
179+
}
180+
if f[n][d] == inf {
181+
return -1
182+
}
183+
return f[n][d]
184+
}
185+
186+
func max(a, b int) int {
187+
if a > b {
188+
return a
189+
}
190+
return b
191+
}
192+
193+
func min(a, b int) int {
194+
if a < b {
195+
return a
196+
}
197+
return b
198+
}
86199
```
87200

88201
### **...**

‎solution/1300-1399/1335.Minimum Difficulty of a Job Schedule/README_EN.md

Lines changed: 100 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -55,13 +55,112 @@ The difficulty of the schedule = 6 + 1 = 7
5555
### **Python3**
5656

5757
```python
58-
58+
class Solution:
59+
def minDifficulty(self, jobDifficulty: List[int], d: int) -> int:
60+
n = len(jobDifficulty)
61+
f = [[inf] * (d + 1) for _ in range(n + 1)]
62+
f[0][0] = 0
63+
for i, x in enumerate(jobDifficulty, 1):
64+
for j in range(1, d + 1):
65+
mx = 0
66+
for k in range(i, 0, -1):
67+
mx = max(mx, jobDifficulty[k - 1])
68+
f[i][j] = min(f[i][j], f[k - 1][j - 1] + mx)
69+
return f[n][d] if f[n][d] != inf else -1
5970
```
6071

6172
### **Java**
6273

6374
```java
75+
class Solution {
76+
public int minDifficulty(int[] jobDifficulty, int d) {
77+
int n = jobDifficulty.length;
78+
final int inf = 1 << 30;
79+
int[][] f = new int[n + 1][d + 1];
80+
for (int[] g : f) {
81+
Arrays.fill(g, inf);
82+
}
83+
f[0][0] = 0;
84+
for (int i = 1; i <= n; ++i) {
85+
for (int j = 1; j <= d; ++j) {
86+
int mx = 0;
87+
for (int k = i; k > 0; --k) {
88+
mx = Math.max(mx, jobDifficulty[k - 1]);
89+
f[i][j] = Math.min(f[i][j], f[k - 1][j - 1] + mx);
90+
}
91+
}
92+
}
93+
return f[n][d] < inf ? f[n][d] : -1;
94+
}
95+
}
96+
```
97+
98+
### **C++**
99+
100+
```cpp
101+
class Solution {
102+
public:
103+
int minDifficulty(vector<int>& jobDifficulty, int d) {
104+
int n = jobDifficulty.size();
105+
int f[n + 1][d + 1];
106+
memset(f, 0x3f, sizeof(f));
107+
f[0][0] = 0;
108+
for (int i = 1; i <= n; ++i) {
109+
for (int j = 1; j <= d; ++j) {
110+
int mx = 0;
111+
for (int k = i; k; --k) {
112+
mx = max(mx, jobDifficulty[k - 1]);
113+
f[i][j] = min(f[i][j], f[k - 1][j - 1] + mx);
114+
}
115+
}
116+
}
117+
return f[n][d] == 0x3f3f3f3f ? -1 : f[n][d];
118+
}
119+
};
120+
```
64121
122+
### **Go**
123+
124+
```go
125+
func minDifficulty(jobDifficulty []int, d int) int {
126+
n := len(jobDifficulty)
127+
f := make([][]int, n+1)
128+
const inf = 1 << 30
129+
for i := range f {
130+
f[i] = make([]int, d+1)
131+
for j := range f[i] {
132+
f[i][j] = inf
133+
}
134+
}
135+
f[0][0] = 0
136+
for i := 1; i <= n; i++ {
137+
for j := 1; j <= d; j++ {
138+
mx := 0
139+
for k := i; k > 0; k-- {
140+
mx = max(mx, jobDifficulty[k-1])
141+
f[i][j] = min(f[i][j], f[k-1][j-1]+mx)
142+
}
143+
}
144+
}
145+
if f[n][d] == inf {
146+
return -1
147+
}
148+
return f[n][d]
149+
}
150+
151+
func max(a, b int) int {
152+
if a > b {
153+
return a
154+
}
155+
return b
156+
}
157+
158+
func min(a, b int) int {
159+
if a < b {
160+
return a
161+
}
162+
return b
163+
}
65164
```
66165

67166
### **...**

‎solution/1300-1399/1335.Minimum Difficulty of a Job Schedule/Solution.cpp

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
class Solution {
2+
public:
3+
int minDifficulty(vector<int>& jobDifficulty, int d) {
4+
int n = jobDifficulty.size();
5+
int f[n + 1][d + 1];
6+
memset(f, 0x3f, sizeof(f));
7+
f[0][0] = 0;
8+
for (int i = 1; i <= n; ++i) {
9+
for (int j = 1; j <= d; ++j) {
10+
int mx = 0;
11+
for (int k = i; k; --k) {
12+
mx = max(mx, jobDifficulty[k - 1]);
13+
f[i][j] = min(f[i][j], f[k - 1][j - 1] + mx);
14+
}
15+
}
16+
}
17+
return f[n][d] == 0x3f3f3f3f ? -1 : f[n][d];
18+
}
19+
};

‎solution/1300-1399/1335.Minimum Difficulty of a Job Schedule/Solution.go

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
func minDifficulty(jobDifficulty []int, d int) int {
2+
n := len(jobDifficulty)
3+
f := make([][]int, n+1)
4+
const inf = 1 << 30
5+
for i := range f {
6+
f[i] = make([]int, d+1)
7+
for j := range f[i] {
8+
f[i][j] = inf
9+
}
10+
}
11+
f[0][0] = 0
12+
for i := 1; i <= n; i++ {
13+
for j := 1; j <= d; j++ {
14+
mx := 0
15+
for k := i; k > 0; k-- {
16+
mx = max(mx, jobDifficulty[k-1])
17+
f[i][j] = min(f[i][j], f[k-1][j-1]+mx)
18+
}
19+
}
20+
}
21+
if f[n][d] == inf {
22+
return -1
23+
}
24+
return f[n][d]
25+
}
26+
27+
func max(a, b int) int {
28+
if a > b {
29+
return a
30+
}
31+
return b
32+
}
33+
34+
func min(a, b int) int {
35+
if a < b {
36+
return a
37+
}
38+
return b
39+
}

‎solution/1300-1399/1335.Minimum Difficulty of a Job Schedule/Solution.java

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
class Solution {
2+
public int minDifficulty(int[] jobDifficulty, int d) {
3+
int n = jobDifficulty.length;
4+
final int inf = 1 << 30;
5+
int[][] f = new int[n + 1][d + 1];
6+
for (int[] g : f) {
7+
Arrays.fill(g, inf);
8+
}
9+
f[0][0] = 0;
10+
for (int i = 1; i <= n; ++i) {
11+
for (int j = 1; j <= d; ++j) {
12+
int mx = 0;
13+
for (int k = i; k > 0; --k) {
14+
mx = Math.max(mx, jobDifficulty[k - 1]);
15+
f[i][j] = Math.min(f[i][j], f[k - 1][j - 1] + mx);
16+
}
17+
}
18+
}
19+
return f[n][d] < inf ? f[n][d] : -1;
20+
}
21+
}

‎solution/1300-1399/1335.Minimum Difficulty of a Job Schedule/Solution.py

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
class Solution:
2+
def minDifficulty(self, jobDifficulty: List[int], d: int) -> int:
3+
n = len(jobDifficulty)
4+
f = [[inf] * (d + 1) for _ in range(n + 1)]
5+
f[0][0] = 0
6+
for i, x in enumerate(jobDifficulty, 1):
7+
for j in range(1, d + 1):
8+
mx = 0
9+
for k in range(i, 0, -1):
10+
mx = max(mx, jobDifficulty[k - 1])
11+
f[i][j] = min(f[i][j], f[k - 1][j - 1] + mx)
12+
return f[n][d] if f[n][d] != inf else -1

0 commit comments

Comments
 (0)