Number of Ways to Wear Different Hats to Each Other

Number of Ways to Wear Different Hats to Each Other - Problem

You're organizing a costume party where n people need to wear different hats! There are 40 types of hats available (labeled 1 to 40), and each person has their own list of preferred hats they're willing to wear.

Your challenge: Count how many ways all n people can wear different hats from each other, where each person wears exactly one hat from their preference list, and no two people wear the same hat.

Input: A 2D array hats where hats[i] contains all hat types that person i is willing to wear.

Output: The number of valid arrangements modulo 10⁹ + 7.

Example: If person 0 likes hats [1,2] and person 1 likes hats [2,3], there are 2 ways: person 0 wears hat 1 & person 1 wears hat 2, OR person 0 wears hat 1 & person 1 wears hat 3.

Input & Output

example_1.py — Basic Case

$ Input: hats = [[3,4],[4,5],[5]]

› Output: 1

💡 Note: There's only 1 way: person 0 wears hat 3, person 1 wears hat 4, and person 2 wears hat 5.

example_2.py — Multiple Options

$ Input: hats = [[3,5,1],[3,5],[1,3,5,4],[9,4]]

› Output: 2

💡 Note: Two valid arrangements exist: [1,3,5,4] and [1,5,3,4] where each person gets a different hat from their preferences.

example_3.py — Overlapping Preferences

$ Input: hats = [[1,2,3,4],[1,2,3,4],[1,2,3,4],[1,2,3,4]]

› Output: 24

💡 Note: Each person can wear any of 4 hats, so we have 4! = 24 different ways to assign unique hats.

Visualization

Tap to expand

Understanding the Visualization

Map Hats to People

Create a reverse mapping: for each hat, list all people who can wear it

Use Bitmask for State

Each bit represents whether a person has been assigned a hat (1) or not (0)

Process Hats Sequentially

For each hat 1-40, either skip it or assign it to an unassigned person

Count Valid Assignments

When all people are assigned (mask = 111...1), we found a valid solution

Key Takeaway

🎯 Key Insight: Process hats sequentially and use bitmasks to track people assignments, avoiding the complexity of people-to-hat assignments!

Time & Space Complexity

Time Complexity

⏱️

O(40 * 2^n * n)

40 hats, 2^n possible masks, and up to n people can wear each hat

⚠ Quadratic Growth

Space Complexity

O(40 * 2^n)

DP table with 40 hats and 2^n possible people assignments

⚠ Quadratic Space

Constraints

n == hats.length
1 ≤ n ≤ 10
1 ≤ hats[i].length ≤ 40
1 ≤ hats[i][j] ≤ 40
All values in hats[i] are unique
The total number of hats across all people is at most 40

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 22

The optimal approach uses Dynamic Programming with Bitmasks. Instead of assigning people to hats, we assign hats to people and use a bitmask to track which people are already assigned. The key insight is to iterate through hats (1-40) and for each hat, decide whether to skip it or assign it to an available person who likes that hat. This avoids redundant computations through memoization with time complexity O(40 × 2ⁿ × n).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmask (Optimal)	O(40 * 2^n * n)	O(40 * 2^n)	Use DP with bitmasks to efficiently count all valid hat assignments
Brute Force (Backtracking)	O(k^n)	O(n)	Try all possible hat assignments using recursive backtracking

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Create a mapping from each hat to the people who can wear it
Use bitmask to represent which people are assigned (1 bit per person)
DP state: dp[hat][mask] = ways to assign first 'hat' hats with 'mask' people assigned
For each hat, either skip it or assign it to an available person
Return dp[40][2^n - 1] (all people assigned)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Start with hat 1 and empty assignment (mask = 0)

Process Each Hat

For each hat, decide to skip or assign to available people

Update Bitmask

Set bit for assigned person and recurse with updated state

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MOD 1000000007
#define MAX_PEOPLE 10
#define MAX_HATS 40

int hatToPeople[41][MAX_PEOPLE];
int hatSizes[41];
int memo[41][1024]; // 2^10 = 1024
int memoSet[41][1024];
int n;

int dp(int hat, int mask) {
    if (mask == (1 << n) - 1) {
        return 1;
    }
    if (hat > 40) {
        return 0;
    }
    
    if (memoSet[hat][mask]) {
        return memo[hat][mask];
    }
    
    long long ways = dp(hat + 1, mask);
    
    for (int i = 0; i < hatSizes[hat]; i++) {
        int person = hatToPeople[hat][i];
        if (!(mask & (1 << person))) {
            ways = (ways + dp(hat + 1, mask | (1 << person))) % MOD;
        }
    }
    
    memoSet[hat][mask] = 1;
    memo[hat][mask] = ways;
    return ways;
}

int numberWaysToWearDifferentHats(int** hats, int* hatCounts, int peopleCount) {
    n = peopleCount;
    memset(hatSizes, 0, sizeof(hatSizes));
    memset(memoSet, 0, sizeof(memoSet));
    
    for (int person = 0; person < n; person++) {
        for (int i = 0; i < hatCounts[person]; i++) {
            int hat = hats[person][i];
            hatToPeople[hat][hatSizes[hat]++] = person;
        }
    }
    
    return dp(1, 0);
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(40 * 2^n * n)

40 hats, 2^n possible masks, and up to n people can wear each hat

⚠ Quadratic Growth

Space Complexity

O(40 * 2^n)

DP table with 40 hats and 2^n possible people assignments

⚠ Quadratic Space

Constraints

n == hats.length
1 ≤ n ≤ 10
1 ≤ hats[i].length ≤ 40
1 ≤ hats[i][j] ≤ 40
All values in hats[i] are unique
The total number of hats across all people is at most 40

28.5K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler