feat: add solutions to lc problem: No.1434

No.1434.Number of Ways to Wear Different Hats to Each Other

Author: yanglbme

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

@@ -65,7 +65,23 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：状态压缩 DP**
+**方法一：状态压缩动态规划**
+
+我们注意到 $n$ 不超过 $10$，因此我们考虑使用状态压缩动态规划的方法求解。
+
+我们定义 $f[i][j]$ 表示在前 $i$ 个帽子中，当前被分配的人的状态为 $j$ 时的方案数。其中 $j$ 是一个二进制数，表示当前被分配的人的集合。初始时 $f[0][0]=1$，答案为 $f[m][2^n - 1]$，其中 $m$ 是帽子的最大编号，而 $n$ 是人的数量。
+
+考虑 $f[i][j]$，如果第 $i$ 个帽子不分配给任何人，那么 $f[i][j]=f[i-1][j]$；如果第 $i$ 个帽子分配给了喜欢它的人 $k$，那么 $f[i][j]=f[i-1][j \oplus 2^k]$。这里 $\oplus$ 表示异或运算。因此我们可以得到状态转移方程：
+
+$$
+f[i][j]=f[i-1][j]+ \sum_{k \in like[i]} f[i-1][j \oplus 2^k]
+$$
+
+其中 $like[i]$ 表示喜欢第 $i$ 个帽子的人的集合。
+
+最终的答案即为 $f[m][2^n - 1]$，注意答案可能很大，需要对 $10^9 + 7$ 取模。
+
+时间复杂度 $O(m \times 2^n \times n)$，空间复杂度 $O(m \times 2^n)$。其中 $m$ 是帽子的最大编号，本题中 $m \leq 40$；而 $n$ 是人的数量，本题中 $n \leq 10$。
 
 <!-- tabs:start -->
 
@@ -76,23 +92,22 @@
 ```python
 class Solution:
     def numberWays(self, hats: List[List[int]]) -> int:
-        d = defaultdict(list)
+        g = defaultdict(list)
         for i, h in enumerate(hats):
             for v in h:
-                d[v].append(i)
+                g[v].append(i)
+        mod = 10**9 + 7
         n = len(hats)
-        mx = max(max(h) for h in hats)
-        dp = [[0] * (1 << n) for _ in range(mx + 1)]
-        dp[0][0] = 1
-        mod = int(1e9) + 7
-        for i in range(1, mx + 1):
-            for mask in range(1 << n):
-                dp[i][mask] = dp[i - 1][mask]
-                for j in d[i]:
-                    if (mask >> j) & 1:
-                        dp[i][mask] += dp[i - 1][mask ^ (1 << j)]
-                dp[i][mask] %= mod
-        return dp[mx][(1 << n) - 1]
+        m = max(max(h) for h in hats)
+        f = [[0] * (1 << n) for _ in range(m + 1)]
+        f[0][0] = 1
+        for i in range(1, m + 1):
+            for j in range(1 << n):
+                f[i][j] = f[i - 1][j]
+                for k in g[i]:
+                    if j >> k & 1:
+                        f[i][j] = (f[i][j] + f[i - 1][j ^ (1 << k)]) % mod
+        return f[m][-1]
 ```
 
 ### **Java**
@@ -101,67 +116,71 @@ class Solution:
 
 ```java
 class Solution {
-    private static final int MOD = (int) 1e9 + 7;
-
     public int numberWays(List<List<Integer>> hats) {
-        List<Integer>[] d = new List[41];
-        Arrays.setAll(d, k -> new ArrayList<>());
         int n = hats.size();
-        int mx = 0;
+        int m = 0;
+        for (var h : hats) {
+            for (int v : h) {
+                m = Math.max(m, v);
+            }
+        }
+        List<Integer>[] g = new List[m + 1];
+        Arrays.setAll(g, k -> new ArrayList<>());
         for (int i = 0; i < n; ++i) {
-            for (int h : hats.get(i)) {
-                d[h].add(i);
-                mx = Math.max(mx, h);
+            for (int v : hats.get(i)) {
+                g[v].add(i);
             }
         }
-        long[][] dp = new long[mx + 1][1 << n];
-        dp[0][0] = 1;
-        for (int i = 1; i < mx + 1; ++i) {
-            for (int mask = 0; mask < 1 << n; ++mask) {
-                dp[i][mask] = dp[i - 1][mask];
-                for (int j : d[i]) {
-                    if (((mask >> j) & 1) == 1) {
-                        dp[i][mask] = (dp[i][mask] + dp[i - 1][mask ^ (1 << j)]) % MOD;
+        final int mod = (int) 1e9 + 7;
+        int[][] f = new int[m + 1][1 << n];
+        f[0][0] = 1;
+        for (int i = 1; i <= m; ++i) {
+            for (int j = 0; j < 1 << n; ++j) {
+                f[i][j] = f[i - 1][j];
+                for (int k : g[i]) {
+                    if ((j >> k & 1) == 1) {
+                        f[i][j] = (f[i][j] + f[i - 1][j ^ (1 << k)]) % mod;
                     }
                 }
             }
         }
-        return (int) dp[mx][(1 << n) - 1];
+        return f[m][(1 << n) - 1];
     }
 }
 ```
 
 ### **C++**
 
 ```cpp
-using ll = long long;
-
 class Solution {
 public:
     int numberWays(vector<vector<int>>& hats) {
-        vector<vector<int>> d(41);
         int n = hats.size();
-        int mx = 0;
+        int m = 0;
+        for (auto& h : hats) {
+            m = max(m, *max_element(h.begin(), h.end()));
+        }
+        vector<vector<int>> g(m + 1);
         for (int i = 0; i < n; ++i) {
-            for (int& h : hats[i]) {
-                d[h].push_back(i);
-                mx = max(mx, h);
+            for (int& v : hats[i]) {
+                g[v].push_back(i);
             }
         }
-        vector<vector<ll>> dp(mx + 1, vector<ll>(1 << n));
-        dp[0][0] = 1;
-        int mod = 1e9 + 7;
-        for (int i = 1; i <= mx; ++i) {
-            for (int mask = 0; mask < 1 << n; ++mask) {
-                dp[i][mask] = dp[i - 1][mask];
-                for (int& j : d[i]) {
-                    if ((mask >> j) & 1) {
-                        dp[i][mask] = (dp[i][mask] + dp[i - 1][mask ^ (1 << j)]) % mod;
+        const int mod = 1e9 + 7;
+        int f[m + 1][1 << n];
+        memset(f, 0, sizeof(f));
+        f[0][0] = 1;
+        for (int i = 1; i <= m; ++i) {
+            for (int j = 0; j < 1 << n; ++j) {
+                f[i][j] = f[i -1][j];
+                for (int k : g[i]) {
+                    if (j >> k & 1) {
+                        f[i][j] = (f[i][j] + f[i - 1][j ^ (1 << k)]) % mod;
                     }
                 }
             }
         }
-        return dp[mx][(1 << n) - 1];
+        return f[m][(1 << n) - 1];
     }
 };
 ```
@@ -170,32 +189,36 @@ public:
 
 ```go
 func numberWays(hats [][]int) int {
-	d := make([][]int, 41)
-	mx := 0
+	n := len(hats)
+	m := 0
+	for _, h := range hats {
+		for _, v := range h {
+			m = max(m, v)
+		}
+	}
+	g := make([][]int, m+1)
 	for i, h := range hats {
 		for _, v := range h {
-			d[v] = append(d[v], i)
-			mx = max(mx, v)
+			g[v] = append(g[v], i)
 		}
 	}
-	dp := make([][]int, mx+1)
-	n := len(hats)
-	for i := range dp {
-		dp[i] = make([]int, 1<<n)
+	const mod = 1e9 + 7
+	f := make([][]int, m+1)
+	for i := range f {
+		f[i] = make([]int, 1<<n)
 	}
-	dp[0][0] = 1
-	mod := int(1e9) + 7
-	for i := 1; i <= mx; i++ {
-		for mask := 0; mask < 1<<n; mask++ {
-			dp[i][mask] = dp[i-1][mask]
-			for _, j := range d[i] {
-				if ((mask >> j) & 1) == 1 {
-					dp[i][mask] = (dp[i][mask] + dp[i-1][mask^(1<<j)]) % mod
+	f[0][0] = 1
+	for i := 1; i <= m; i++ {
+		for j := 0; j < 1<<n; j++ {
+			f[i][j] = f[i-1][j]
+			for _, k := range g[i] {
+				if j>>k&1 == 1 {
+					f[i][j] = (f[i][j] + f[i-1][j^(1<<k)]) % mod
 				}
 			}
 		}
 	}
-	return dp[mx][(1<<n)-1]
+	return f[m][(1<<n)-1]
 }
 
 func max(a, b int) int {
@@ -206,6 +229,37 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function numberWays(hats: number[][]): number {
+    const n = hats.length;
+    const m = Math.max(...hats.flat());
+    const g: number[][] = Array.from({ length: m + 1 }, () => []);
+    for (let i = 0; i < n; ++i) {
+        for (const v of hats[i]) {
+            g[v].push(i);
+        }
+    }
+    const f: number[][] = Array.from({ length: m + 1 }, () =>
+        Array.from({ length: 1 << n }, () => 0),
+    );
+    f[0][0] = 1;
+    const mod = 1e9 + 7;
+    for (let i = 1; i <= m; ++i) {
+        for (let j = 0; j < 1 << n; ++j) {
+            f[i][j] = f[i - 1][j];
+            for (const k of g[i]) {
+                if (((j >> k) & 1) === 1) {
+                    f[i][j] = (f[i][j] + f[i - 1][j ^ (1 << k)]) % mod;
+                }
+            }
+        }
+    }
+    return f[m][(1 << n) - 1];
+}
+```
+
 ### **...**
 
 ```