Maximum Element After Decreasing and Rearranging

Maximum Element After Decreasing and Rearranging - Problem

Maximum Element After Decreasing and Rearranging

You're given an array of positive integers and need to transform it to satisfy two key constraints:

Constraints to satisfy:
1. The first element must be 1
2. Adjacent elements can differ by at most 1 (i.e., |arr[i] - arr[i-1]| ≤ 1)

Available operations:
• Decrease any element to a smaller positive integer
• Rearrange elements in any order

Your goal is to find the maximum possible value any element can have after performing these operations optimally.

Example: With array [2,2,1,2,1], you could rearrange to [1,2,2,1,2] then adjust to [1,2,3,2,3], but the optimal solution gives us a maximum value of 3.

Input & Output

example_1.py — Basic Case

$ Input: [2,2,1,2,1]

› Output: 3

💡 Note: After sorting: [1,1,2,2,2]. Set first to 1: [1,1,2,2,2]. Apply greedy: [1,2,3,3,3]. Maximum is 3.

example_2.py — Large Values

$ Input: [100,1,1000]

› Output: 3

💡 Note: After sorting: [1,1,100]. Set first to 1: [1,1,100]. Apply greedy: [1,2,3]. Even with large values, we're limited by the adjacent difference constraint.

example_3.py — All Same Values

$ Input: [1,1,1,1]

› Output: 4

💡 Note: After sorting: [1,1,1,1]. Set first to 1: [1,1,1,1]. Apply greedy: [1,2,3,4]. We can build a perfect staircase.

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁹
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Sort the Blocks

Arrange blocks from smallest to largest to maximize our building potential

Start at Height 1

The first step must be at height 1 (constraint requirement)

Build Greedily

For each subsequent step, use the smaller of: current block height or previous step + 1

Find Tallest Step

The maximum height achieved is our answer

Key Takeaway

🎯 Key Insight: After sorting, we can greedily build the tallest possible staircase by ensuring each step is at most 1 higher than the previous step.

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 21

The optimal solution uses a greedy approach after sorting. Key insight: since we must start with 1 and can increase by at most 1 per step, the maximum possible value at position i is min(arr[i], i+1). Sort the array, then greedily assign the minimum of current element and previous value + 1.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Arrangements)	O(n! × 2^n)	O(n!)	Generate all permutations and test each with all possible decreases
Greedy Approach (Optimal)	O(n log n)	O(1)	Sort array and greedily assign maximum possible value at each position

Brute Force (Try All Arrangements) — Algorithm Steps

Generate all n! permutations of the array
For each permutation, try all possible ways to decrease elements
Check if the arrangement satisfies both constraints
Track the maximum element value across all valid configurations
Return the overall maximum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements of the input array

Try All Decreases

For each arrangement, try all ways to decrease elements

Check Constraints

Verify first element is 1 and adjacent diff ≤ 1

Track Maximum

Keep track of the highest value found across all valid configurations

Code -

solution.c — C

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

int maxResult = 0;

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void backtrack(int* perm, int idx, int* current, int n) {
    if (idx == n) {
        if (current[0] != 1) return;
        for (int i = 1; i < n; i++) {
            if (abs(current[i] - current[i-1]) > 1) return;
        }
        int maxVal = 0;
        for (int i = 0; i < n; i++) {
            if (current[i] > maxVal) maxVal = current[i];
        }
        if (maxVal > maxResult) maxResult = maxVal;
        return;
    }
    
    for (int val = 1; val <= perm[idx]; val++) {
        current[idx] = val;
        backtrack(perm, idx + 1, current, n);
    }
}

void checkArrangement(int* perm, int n) {
    int* current = (int*)malloc(n * sizeof(int));
    backtrack(perm, 0, current, n);
    free(current);
}

void permute(int* arr, int start, int n) {
    if (start == n) {
        checkArrangement(arr, n);
        return;
    }
    
    for (int i = start; i < n; i++) {
        swap(&arr[start], &arr[i]);
        permute(arr, start + 1, n);
        swap(&arr[start], &arr[i]);
    }
}

int findMaximumElement(int* arr, int n) {
    maxResult = 0;
    permute(arr, 0, n);
    return maxResult;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse input array
    int arr[100];
    int n = 0;
    char* token = strtok(input, "[],\n ");
    while (token != NULL) {
        arr[n++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", findMaximumElement(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × 2^n)

n! permutations, each with 2^n possible decrease combinations

⚠ Quadratic Growth

Space Complexity

O(n!)

Storage for all permutations and recursive call stack

⚠ Quadratic Space

52.3K Views

Medium Frequency

~15 min Avg. Time

1.8K 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 Arrangements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler