Minimum Unique Material Identifiers — Problem Statement & Solution Guide

#include <iostream>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
using namespace std;

class Solution {
public:
    int minUniqueMaterialIdentifiers(vector<vector<int>>& rooms) {
        // Count frequency of each material type across all rooms
        unordered_map<int, int> materialFreq;
        for (const auto& room : rooms) {
            unordered_set<int> uniqueMaterialsInRoom(room.begin(), room.end());
            for (int mat : uniqueMaterialsInRoom) {
                materialFreq[mat]++;
            }
        }

        // The minimum number of distinct identifiers needed is the maximum frequency
        // of any single material type, because each occurrence of that material in
        // different rooms must have a distinct identifier.
        int maxFreq = 0;
        for (const auto& pair : materialFreq) {
            maxFreq = max(maxFreq, pair.second);
        }

        return maxFreq;
    }
};

int main() {
    vector<vector<int>> rooms = {{1, 2}, {2, 3}, {1, 3, 4}};
    Solution sol;
    cout << sol.minUniqueMaterialIdentifiers(rooms) << endl;
    return 0;
}

import java.util.*;

class Solution {
    public int minUniqueMaterialIdentifiers(int[][] rooms) {
        // Count frequency of each material type across all rooms
        Map<Integer, Integer> materialFreq = new HashMap<>();
        
        for (int[] room : rooms) {
            // Use a Set to handle duplicate materials within the same room
            Set<Integer> uniqueMaterials = new HashSet<>(Arrays.asList(room));
            for (int mat : uniqueMaterials) {
                materialFreq.put(mat, materialFreq.getOrDefault(mat, 0) + 1);
            }
        }

        // The minimum number of distinct identifiers needed is the maximum frequency
        // of any single material type.
        int maxFreq = 0;
        for (int count : materialFreq.values()) {
            maxFreq = Math.max(maxFreq, count);
        }

        return maxFreq;
    }

    public static void main(String[] args) {
        int[][] rooms = {{1, 2}, {2, 3}, {1, 3, 4}};
        Solution sol = new Solution();
        System.out.println(sol.minUniqueMaterialIdentifiers(rooms));
    }
}

from typing import List

class Solution:
    def minUniqueMaterialIdentifiers(self, rooms: List[List[int]]) -> int:
        # Count frequency of each material type across all rooms
        material_freq = {}
        
        for room in rooms:
            # Use a set to handle duplicate materials within the same room
            unique_materials = set(room)
            for mat in unique_materials:
                material_freq[mat] = material_freq.get(mat, 0) + 1

        # The minimum number of distinct identifiers needed is the maximum frequency
        # of any single material type.
        if not material_freq:
            return 0
        
        return max(material_freq.values())

# Example usage
if __name__ == "__main__":
    sol = Solution()
    rooms = [[1, 2], [2, 3], [1, 3, 4]]
    print(sol.minUniqueMaterialIdentifiers(rooms))

/**
 * @param {number[][]} rooms
 * @return {number}
 */
var minUniqueMaterialIdentifiers = function(rooms) {
    // Count frequency of each material type across all rooms
    const materialFreq = new Map();
    
    for (const room of rooms) {
        // Use a Set to handle duplicate materials within the same room
        const uniqueMaterials = new Set(room);
        for (const mat of uniqueMaterials) {
            materialFreq.set(mat, (materialFreq.get(mat) || 0) + 1);
        }
    }

    // The minimum number of distinct identifiers needed is the maximum frequency
    // of any single material type.
    let maxFreq = 0;
    for (const count of materialFreq.values()) {
        maxFreq = Math.max(maxFreq, count);
    }

    return maxFreq;
};

// Example usage
const rooms = [[1, 2], [2, 3], [1, 3, 4]];
console.log(minUniqueMaterialIdentifiers(rooms));