Codestin Search App

Minimum Incompatibility - Problem

The Challenge: You're given an integer array nums and an integer k. Your task is to distribute this array into exactly k subsets of equal size, with one crucial rule: no two equal elements can be in the same subset.

What is Incompatibility? For any subset, the incompatibility is simply the difference between its maximum and minimum elements. For example, if a subset contains [2, 5, 8], its incompatibility is 8 - 2 = 6.

Your Goal: Find the minimum possible sum of incompatibilities across all k subsets after optimally distributing the elements. If it's impossible to create valid subsets (due to duplicate constraints), return -1.

Example: Given nums = [1,2,1,4] and k = 2, you could create subsets [1,2] and [1,4] with incompatibilities 1 and 3 respectively, for a total of 4.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,1,4], k = 2

› Output: 4

💡 Note: We can distribute into subsets [1,2] and [1,4]. Incompatibility of [1,2] is 2-1=1, and [1,4] is 4-1=3. Total is 1+3=4.

example_2.py — Impossible Case

$ Input: nums = [6,3,8,1,3,1,2,2], k = 4

› Output: -1

💡 Note: We need 4 subsets of size 2 each. Since we have 2 ones, 2 twos, and 2 threes, but each can appear in at most 4 subsets, this is theoretically possible. However, the optimal arrangement gives us subsets like [1,6], [2,3], [1,8], [2,3] with total incompatibility 5+1+7+1=14. But let's verify: we can actually form [1,2], [1,3], [2,6], [3,8] for costs 1+2+4+5=12.

example_3.py — Single Elements

$ Input: nums = [5,3,3,6,3,3], k = 3

› Output: -1

💡 Note: We have four 3's but need 3 subsets of size 2 each. Since each 3 can appear in at most 3 subsets, but we have 4 of them, it's impossible to distribute without having duplicates in the same subset.

Constraints

1 ≤ k ≤ nums.length ≤ 16
nums.length is divisible by k
1 ≤ nums[i] ≤ nums.length
Important: The constraint n ≤ 16 makes bitmask DP feasible

Visualization

Tap to expand

Understanding the Visualization

Check Feasibility

Verify that no skill level appears more times than the number of teams

Generate Valid Teams

Find all possible team combinations with unique skill levels

Calculate Team Weakness

For each valid team, compute skill gap (max - min)

Optimize Assignment

Use DP to find the assignment that minimizes total weakness

Key Takeaway

🎯 Key Insight: Bitmask DP allows us to efficiently track which elements are used while avoiding redundant subproblem calculations, making this exponential problem solvable for the given constraints.

Asked in

G Google 15 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses Dynamic Programming with Bitmasks to efficiently explore all valid partitions. We precompute incompatibilities for all valid subsets, then use DP where dp[mask] represents the minimum cost to partition elements represented by the bitmask. The key insight is that bitmasks let us track element usage and avoid redundant calculations, achieving O(3^n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(k^n * n!)	O(n)	Generate all possible ways to partition the array into k subsets and find the minimum sum
Dynamic Programming with Bitmask (Optimal)	O(3^n)	O(2^n)	Use bitmask DP to efficiently track used elements and avoid redundant calculations

Brute Force (Try All Combinations) — Algorithm Steps

Check if partition is possible (each unique element appears at most k times)
Use backtracking to try all ways to assign elements to k subsets
For each assignment, verify no subset contains duplicates
Calculate incompatibility for each subset and sum them up
Track the minimum sum across all valid partitions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Assignment

Begin with empty subsets and first element

Try All Subsets

For each element, try placing it in each valid subset

Check Constraints

Ensure no duplicates in same subset and size limits

Calculate Score

When all elements placed, compute total incompatibility

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <stdbool.h>

#define MAX_N 16

int count[MAX_N];
bool subsets[MAX_N][MAX_N];
int subset_sizes[MAX_N];

int backtrack(int index, int* nums, int n, int k, int subset_size) {
    if (index == n) {
        int total = 0;
        for (int i = 0; i < k; i++) {
            if (subset_sizes[i] == subset_size) {
                int min_val = INT_MAX, max_val = INT_MIN;
                for (int j = 0; j < n; j++) {
                    if (subsets[i][j]) {
                        if (nums[j] < min_val) min_val = nums[j];
                        if (nums[j] > max_val) max_val = nums[j];
                    }
                }
                total += max_val - min_val;
            } else {
                return INT_MAX;
            }
        }
        return total;
    }
    
    int min_incomp = INT_MAX;
    int num = nums[index];
    
    for (int i = 0; i < k; i++) {
        if (subset_sizes[i] < subset_size) {
            // Check if num already in subset i
            bool has_num = false;
            for (int j = 0; j < index; j++) {
                if (subsets[i][j] && nums[j] == num) {
                    has_num = true;
                    break;
                }
            }
            
            if (!has_num) {
                subsets[i][index] = true;
                subset_sizes[i]++;
                int temp = backtrack(index + 1, nums, n, k, subset_size);
                if (temp != INT_MAX && temp < min_incomp) {
                    min_incomp = temp;
                }
                subsets[i][index] = false;
                subset_sizes[i]--;
            }
        }
        
        if (subset_sizes[i] == 0) break;
    }
    
    return min_incomp;
}

int minimumIncompatibility(int* nums, int numsSize, int k) {
    if (numsSize % k != 0) return -1;
    
    int subset_size = numsSize / k;
    
    // Count occurrences
    for (int i = 0; i < MAX_N; i++) count[i] = 0;
    for (int i = 0; i < numsSize; i++) {
        count[nums[i]]++;
        if (count[nums[i]] > k) return -1;
    }
    
    // Initialize
    for (int i = 0; i < k; i++) {
        subset_sizes[i] = 0;
        for (int j = 0; j < numsSize; j++) {
            subsets[i][j] = false;
        }
    }
    
    int result = backtrack(0, nums, numsSize, k, subset_size);
    return result == INT_MAX ? -1 : result;
}

int main() {
    int nums[] = {1, 2, 1, 4};
    int k = 2;
    printf("%d\n", minimumIncompatibility(nums, 4, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n * n!)

We try k choices for each of n elements, plus the cost of generating permutations

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and space to store current partition

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

847 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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler