Maximum Number of Distinct Elements After Operations

Maximum Number of Distinct Elements After Operations - Problem

You're given an integer array nums and an integer k. Your mission is to maximize the number of distinct elements in the array by strategically adjusting each element.

The Rule: For each element in the array, you can perform at most one operation - add any integer from the range [-k, k] to that element. This means you can decrease it by up to k, increase it by up to k, or leave it unchanged.

Goal: Return the maximum possible number of distinct elements after performing these operations optimally.

Example: If nums = [1, 2, 2, 3] and k = 1, you could transform it to [1, 1, 3, 3] (no change, decrease by 1, increase by 1, no change) to get 3 distinct elements. But with better strategy: [0, 2, 1, 3] gives you 4 distinct elements!

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: We can transform the array to [0, 1, 3, 4]: subtract 1 from first element (1-1=0), subtract 1 from second element (2-1=1), add 1 to third element (2+1=3), add 1 to fourth element (3+1=4). All four values are distinct.

example_2.py — No Operations Needed

$ Input: nums = [4, 6, 16, 18], k = 3

› Output: 4

💡 Note: All elements are already distinct and no operations are needed. The answer is 4.

example_3.py — Limited by Range

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

› Output: 3

💡 Note: We can transform to [0, 1, 2, 1]: first element becomes 0 (1-1), second becomes 1 (no change), third becomes 2 (1+1), fourth stays as 1. But this gives duplicate! Better: [0, 1, 2, cannot assign unique value to fourth element within range [0,2]]. Maximum distinct is 3.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 10⁹
Each element can be modified at most once

Visualization

Tap to expand

Understanding the Visualization

Sort the array

Process elements in ascending order to handle smaller values first

Track next available value

Maintain a pointer to the next distinct value that can be assigned

Greedy assignment

For each element, assign max(next_available, element-k) if it's ≤ element+k

Update and continue

Increment next_available and move to the next element

Key Takeaway

🎯 Key Insight: The greedy approach works because choosing the smallest available value within range always leaves maximum flexibility for future assignments, guaranteeing the optimal solution.

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a greedy approach with sorting. After sorting the array, we process each element and assign it the smallest available value within its adjustment range [element-k, element+k]. This greedy strategy maximizes the number of distinct elements in O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Sorting (Optimal)	O(n log n)	O(1)	Sort array and greedily assign smallest possible distinct values
Brute Force (Try All Combinations)	O((2k+1)^n)	O(n)	Generate all possible combinations of adjustments and count distinct elements

Greedy with Sorting (Optimal) — Algorithm Steps

Sort the input array to process elements in ascending order
Initialize a variable to track the next available distinct value
For each element, calculate its valid range [element-k, element+k]
Assign the maximum of (next available value, element-k) to ensure uniqueness
Update next available value and increment distinct count

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort the array

Process elements in ascending order: [1,2,2,3]

Process first element

Assign value 0 to first element (1-1=0)

Process subsequent elements

For each element, assign smallest available value in range

Count distinct values

Result: [0,1,3,4] gives 4 distinct elements

Code -

solution.c — C

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

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

int maxDistinctElements(int* nums, int numsSize, int k) {
    // Sort array to process in ascending order
    qsort(nums, numsSize, sizeof(int), compare);
    
    int distinctCount = 0;
    long long nextAvailable = LLONG_MIN;
    
    for (int i = 0; i < numsSize; i++) {
        // Calculate valid range for current number
        long long minPossible = (long long)nums[i] - k;
        long long maxPossible = (long long)nums[i] + k;
        
        // Choose the smallest available value in range
        long long chosenValue = (nextAvailable > minPossible) ? nextAvailable : minPossible;
        
        // Check if chosen value is within valid range
        if (chosenValue <= maxPossible) {
            distinctCount++;
            nextAvailable = chosenValue + 1;
        }
    }
    
    return distinctCount;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then single pass through array takes O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for tracking variables (excluding space for sorting)

✓ Linear Space

26.8K Views

Medium Frequency

~18 min Avg. Time

834 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

Greedy with Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler