Maximize The Topmost Element After K Moves - Leetcode Solution

Problem Statement:

You are given an array of integers nums and an integer k. In exactly k moves, you need to maximize the topmost element of the array.

A move consists of choosing any element of the array and incrementing it by 1.

Return the maximum element in the array after performing k moves.

Solution:

Approach

We can solve this by observing that after k moves, we only need to increment the k smallest elements in the array as these will be the elements that will become the new maximum. This is because to maximize the topmost element, we need to increment the smallest elements in the array that are not currently the largest.

So we can first sort the array in ascending order and then iterate from the beginning of the array and increment the k smallest elements. At each iteration, we decrement k by the number of increments we made. If k becomes 0, we break out of the loop and return the maximum element of the array.

If k is still greater than 0 after iterating through the array, this means that all elements have been incremented and we need to increment the maximum element of the array k more times.

Algorithm

1. Sort the given array nums in ascending order.
2. Initialize a variable i = 0.
3. While k > 0, do the following: a. Increment nums[i] by min(k, nums[i+1] - nums[i]). b. Decrement k by the number of increments made in the previous step. c. Increment i by 1. d. If i reaches the end of the array, break out of the loop.
4. If k is still greater than 0, increment nums[n-1] by k.
5. Return the maximum element of the array nums.

Time Complexity

Sorting the array takes O(nlogn) time. Iterating through the array takes O(n) time. Therefore, the total time complexity of the algorithm is O(nlogn).

Code

Python:

class Solution: def maxSumAfterKIncrements(self, nums: List[int], k: int) -> int: nums.sort() i = 0 n = len(nums) while k > 0 and i < n - 1: increments = min(k, nums[i+1] - nums[i]) nums[i] += increments k -= increments i += 1 if k > 0: nums[n-1] += k return max(nums)

Java:

class Solution { public int maxSumAfterKIncrements(int[] nums, int k) { Arrays.sort(nums); int i = 0; int n = nums.length; while (k > 0 && i < n - 1) { int increments = Math.min(k, nums[i+1] - nums[i]); nums[i] += increments; k -= increments; i += 1; } if (k > 0) { nums[n-1] += k; } int max = Integer.MIN_VALUE; for (int num: nums) { max = Math.max(max, num); } return max; } }

Conclusion:

In this problem, we have solved by observing that after k moves, we only need to increment the k smallest elements in the array as these will be the elements that will become the new maximum. The approach is used to sort the array and then iterate from the beginning of the array. We can achieve the solution in O(nlogn) time.

1