Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1846.html

1846. Maximum Element After Decreasing and Rearranging

Level

Medium

Description

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.

Example 1:

Input: arr = [2,2,1,2,1]

Output: 2

Explanation:

We can satisfy the conditions by rearranging arr so it becomes [1,2,2,2,1].

The largest element in arr is 2.

Example 2:

Input: arr = [100,1,1000]

Output: 3

Explanation:

One possible way to satisfy the conditions is by doing the following:

  1. Rearrange arr so it becomes [1,100,1000].
  2. Decrease the value of the second element to 2.
  3. Decrease the value of the third element to 3.

Now arr = [1,2,3], which satisfies the conditions.

The largest element in arr is 3.

Example 3:

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

Output: 5

Explanation: The array already satisfies the conditions, and the largest element is 5.

Constraints:

  • 1 <= arr.length <= 10^5
  • 1 <= arr[i] <= 10^9

Solution

Sort arr and let arr[0] = 1. For 1 <= i < arr.length, set arr[i] to the minimum of arr[i] and arr[i - 1] + 1. Finally, return arr[arr.length - 1].

  • class Solution {
    public int maximumElementAfterDecrementingAndRearranging(int[] arr) {
        Arrays.sort(arr);
        int length = arr.length;
        arr[0] = 1;
        for (int i = 1; i < length; i++)
            arr[i] = Math.min(arr[i], arr[i - 1] + 1);
        return arr[length - 1];
    }
}

############

class Solution {
    public int maximumElementAfterDecrementingAndRearranging(int[] arr) {
        Arrays.sort(arr);
        arr[0] = 1;
        int ans = 1;
        for (int i = 1; i < arr.length; ++i) {
            int d = Math.max(0, arr[i] - arr[i - 1] - 1);
            arr[i] -= d;
            ans = Math.max(ans, arr[i]);
        }
        return ans;
    }
}

  • // OJ: https://leetcode.com/problems/maximum-element-after-decreasing-and-rearranging/
// Time: O(NlogN)
// Space: O(1)
class Solution {
public:
    int maximumElementAfterDecrementingAndRearranging(vector<int>& A) {
        sort(begin(A), end(A));
        A[0] = 1;
        for (int i = 1; i < A.size(); ++i) {
            A[i] = min(A[i - 1] + 1, A[i]);
        }
        return A.back();
    }
};

  • class Solution:
    def maximumElementAfterDecrementingAndRearranging(self, arr: List[int]) -> int:
        arr.sort()
        arr[0] = 1
        for i in range(1, len(arr)):
            d = max(0, arr[i] - arr[i - 1] - 1)
            arr[i] -= d
        return max(arr)

############

# 1846. Maximum Element After Decreasing and Rearranging
# https://leetcode.com/problems/maximum-element-after-decreasing-and-rearranging/

class Solution:
    def maximumElementAfterDecrementingAndRearranging(self, arr: List[int]) -> int:
        n = len(arr)
        arr.sort()
        
        arr[0] = 1
        for i in range(1, n):
            arr[i] = min(arr[i - 1] + 1, arr[i])
        
        return max(arr)


  • func maximumElementAfterDecrementingAndRearranging(arr []int) int {
	sort.Ints(arr)
	ans := 1
	arr[0] = 1
	for i := 1; i < len(arr); i++ {
		d := max(0, arr[i]-arr[i-1]-1)
		arr[i] -= d
		ans = max(ans, arr[i])
	}
	return ans
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

  • function maximumElementAfterDecrementingAndRearranging(arr: number[]): number {
    arr.sort((a, b) => a - b);
    arr[0] = 1;
    let ans = 1;
    for (let i = 1; i < arr.length; ++i) {
        const d = Math.max(0, arr[i] - arr[i - 1] - 1);
        arr[i] -= d;
        ans = Math.max(ans, arr[i]);
    }
    return ans;
};

  • public class Solution {
    public int MaximumElementAfterDecrementingAndRearranging(int[] arr) {
        Array.Sort(arr);
        int n = arr.Length;
        arr[0] = 1;
        for (int i = 1; i < n; ++i) {
            arr[i] = Math.Min(arr[i], arr[i - 1] + 1);
        }
        return arr[n - 1];
    }
}

All Problems

All Solutions