Skip to content

Commit e998e4e

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1125
No.1125.Smallest Sufficient Team
1 parent 9be3fcd commit e998e4e

File tree

4 files changed

+236
-4
lines changed

4 files changed

+236
-4
lines changed

‎solution/1100-1199/1125.Smallest Sufficient Team/README.md

Lines changed: 80 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -54,22 +54,100 @@
5454

5555
<!-- 这里可写通用的实现逻辑 -->
5656

57+
**方法一：状态压缩 + 记忆化搜索**
58+
5759
<!-- tabs:start -->
5860

5961
### **Python3**
6062

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

6365
```python
64-
66+
class Solution:
67+
def smallestSufficientTeam(self, req_skills: List[str], people: List[List[str]]) -> List[int]:
68+
@cache
69+
def dfs(i, state):
70+
if i == n:
71+
return [] if state == (1 << m) - 1 else None
72+
ans1 = dfs(i + 1, state)
73+
ans2 = dfs(i + 1, state | ps[i])
74+
if ans1 is None and ans2 is None:
75+
return None
76+
if ans1 is None:
77+
return [i] + ans2
78+
if ans2 is None:
79+
return ans1
80+
return min(ans1, [i] + ans2, key=len)
81+
82+
d = {s: i for i, s in enumerate(req_skills)}
83+
m = len(req_skills)
84+
n = len(people)
85+
ps = [0] * n
86+
for i, skills in enumerate(people):
87+
for skill in skills:
88+
ps[i] |= 1 << d[skill]
89+
return dfs(0, 0)
6590
```
6691

6792
### **Java**
6893

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

7196
```java
72-
97+
class Solution {
98+
private int m;
99+
private int n;
100+
private int[] ps;
101+
private int[][][] f;
102+
private static final int MX = 100;
103+
104+
public int[] smallestSufficientTeam(String[] req_skills, List<List<String>> people) {
105+
m = req_skills.length;
106+
n = people.size();
107+
ps = new int[n];
108+
f = new int[n][1 << m][];
109+
Map<String, Integer> d = new HashMap<>();
110+
for (int i = 0; i < m; ++i) {
111+
d.put(req_skills[i], i);
112+
}
113+
for (int i = 0; i < n; ++i) {
114+
for (String skill : people.get(i)) {
115+
ps[i] |= 1 << d.get(skill);
116+
}
117+
}
118+
return dfs(0, 0);
119+
}
120+
121+
private int[] dfs(int i, int state) {
122+
if (i == n) {
123+
return state == (1 << m) - 1 ? new int[0] : add(new int[0], MX);
124+
}
125+
if (f[i][state] != null) {
126+
return f[i][state];
127+
}
128+
int[] ans1 = dfs(i + 1, state);
129+
int[] ans2 = dfs(i + 1, state | ps[i]);
130+
if (ans1.length > 0 && ans1[0] == MX && ans2.length > 0 && ans2[0] == MX) {
131+
return f[i][state] = ans1;
132+
}
133+
if (ans1.length > 0 && ans1[0] == MX) {
134+
return f[i][state] = add(ans2, i);
135+
}
136+
if (ans2.length > 0 && ans2[0] == MX) {
137+
return f[i][state] = ans1;
138+
}
139+
if (ans1.length < ans2.length + 1) {
140+
return f[i][state] = ans1;
141+
}
142+
return f[i][state] = add(ans2, i);
143+
}
144+
145+
private int[] add(int[] nums, int x) {
146+
int[] copy = Arrays.copyOf(nums, nums.length + 1);
147+
copy[copy.length - 1] = x;
148+
return copy;
149+
}
150+
}
73151
```
74152

75153
### **...**

‎solution/1100-1199/1125.Smallest Sufficient Team/README_EN.md

Lines changed: 78 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -48,13 +48,89 @@
4848
### **Python3**
4949

5050
```python
51-
51+
class Solution:
52+
def smallestSufficientTeam(self, req_skills: List[str], people: List[List[str]]) -> List[int]:
53+
@cache
54+
def dfs(i, state):
55+
if i == n:
56+
return [] if state == (1 << m) - 1 else None
57+
ans1 = dfs(i + 1, state)
58+
ans2 = dfs(i + 1, state | ps[i])
59+
if ans1 is None and ans2 is None:
60+
return None
61+
if ans1 is None:
62+
return [i] + ans2
63+
if ans2 is None:
64+
return ans1
65+
return min(ans1, [i] + ans2, key=len)
66+
67+
d = {s: i for i, s in enumerate(req_skills)}
68+
m = len(req_skills)
69+
n = len(people)
70+
ps = [0] * n
71+
for i, skills in enumerate(people):
72+
for skill in skills:
73+
ps[i] |= 1 << d[skill]
74+
return dfs(0, 0)
5275
```
5376

5477
### **Java**
5578

5679
```java
57-
80+
class Solution {
81+
private int m;
82+
private int n;
83+
private int[] ps;
84+
private int[][][] f;
85+
private static final int MX = 100;
86+
87+
public int[] smallestSufficientTeam(String[] req_skills, List<List<String>> people) {
88+
m = req_skills.length;
89+
n = people.size();
90+
ps = new int[n];
91+
f = new int[n][1 << m][];
92+
Map<String, Integer> d = new HashMap<>();
93+
for (int i = 0; i < m; ++i) {
94+
d.put(req_skills[i], i);
95+
}
96+
for (int i = 0; i < n; ++i) {
97+
for (String skill : people.get(i)) {
98+
ps[i] |= 1 << d.get(skill);
99+
}
100+
}
101+
return dfs(0, 0);
102+
}
103+
104+
private int[] dfs(int i, int state) {
105+
if (i == n) {
106+
return state == (1 << m) - 1 ? new int[0] : add(new int[0], MX);
107+
}
108+
if (f[i][state] != null) {
109+
return f[i][state];
110+
}
111+
int[] ans1 = dfs(i + 1, state);
112+
int[] ans2 = dfs(i + 1, state | ps[i]);
113+
if (ans1.length > 0 && ans1[0] == MX && ans2.length > 0 && ans2[0] == MX) {
114+
return f[i][state] = ans1;
115+
}
116+
if (ans1.length > 0 && ans1[0] == MX) {
117+
return f[i][state] = add(ans2, i);
118+
}
119+
if (ans2.length > 0 && ans2[0] == MX) {
120+
return f[i][state] = ans1;
121+
}
122+
if (ans1.length < ans2.length + 1) {
123+
return f[i][state] = ans1;
124+
}
125+
return f[i][state] = add(ans2, i);
126+
}
127+
128+
private int[] add(int[] nums, int x) {
129+
int[] copy = Arrays.copyOf(nums, nums.length + 1);
130+
copy[copy.length - 1] = x;
131+
return copy;
132+
}
133+
}
58134
```
59135

60136
### **...**

‎solution/1100-1199/1125.Smallest Sufficient Team/Solution.java

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
class Solution {
2+
private int m;
3+
private int n;
4+
private int[] ps;
5+
private int[][][] f;
6+
private static final int MX = 100;
7+
8+
public int[] smallestSufficientTeam(String[] req_skills, List<List<String>> people) {
9+
m = req_skills.length;
10+
n = people.size();
11+
ps = new int[n];
12+
f = new int[n][1 << m][];
13+
Map<String, Integer> d = new HashMap<>();
14+
for (int i = 0; i < m; ++i) {
15+
d.put(req_skills[i], i);
16+
}
17+
for (int i = 0; i < n; ++i) {
18+
for (String skill : people.get(i)) {
19+
ps[i] |= 1 << d.get(skill);
20+
}
21+
}
22+
return dfs(0, 0);
23+
}
24+
25+
private int[] dfs(int i, int state) {
26+
if (i == n) {
27+
return state == (1 << m) - 1 ? new int[0] : add(new int[0], MX);
28+
}
29+
if (f[i][state] != null) {
30+
return f[i][state];
31+
}
32+
int[] ans1 = dfs(i + 1, state);
33+
int[] ans2 = dfs(i + 1, state | ps[i]);
34+
if (ans1.length > 0 && ans1[0] == MX && ans2.length > 0 && ans2[0] == MX) {
35+
return f[i][state] = ans1;
36+
}
37+
if (ans1.length > 0 && ans1[0] == MX) {
38+
return f[i][state] = add(ans2, i);
39+
}
40+
if (ans2.length > 0 && ans2[0] == MX) {
41+
return f[i][state] = ans1;
42+
}
43+
if (ans1.length < ans2.length + 1) {
44+
return f[i][state] = ans1;
45+
}
46+
return f[i][state] = add(ans2, i);
47+
}
48+
49+
private int[] add(int[] nums, int x) {
50+
int[] copy = Arrays.copyOf(nums, nums.length + 1);
51+
copy[copy.length - 1] = x;
52+
return copy;
53+
}
54+
}

‎solution/1100-1199/1125.Smallest Sufficient Team/Solution.py

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution:
2+
def smallestSufficientTeam(self, req_skills: List[str], people: List[List[str]]) -> List[int]:
3+
@cache
4+
def dfs(i, state):
5+
if i == n:
6+
return [] if state == (1 << m) - 1 else None
7+
ans1 = dfs(i + 1, state)
8+
ans2 = dfs(i + 1, state | ps[i])
9+
if ans1 is None and ans2 is None:
10+
return None
11+
if ans1 is None:
12+
return [i] + ans2
13+
if ans2 is None:
14+
return ans1
15+
return min(ans1, [i] + ans2, key=len)
16+
17+
d = {s: i for i, s in enumerate(req_skills)}
18+
m = len(req_skills)
19+
n = len(people)
20+
ps = [0] * n
21+
for i, skills in enumerate(people):
22+
for skill in skills:
23+
ps[i] |= 1 << d[skill]
24+
return dfs(0, 0)

0 commit comments

Comments
 (0)