Maximum Number of Distinct Elements After Operations

Maximum Number of Distinct Elements After Operations - Problem

You are given an integer array nums and an integer k.

You are allowed to perform the following operation on each element of the array at most once:

Add an integer in the range [-k, k] to the element.

Return the maximum possible number of distinct elements in nums after performing the operations.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: We can adjust: 1→1, 2→3, 4→5, giving us [1,3,5] with 3 distinct elements. All adjustments are within [-2,2] range.

Example 2 — With Duplicates

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

› Output: 4

💡 Note: After sorting [1,2,2,4], we can assign: 1→-1, 2→0, 2→1, 4→2, giving us [-1,0,1,2] with 4 distinct elements.

Example 3 — Small Range

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

› Output: 3

💡 Note: We can adjust to [4,5,6] using adjustments [-1,0,+1], all within range [-1,1], giving 3 distinct elements.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to sort the array first, then greedily assign the smallest available value within the allowed range for each element. This greedy approach maximizes distinct elements efficiently. Best approach uses sorting with greedy assignment. Time: O(n log n), Space: O(n)

Common Approaches

✓ Sort First

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O((2k+1)ⁿ) Space: O(n)

Generate all possible combinations of adjustments for each element and count distinct values in each combination. This explores the entire solution space but is extremely inefficient.

Greedy with Sorting

⏱️ Time: O(n log n) Space: O(n)

Sort the array first, then for each element, try to assign the smallest possible value that hasn't been used yet. This greedy approach ensures maximum distinct elements efficiently.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

int* parseArray(char* line, int* size) {
    *size = 0;
    int capacity = 100;
    int* nums = (int*)malloc(capacity * sizeof(int));
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr == ']') break;
        
        int num = 0;
        int sign = 1;
        if (*ptr == '-') {
            sign = -1;
            ptr++;
        }
        
        while (*ptr >= '0' && *ptr <= '9') {
            num = num * 10 + (*ptr - '0');
            ptr++;
        }
        
        if (*size >= capacity) {
            capacity *= 2;
            nums = (int*)realloc(nums, capacity * sizeof(int));
        }
        
        nums[(*size)++] = sign * num;
    }
    
    return nums;
}

int maxDistinctElements(int* nums, int numsSize, int k) {
    // Sort the array
    qsort(nums, numsSize, sizeof(int), compare);
    
    int distinctCount = 0;
    int lastUsed = nums[0] - k - 1; // Initialize to a value smaller than any possible first element
    
    for (int i = 0; i < numsSize; i++) {
        // Try to place current element as close to lastUsed as possible
        // but within the range [nums[i] - k, nums[i] + k]
        int minPossible = nums[i] - k;
        int maxPossible = nums[i] + k;
        
        // We want to place it at the smallest value > lastUsed within the range
        int target;
        if (lastUsed + 1 <= maxPossible) {
            target = (lastUsed + 1 > minPossible) ? lastUsed + 1 : minPossible;
        } else {
            // Cannot make this element distinct
            continue;
        }
        
        distinctCount++;
        lastUsed = target;
    }
    
    return distinctCount;
}

int main() {
    char line1[10000];
    char line2[100];
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int numsSize;
    int* nums = parseArray(line1, &numsSize);
    int k = atoi(line2);
    
    int result = maxDistinctElements(nums, numsSize, k);
    printf("%d\n", result);
    
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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