Minimum Incompatibility

Minimum Incompatibility - Problem

You are given an integer array nums and an integer k. You are asked to distribute this array into k subsets of equal size such that there are no two equal elements in the same subset.

A subset's incompatibility is the difference between the maximum and minimum elements in that array.

Return the minimum possible sum of incompatibilities of the k subsets after distributing the array optimally, or return -1 if it is not possible.

A subset is a group of integers that appear in the array with no particular order.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Optimal distribution: [1,4] and [1,2]. Incompatibilities: (4-1) + (2-1) = 3 + 1 = 4

Example 2 — Impossible Case

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

› Output: 6

💡 Note: Each subset has size 2. Possible distribution: [1,2], [1,3], [3,6], [2,8] with incompatibilities 1+2+3+6=12, but optimal is different

Example 3 — All Same Elements

$ Input: nums = [5,5,5,5], k = 2

› Output: -1

💡 Note: Cannot form 2 subsets without duplicate elements since all elements are the same

Constraints

1 ≤ k ≤ nums.length ≤ 16
nums.length is divisible by k
1 ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8

The key insight is to use bitmask dynamic programming to efficiently track which elements have been used while avoiding redundant calculations. The optimal approach precomputes all valid subsets and uses DP to find minimum incompatibility sum. Time: O(3^n), Space: O(2^n)

Common Approaches

✓ Brute Force Backtracking

⏱️ Time: O(k! × (n/k)^k) Space: O(n)

Use recursive backtracking to generate all possible ways to divide the array into k equal-sized subsets, ensuring no duplicates within each subset, and calculate the minimum sum of incompatibilities.

Dynamic Programming with Bitmask

⏱️ Time: O(3^n) Space: O(2^n)

Use dynamic programming with bitmasks to represent which elements have been used. Precompute all valid subsets and their incompatibilities, then use DP to find the minimum sum.

Brute Force Backtracking — Algorithm Steps

Sort array to handle duplicates efficiently
Use backtracking to try all subset formations
For each complete formation, calculate sum of incompatibilities
Return minimum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Sort array and create k empty subsets

Backtrack

Try placing each element in each valid subset

Calculate

When all elements placed, compute sum of incompatibilities

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int findMin(int* arr, int size) {
    int min = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] < min) min = arr[i];
    }
    return min;
}

int findMax(int* arr, int size) {
    int max = arr[0];
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) max = arr[i];
    }
    return max;
}

int contains(int* arr, int size, int val) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == val) return 1;
    }
    return 0;
}

int backtrack(int idx, int* nums, int n, int** subsets, int* subsetSizes, int k, int subsetSize) {
    if (idx == n) {
        int sum = 0;
        for (int i = 0; i < k; i++) {
            if (subsetSizes[i] > 0) {
                sum += findMax(subsets[i], subsetSizes[i]) - findMin(subsets[i], subsetSizes[i]);
            }
        }
        return sum;
    }
    
    int minIncomp = INT_MAX;
    
    for (int i = 0; i < k; i++) {
        if (subsetSizes[i] < subsetSize && !contains(subsets[i], subsetSizes[i], nums[idx])) {
            subsets[i][subsetSizes[i]] = nums[idx];
            subsetSizes[i]++;
            int result = backtrack(idx + 1, nums, n, subsets, subsetSizes, k, subsetSize);
            if (result < minIncomp) minIncomp = result;
            subsetSizes[i]--;
        }
        
        if (subsetSizes[i] == 0) break;
    }
    
    return minIncomp;
}

int solution(int* nums, int numsSize, int k) {
    if (numsSize % k != 0) return -1;
    
    int subsetSize = numsSize / k;
    qsort(nums, numsSize, sizeof(int), compare);
    
    // Check if distribution is possible
    int count[2001] = {0}; // Assuming nums[i] in range [-1000, 1000]
    for (int i = 0; i < numsSize; i++) {
        count[nums[i] + 1000]++;
    }
    for (int i = 0; i < 2001; i++) {
        if (count[i] > k) return -1;
    }
    
    int** subsets = (int**)malloc(k * sizeof(int*));
    int* subsetSizes = (int*)calloc(k, sizeof(int));
    for (int i = 0; i < k; i++) {
        subsets[i] = (int*)malloc(subsetSize * sizeof(int));
    }
    
    int result = backtrack(0, nums, numsSize, subsets, subsetSizes, k, subsetSize);
    
    for (int i = 0; i < k; i++) {
        free(subsets[i]);
    }
    free(subsets);
    free(subsetSizes);
    
    return result == INT_MAX ? -1 : result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array
    int nums[100];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k! × (n/k)^k)

For each of k subsets, we try all ways to choose n/k elements, with k! ways to arrange subsets

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth up to n levels plus space for tracking used elements

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~45 min Avg. Time

234 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 Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler