当时参加周赛的时候没做出来，后来通过看题解，学习到了状态压缩dp,对于这一题是理解了，但是状态压缩dp运用的还不是特别好。记录一下解题过程。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-ways-to-wear-different-hats-to-each-other
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目

总共有 n 个人和 40 种不同的帽子，帽子编号从 1 到 40 。

给你一个整数列表的列表 hats ，其中 hats[i] 是第 i 个人所有喜欢帽子的列表。

请你给每个人安排一顶他喜欢的帽子，确保每个人戴的帽子跟别人都不一样，并返回方案数。

由于答案可能很大，请返回它对 10^9 + 7 取余后的结果。

示例 1：

输入：hats = [[3,4],[4,5],[5]]
输出：1
解释：给定条件下只有一种方法选择帽子。
第一个人选择帽子 3，第二个人选择帽子 4，最后一个人选择帽子 5。

示例 2：

输入：hats = [[3,5,1],[3,5]]
输出：4
解释：总共有 4 种安排帽子的方法：
(3,5)，(5,3)，(1,3) 和 (1,5)

示例 3：

输入：hats = [[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4]]
输出：24
解释：每个人都可以从编号为 1 到 4 的帽子中选。
(1,2,3,4) 4 个帽子的排列方案数为 24 。

示例 4：

输入：hats = [[1,2,3],[2,3,5,6],[1,3,7,9],[1,8,9],[2,5,7]]
输出：111

n == hats.length
1 <= n <= 10
1 <= hats[i].length <= 40
1 <= hats[i][j] <= 40
hats[i] 包含一个数字互不相同的整数列表。

解题过程

首先，因为帽子的数量比人的数量多4倍，可以将人匹配帽子的列表转换成帽子可以匹配人的列表，以此来减少状态数量。

int n = hats.size();
List<List<Integer>> peo = new ArrayList<>(41);
for (int i = 0; i < 41; i++) {
    peo.add(new ArrayList<Integer>());
}
for (int i = 0; i < n; i++) {
    for (int j = 0; j < hats.get(i).size(); j++) {
        peo.get(hats.get(i).get(j)).add(i);
    }
}

n是人数，我们用n位来表示所有人是否戴帽子的一种状态，例如n=5，那么10011表示第0、1、4个人戴了帽子，第2、3个人没戴帽子。
然后维护一个dp[1<<n][41]，其中dp[j][i]就是，考虑前i个帽子的情况下，状态为j的分配帽子的可能数
对于dp[j][i]，
首先如果选择第i个帽子不分配，那么dp[j][i] = dp[j][i-1]
如果选择第i个帽子分配，那么关注j的状态，例如j状态为10011，那么依次判断每一位为1的，再判断该位的人是否可以戴这顶帽子，如果可以，那么dp[j][i] += dp[j - (1 << k)][i-1]，其中k是人的编号。
所以总的dp转移方程为

\(dp[j][i] = dp[j][i-1] + \sum dp[j - (1 << k)][i-1]\)

其中k满足((1 << k) & j) != 0且第i个帽子可以分配给第k个人。
最后dp[(1<<n)-1][40]就是我们要求的答案。
总代码

public class Solution {
    public static final int MOD = 1000000007;
    public int numberWays(List<List<Integer>> hats) {
        int n = hats.size();
        List<List<Integer>> peo = new ArrayList<>(41);
        for (int i = 0; i < 41; i++) {
            peo.add(new ArrayList<Integer>());
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < hats.get(i).size(); j++) {
                peo.get(hats.get(i).get(j)).add(i);
            }
        }
        int[][] dp = new int[1 << n][41];
        dp[0][0] = 1;
    
        for (int i = 1; i < 41; i++) {
            for (int j = 0; j < (1 << n); j++) {
                dp[j][i] = dp[j][i-1];
                for (int k = 0; k < n; k++) {
                    if (((1 << k) & j) != 0){
                        if (peo.get(i).contains(k)){
                            dp[j][i] = (dp[j][i] + dp[j - (1 << k)][i - 1]) % MOD;
                        }
                    }
                }
            }
        }
        return dp[(1 << n) - 1][40];
    }
}