Skip to content

Commit 55eed7e

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1434
No.1434.Number of Ways to Wear Different Hats to Each Other
1 parent 47a8ef5 commit 55eed7e

File tree

6 files changed

+383
-2
lines changed

6 files changed

+383
-2
lines changed

‎solution/1400-1499/1434.Number of Ways to Wear Different Hats to Each Other/README.md

+132-1
Original file line numberDiff line numberDiff line change
@@ -65,22 +65,153 @@
6565

6666
<!-- 这里可写通用的实现逻辑 -->
6767

68+
**方法一：状态压缩 DP**
69+
6870
<!-- tabs:start -->
6971

7072
### **Python3**
7173

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

7476
```python
75-
77+
class Solution:
78+
def numberWays(self, hats: List[List[int]]) -> int:
79+
d = defaultdict(list)
80+
for i, h in enumerate(hats):
81+
for v in h:
82+
d[v].append(i)
83+
n = len(hats)
84+
mx = max(max(h) for h in hats)
85+
dp = [[0] * (1 << n) for _ in range(mx + 1)]
86+
dp[0][0] = 1
87+
mod = int(1e9) + 7
88+
for i in range(1, mx + 1):
89+
for mask in range(1 << n):
90+
dp[i][mask] = dp[i - 1][mask]
91+
for j in d[i]:
92+
if (mask >> j) & 1:
93+
dp[i][mask] += dp[i - 1][mask ^ (1 << j)]
94+
dp[i][mask] %= mod
95+
return dp[mx][(1 << n) - 1]
7696
```
7797

7898
### **Java**
7999

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

82102
```java
103+
class Solution {
104+
private static final int MOD = (int) 1e9 + 7;
105+
106+
public int numberWays(List<List<Integer>> hats) {
107+
List<Integer>[] d = new List[41];
108+
for (int i = 0; i < d.length; ++i) {
109+
d[i] = new ArrayList<>();
110+
}
111+
int n = hats.size();
112+
int mx = 0;
113+
for (int i = 0; i < n; ++i) {
114+
for (int h : hats.get(i)) {
115+
d[h].add(i);
116+
mx = Math.max(mx, h);
117+
}
118+
}
119+
long[][] dp = new long[mx + 1][1 << n];
120+
dp[0][0] = 1;
121+
for (int i = 1; i < mx + 1; ++i) {
122+
for (int mask = 0; mask < 1 << n; ++mask) {
123+
dp[i][mask] = dp[i - 1][mask];
124+
for (int j : d[i]) {
125+
if (((mask >> j) & 1) == 1) {
126+
dp[i][mask] = (dp[i][mask] + dp[i - 1][mask ^ (1 << j)]) % MOD;
127+
}
128+
}
129+
}
130+
}
131+
return (int) dp[mx][(1 << n) - 1];
132+
}
133+
}
134+
```
135+
136+
### **C++**
137+
138+
```cpp
139+
using ll = long long;
140+
141+
class Solution {
142+
public:
143+
int numberWays(vector<vector<int>>& hats) {
144+
vector<vector<int>> d(41);
145+
int n = hats.size();
146+
int mx = 0;
147+
for (int i = 0; i < n; ++i)
148+
{
149+
for (int& h : hats[i])
150+
{
151+
d[h].push_back(i);
152+
mx = max(mx, h);
153+
}
154+
}
155+
vector<vector<ll>> dp(mx + 1, vector<ll>(1 << n));
156+
dp[0][0] = 1;
157+
int mod = 1e9 + 7;
158+
for (int i = 1; i <= mx; ++i)
159+
{
160+
for (int mask = 0; mask < 1 << n; ++mask)
161+
{
162+
dp[i][mask] = dp[i - 1][mask];
163+
for (int& j : d[i])
164+
{
165+
if ((mask >> j) & 1)
166+
{
167+
dp[i][mask] = (dp[i][mask] + dp[i - 1][mask ^ (1 << j)]) % mod;
168+
}
169+
}
170+
}
171+
}
172+
return dp[mx][(1 << n) - 1];
173+
}
174+
};
175+
```
83176
177+
### **Go**
178+
179+
```go
180+
func numberWays(hats [][]int) int {
181+
d := make([][]int, 41)
182+
mx := 0
183+
for i, h := range hats {
184+
for _, v := range h {
185+
d[v] = append(d[v], i)
186+
mx = max(mx, v)
187+
}
188+
}
189+
dp := make([][]int, mx+1)
190+
n := len(hats)
191+
for i := range dp {
192+
dp[i] = make([]int, 1<<n)
193+
}
194+
dp[0][0] = 1
195+
mod := int(1e9) + 7
196+
for i := 1; i <= mx; i++ {
197+
for mask := 0; mask < 1<<n; mask++ {
198+
dp[i][mask] = dp[i-1][mask]
199+
for _, j := range d[i] {
200+
if ((mask >> j) & 1) == 1 {
201+
dp[i][mask] = (dp[i][mask] + dp[i-1][mask^(1<<j)]) % mod
202+
}
203+
}
204+
}
205+
}
206+
return dp[mx][(1<<n)-1]
207+
}
208+
209+
func max(a, b int) int {
210+
if a > b {
211+
return a
212+
}
213+
return b
214+
}
84215
```
85216

86217
### **...**

‎solution/1400-1499/1434.Number of Ways to Wear Different Hats to Each Other/README_EN.md

+130-1
Original file line numberDiff line numberDiff line change
@@ -58,13 +58,142 @@ Number of Permutations of (1,2,3,4) = 24.
5858
### **Python3**
5959

6060
```python
61-
61+
class Solution:
62+
def numberWays(self, hats: List[List[int]]) -> int:
63+
d = defaultdict(list)
64+
for i, h in enumerate(hats):
65+
for v in h:
66+
d[v].append(i)
67+
n = len(hats)
68+
mx = max(max(h) for h in hats)
69+
dp = [[0] * (1 << n) for _ in range(mx + 1)]
70+
dp[0][0] = 1
71+
mod = int(1e9) + 7
72+
for i in range(1, mx + 1):
73+
for mask in range(1 << n):
74+
dp[i][mask] = dp[i - 1][mask]
75+
for j in d[i]:
76+
if (mask >> j) & 1:
77+
dp[i][mask] += dp[i - 1][mask ^ (1 << j)]
78+
dp[i][mask] %= mod
79+
return dp[mx][(1 << n) - 1]
6280
```
6381

6482
### **Java**
6583

6684
```java
85+
class Solution {
86+
private static final int MOD = (int) 1e9 + 7;
87+
88+
public int numberWays(List<List<Integer>> hats) {
89+
List<Integer>[] d = new List[41];
90+
for (int i = 0; i < d.length; ++i) {
91+
d[i] = new ArrayList<>();
92+
}
93+
int n = hats.size();
94+
int mx = 0;
95+
for (int i = 0; i < n; ++i) {
96+
for (int h : hats.get(i)) {
97+
d[h].add(i);
98+
mx = Math.max(mx, h);
99+
}
100+
}
101+
long[][] dp = new long[mx + 1][1 << n];
102+
dp[0][0] = 1;
103+
for (int i = 1; i < mx + 1; ++i) {
104+
for (int mask = 0; mask < 1 << n; ++mask) {
105+
dp[i][mask] = dp[i - 1][mask];
106+
for (int j : d[i]) {
107+
if (((mask >> j) & 1) == 1) {
108+
dp[i][mask] = (dp[i][mask] + dp[i - 1][mask ^ (1 << j)]) % MOD;
109+
}
110+
}
111+
}
112+
}
113+
return (int) dp[mx][(1 << n) - 1];
114+
}
115+
}
116+
```
117+
118+
### **C++**
119+
120+
```cpp
121+
using ll = long long;
122+
123+
class Solution {
124+
public:
125+
int numberWays(vector<vector<int>>& hats) {
126+
vector<vector<int>> d(41);
127+
int n = hats.size();
128+
int mx = 0;
129+
for (int i = 0; i < n; ++i)
130+
{
131+
for (int& h : hats[i])
132+
{
133+
d[h].push_back(i);
134+
mx = max(mx, h);
135+
}
136+
}
137+
vector<vector<ll>> dp(mx + 1, vector<ll>(1 << n));
138+
dp[0][0] = 1;
139+
int mod = 1e9 + 7;
140+
for (int i = 1; i <= mx; ++i)
141+
{
142+
for (int mask = 0; mask < 1 << n; ++mask)
143+
{
144+
dp[i][mask] = dp[i - 1][mask];
145+
for (int& j : d[i])
146+
{
147+
if ((mask >> j) & 1)
148+
{
149+
dp[i][mask] = (dp[i][mask] + dp[i - 1][mask ^ (1 << j)]) % mod;
150+
}
151+
}
152+
}
153+
}
154+
return dp[mx][(1 << n) - 1];
155+
}
156+
};
157+
```
67158
159+
### **Go**
160+
161+
```go
162+
func numberWays(hats [][]int) int {
163+
d := make([][]int, 41)
164+
mx := 0
165+
for i, h := range hats {
166+
for _, v := range h {
167+
d[v] = append(d[v], i)
168+
mx = max(mx, v)
169+
}
170+
}
171+
dp := make([][]int, mx+1)
172+
n := len(hats)
173+
for i := range dp {
174+
dp[i] = make([]int, 1<<n)
175+
}
176+
dp[0][0] = 1
177+
mod := int(1e9) + 7
178+
for i := 1; i <= mx; i++ {
179+
for mask := 0; mask < 1<<n; mask++ {
180+
dp[i][mask] = dp[i-1][mask]
181+
for _, j := range d[i] {
182+
if ((mask >> j) & 1) == 1 {
183+
dp[i][mask] = (dp[i][mask] + dp[i-1][mask^(1<<j)]) % mod
184+
}
185+
}
186+
}
187+
}
188+
return dp[mx][(1<<n)-1]
189+
}
190+
191+
func max(a, b int) int {
192+
if a > b {
193+
return a
194+
}
195+
return b
196+
}
68197
```
69198

70199
### **...**

‎solution/1400-1499/1434.Number of Ways to Wear Different Hats to Each Other/Solution.cpp

+36
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
using ll = long long;
2+
3+
class Solution {
4+
public:
5+
int numberWays(vector<vector<int>>& hats) {
6+
vector<vector<int>> d(41);
7+
int n = hats.size();
8+
int mx = 0;
9+
for (int i = 0; i < n; ++i)
10+
{
11+
for (int& h : hats[i])
12+
{
13+
d[h].push_back(i);
14+
mx = max(mx, h);
15+
}
16+
}
17+
vector<vector<ll>> dp(mx + 1, vector<ll>(1 << n));
18+
dp[0][0] = 1;
19+
int mod = 1e9 + 7;
20+
for (int i = 1; i <= mx; ++i)
21+
{
22+
for (int mask = 0; mask < 1 << n; ++mask)
23+
{
24+
dp[i][mask] = dp[i - 1][mask];
25+
for (int& j : d[i])
26+
{
27+
if ((mask >> j) & 1)
28+
{
29+
dp[i][mask] = (dp[i][mask] + dp[i - 1][mask ^ (1 << j)]) % mod;
30+
}
31+
}
32+
}
33+
}
34+
return dp[mx][(1 << n) - 1];
35+
}
36+
};

‎solution/1400-1499/1434.Number of Ways to Wear Different Hats to Each Other/Solution.go

+35
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
func numberWays(hats [][]int) int {
2+
d := make([][]int, 41)
3+
mx := 0
4+
for i, h := range hats {
5+
for _, v := range h {
6+
d[v] = append(d[v], i)
7+
mx = max(mx, v)
8+
}
9+
}
10+
dp := make([][]int, mx+1)
11+
n := len(hats)
12+
for i := range dp {
13+
dp[i] = make([]int, 1<<n)
14+
}
15+
dp[0][0] = 1
16+
mod := int(1e9) + 7
17+
for i := 1; i <= mx; i++ {
18+
for mask := 0; mask < 1<<n; mask++ {
19+
dp[i][mask] = dp[i-1][mask]
20+
for _, j := range d[i] {
21+
if ((mask >> j) & 1) == 1 {
22+
dp[i][mask] = (dp[i][mask] + dp[i-1][mask^(1<<j)]) % mod
23+
}
24+
}
25+
}
26+
}
27+
return dp[mx][(1<<n)-1]
28+
}
29+
30+
func max(a, b int) int {
31+
if a > b {
32+
return a
33+
}
34+
return b
35+
}

0 commit comments

Comments
 (0)