Maximum Element After Decreasing and Rearranging

Maximum Element After Decreasing and Rearranging - Problem

You are given an array of positive integers arr. Perform some operations (possibly none) on arr so that it satisfies these conditions:

The value of the first element in arr must be 1.
The absolute difference between any 2 adjacent elements must be less than or equal to 1. In other words, abs(arr[i] - arr[i - 1]) <= 1 for each i where 1 <= i < arr.length (0-indexed). abs(x) is the absolute value of x.

There are 2 types of operations that you can perform any number of times:

Decrease the value of any element of arr to a smaller positive integer.
Rearrange the elements of arr to be in any order.

Return the maximum possible value of an element in arr after performing the operations to satisfy the conditions.

Input & Output

Example 1 — Basic Case

$ Input: arr = [2,1,3,5,4]

› Output: 5

💡 Note: Sort to [1,2,3,4,5]. Build staircase: arr[0]=1, arr[1]=min(2,2)=2, arr[2]=min(3,3)=3, arr[3]=min(4,4)=4, arr[4]=min(5,5)=5. Maximum is 5.

Example 2 — Large Values Need Reduction

$ Input: arr = [100,1,1000]

› Output: 3

💡 Note: Sort to [1,100,1000]. Build staircase: arr[0]=1, arr[1]=min(100,2)=2, arr[2]=min(1000,3)=3. Maximum is 3.

Example 3 — Already Optimal

$ Input: arr = [1,2,3,4]

› Output: 4

💡 Note: Already sorted and valid staircase. Each element can keep its value: 1→2→3→4. Maximum is 4.

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8 M Microsoft 6

The key insight is that sorting the array allows us to greedily build the tallest possible staircase. After sorting, each position gets the minimum of its original value or one more than the previous position. Best approach is greedy after sorting. Time: O(n log n), Space: O(1)

Common Approaches

✓ Sliding Window

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

Brute Force - Try All Arrangements

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

Try every possible rearrangement of the array, then for each arrangement try all possible ways to decrease elements to satisfy constraints. This involves exponential combinations of arrangements and decreases.

Optimal Greedy - Maximum Staircase Height

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

The key insight is that after sorting, we can greedily assign values to maximize the final result. Each position gets the minimum of its original value or one more than the previous position.

Sort First - Greedy Construction

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

Sort the array first to maximize our chances of building the tallest staircase. Then iterate through sorted elements, setting each position to the minimum of the current element or the maximum allowed value (previous + 1).

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

32.0K Views

Medium Frequency

~15 min Avg. Time

892 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