People Whose List of Favorite Companies Is Not a Subset of Another List

People Whose List of Favorite Companies Is Not a Subset of Another List - Problem

Imagine you're analyzing employee preferences in a corporate survey! You have collected data about each person's favorite companies, and now you need to find the unique individuals whose preferences aren't completely covered by someone else's broader list.

Given an array favoriteCompanies where favoriteCompanies[i] represents the list of favorite companies for the i-th person (0-indexed), your task is to identify people whose company preferences are not a subset of any other person's list.

Goal: Return the indices of people whose favorite companies list is NOT completely contained within anyone else's list. The result should be in increasing order.

Example: If Person A likes ["Google", "Apple"] and Person B likes ["Google", "Apple", "Microsoft"], then Person A's preferences are a subset of Person B's, so we wouldn't include Person A in our result.

Input & Output

example_1.py — Basic Example

$ Input: [["leetcode","google","facebook"],["google","microsoft"],["google","facebook"],["google"],["amazon"]]

› Output: [0,1,4]

💡 Note: Person 0's list ["leetcode","google","facebook"] is not a subset of any other list. Person 1's list ["google","microsoft"] is not a subset of any other list. Person 2's list ["google","facebook"] is a subset of Person 0's list. Person 3's list ["google"] is a subset of Person 0's, 1's and 2's lists. Person 4's list ["amazon"] is not a subset of any other list.

example_2.py — All Unique

$ Input: [["leetcode","google","facebook"],["leetcode","amazon"],["facebook","google"]]

› Output: [0,1,2]

💡 Note: None of the lists are subsets of each other, so all people should be included in the result.

example_3.py — Single Elements

$ Input: [["leetcode"],["google"],["facebook"],["leetcode","google"]]

› Output: [3]

💡 Note: Person 0's ["leetcode"], Person 1's ["google"], and Person 2's ["facebook"] are all subsets of Person 3's ["leetcode","google"]. Only Person 3 has a list that's not a subset of anyone else's.

Constraints

1 ≤ favoriteCompanies.length ≤ 100
1 ≤ favoriteCompanies[i].length ≤ 500
1 ≤ favoriteCompanies[i][j].length ≤ 20
All strings in favoriteCompanies[i] are distinct
All the strings of favoriteCompanies are distinct

Visualization

Tap to expand

Understanding the Visualization

Collect All Recipes

Each person has their favorite recipes in a collection

Convert to Quick-Lookup

Transform each collection into a hash table for fast searching

Compare Collections

For each person, check if all their recipes exist in someone else's collection

Find Unique Collections

Keep only people whose recipe collections aren't subsets of others

Key Takeaway

🎯 Key Insight: Hash sets transform expensive O(m) string searches into O(1) lookups, making subset checking much more efficient while maintaining the same overall algorithm structure.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses hash sets to convert each person's company list for O(1) lookup time. For each person, we check if their companies form a subset of any other person's companies by iterating through their set and checking membership in other sets. This reduces the time complexity from O(n² × m²) to O(n² × m) where n is the number of people and m is the average number of companies per person.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Set Optimization (Optimal)	O(n² × m)	O(n × m)	Convert each list to hash set for O(1) lookup and efficient subset checking
Brute Force (Nested Loops)	O(n² × m²)	O(1)	Compare each person's list with every other person's list using nested loops

Hash Set Optimization (Optimal) — Algorithm Steps

Convert all company lists to hash sets for O(1) lookup
For each person, check if their set is a subset of any other person's set
Use hash set operations to check subset relationship efficiently
Only include indices of people whose sets are not subsets of others
Return result in increasing order (already maintained by iteration)

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Hash Sets

Convert all company lists to hash sets

Fast Lookup

Check subset using O(1) hash lookups

Subset Test

Iterate through smaller set checking membership

Collect Results

Add non-subset indices to result

Code -

solution.c — C

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

// Simple hash table implementation for strings
#define HASH_SIZE 1009

typedef struct HashNode {
    char* key;
    struct HashNode* next;
} HashNode;

typedef struct {
    HashNode* buckets[HASH_SIZE];
} HashSet;

unsigned int hash(const char* str) {
    unsigned int hash = 5381;
    int c;
    while ((c = *str++)) {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % HASH_SIZE;
}

int contains(HashSet* set, const char* key) {
    unsigned int index = hash(key);
    HashNode* node = set->buckets[index];
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return 1;
        }
        node = node->next;
    }
    return 0;
}

void insert(HashSet* set, const char* key) {
    if (contains(set, key)) return;
    
    unsigned int index = hash(key);
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    node->key = strdup(key);
    node->next = set->buckets[index];
    set->buckets[index] = node;
}

int* peopleIndexes(char*** favoriteCompanies, int* favoriteCompaniesSize, int favoriteCompaniesColSize, int* returnSize) {
    // Create hash sets for each person
    HashSet* sets = (HashSet*)calloc(favoriteCompaniesColSize, sizeof(HashSet));
    
    for (int i = 0; i < favoriteCompaniesColSize; i++) {
        for (int j = 0; j < favoriteCompaniesSize[i]; j++) {
            insert(&sets[i], favoriteCompanies[i][j]);
        }
    }
    
    int* result = (int*)malloc(favoriteCompaniesColSize * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < favoriteCompaniesColSize; i++) {
        int isSubset = 0;
        
        for (int j = 0; j < favoriteCompaniesColSize; j++) {
            if (i == j) continue;
            
            if (favoriteCompaniesSize[i] <= favoriteCompaniesSize[j]) {
                int allFound = 1;
                for (int k = 0; k < favoriteCompaniesSize[i]; k++) {
                    if (!contains(&sets[j], favoriteCompanies[i][k])) {
                        allFound = 0;
                        break;
                    }
                }
                
                if (allFound) {
                    isSubset = 1;
                    break;
                }
            }
        }
        
        if (!isSubset) {
            result[(*returnSize)++] = i;
        }
    }
    
    // Cleanup
    free(sets);
    return result;
}

int main() {
    printf("Hash set solution ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

n people compared with n people, each subset check takes O(m) where m is smaller list size

⚠ Quadratic Growth

Space Complexity

O(n × m)

Hash sets for each person's companies, where n is number of people and m is average companies per person

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Hash Set Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler