Maximize Consecutive Elements in an Array After Modification

Maximize Consecutive Elements in an Array After Modification - Problem

You're given an array of positive integers, and you have a special power: you can increase any element by at most 1. Your goal is to create the longest possible consecutive sequence by selecting elements from your modified array.

For example, if you have [2, 3, 5], you could increase the last element to get [2, 3, 6], but you still can't form a consecutive sequence longer than 2 elements. However, if you increase it to 4, you get [2, 3, 4] - a perfect consecutive sequence of length 3!

Consecutive means: Elements that follow each other in order when sorted, like [3, 4, 5] ✅

Not consecutive: [3, 4, 6] ❌ (gap between 4 and 6), [1, 1, 2, 3] ❌ (duplicates)

Return the maximum number of elements you can select to form a consecutive sequence.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2, 3, 5, 4]

› Output: 4

💡 Note: We can use all elements: keep 2, 3, 4 as they are, and increment 5 to 6. This gives us the consecutive sequence [2, 3, 4, 5] with length 4.

example_2.py — Increment Strategy

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

› Output: 4

💡 Note: Increment one of the 1s to 2, and increment the other 1 to get another value. We can form [1, 2, 3, 4] by using the two 1s (one as 1, one incremented to 2), the 2 (incremented to 3), and the 3 (incremented to 4).

example_3.py — Optimal Selection

$ Input: nums = [1, 5, 51, 50, 100]

› Output: 3

💡 Note: The best consecutive sequence we can form is [49, 50, 51] by using: 51 as is, 50 as is, and increment 50-1=49 (but we don't have 49, so we increment 50 to 51... wait, let's reconsider: we can form [50, 51, 52] using 50, 51, and increment 51 to 52. Actually, the optimal is [1, 2, 3] using 1, increment 1 to 2, increment 5 to 2 (no, that's wrong). Let me recalculate: we can get [50, 51, 52] with length 3.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
Each element can be increased by at most 1
The resulting consecutive sequence must have distinct elements

Visualization

Tap to expand

Understanding the Visualization

Survey Your Stones

Count how many stones of each number you have. Each stone can either stay at its value or be upgraded by +1.

Try Each Starting Point

For each possible starting number, try to build the longest consecutive bridge from that point.

Greedy Bridge Building

At each position, use available stones optimally. Prefer using stones at their original value when possible.

Find the Longest Bridge

Compare all possible starting points and return the longest consecutive sequence found.

Key Takeaway

🎯 Key Insight: The problem becomes finding the longest consecutive sequence where each position can be filled by elements from at most two source values (original or decremented by 1).

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal solution uses dynamic programming with frequency counting. We count how many times each number appears, then for each possible starting position, greedily build the longest consecutive sequence. Each element can contribute to its original position or be incremented to fill the next position. The key insight is that this problem reduces to finding the longest consecutive sequence where each position can be filled by elements from two possible source values.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Starting Points)	O(n²)	O(n)	For each possible starting value, try to build the longest consecutive sequence
Two-Pass Hash Table (Frequency Counting)	O(n²)	O(n)	Count frequencies of possible values, then find longest consecutive sequence
Dynamic Programming with Frequency Map (Optimal)	O(n)	O(n)	Use DP to build consecutive sequences efficiently in one pass

Brute Force (Try All Starting Points) — Algorithm Steps

Get all unique values from the array and their +1 versions
For each potential starting value, try to build consecutive sequence
For each consecutive position, count available elements (original or +1)
Track the maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Starting Point

Pick a potential starting value from our array or array+1

Extend Sequence

For each consecutive number, count available elements

Track Maximum

Keep track of the longest sequence found

Code -

solution.c — C

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

int maximizeConsecutiveElements(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    // Find min and max for range
    int minVal = nums[0], maxVal = nums[0];
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < minVal) minVal = nums[i];
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    int maxLength = 0;
    
    // Try each possible starting value
    for (int start = minVal; start <= maxVal + 1; start++) {
        int length = 0;
        int current = start;
        
        while (current <= maxVal + 1) {
            int count = 0;
            for (int i = 0; i < numsSize; i++) {
                if (nums[i] == current || nums[i] == current - 1) {
                    count++;
                }
            }
            
            if (count > 0) {
                length++;
                current++;
            } else {
                break;
            }
        }
        
        if (length > maxLength) {
            maxLength = length;
        }
    }
    
    return maxLength;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of O(n) starting points, we check O(n) elements

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing unique values and counting

⚡ Linearithmic Space

38.2K Views

High Frequency

~25 min Avg. Time

1.3K 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 Starting Points) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler