Maximize the Topmost Element After K Moves

Maximize the Topmost Element After K Moves - Problem

Array Greedy Medium

You are given a 0-indexed integer array nums representing the contents of a pile, where nums[0] is the topmost element of the pile.

In one move, you can perform either of the following:

If the pile is not empty, remove the topmost element of the pile.
If there are one or more removed elements, add any one of them back onto the pile. This element becomes the new topmost element.

You are also given an integer k, which denotes the total number of moves to be made.

Return the maximum value of the topmost element of the pile possible after exactly k moves. In case it is not possible to obtain a non-empty pile after k moves, return -1.

Input & Output

Example 1 — Basic Case

$ Input: nums = [5,2,7,4,1], k = 2

› Output: 7

💡 Note: We can remove 5 and 2 (2 moves), making 7 the topmost element. Or remove 5, then add it back, then remove it and 2 to get 7 on top.

Example 2 — All Elements Removed

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

› Output: -1

💡 Note: With only 1 element and 1 move, we must remove it, leaving an empty pile.

Example 3 — Return to Original

$ Input: nums = [73,98,39,51], k = 4

› Output: 98

💡 Note: We can remove all 4 elements, then add back the maximum (98) to make it topmost.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ 2 × 10⁹
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Meta 12

The key insight is to analyze which elements are reachable with exactly k moves. We can remove up to k elements and potentially add them back. The optimal strategy depends on whether k allows us to access better elements deeper in the pile or return to previously removed ones. Best approach uses greedy analysis: Time O(n), Space O(1).

Common Approaches

✓ Sort First

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

Brute Force Simulation

⏱️ Time: O(2^k) Space: O(k)

Generate all possible move sequences by recursively trying both remove and add operations at each step. Track the maximum topmost element across all valid final states.

Greedy Strategy Analysis

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

Determine which elements can be reached with exactly k moves, then select the maximum. Handle special cases like odd/even move parity and insufficient moves.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int k) {
    if (numsSize == 0) return -1;
    
    // Special case: if we can do enough moves to remove all and add back any
    if (k >= 2 * numsSize) {
        int maxVal = nums[0];
        for (int i = 1; i < numsSize; i++) {
            if (nums[i] > maxVal) {
                maxVal = nums[i];
            }
        }
        return maxVal;
    }
    
    // If k is odd and equals numsSize, we remove all elements 
    // but must make one more move, so we add back the best removed element
    if (k == numsSize && numsSize > 1) {
        int maxVal = nums[0];
        for (int i = 1; i < numsSize; i++) {
            if (nums[i] > maxVal) {
                maxVal = nums[i];
            }
        }
        return maxVal;
    }
    
    // If k == 1 and numsSize == 1, we must remove the only element
    if (k == 1 && numsSize == 1) {
        return -1;
    }
    
    int maxResult = -1;
    
    // Case 1: Remove fewer than k elements, leaving element at position k on top
    if (k < numsSize) {
        maxResult = nums[k];
    }
    
    // Case 2: Remove exactly i elements (i <= k), then add back the best one
    // We need at least 1 move to remove and 1 move to add back
    for (int i = 1; i <= k && i <= numsSize; i++) {
        int remaining_moves = k - i;
        
        // We need at least 1 more move to add back an element
        if (remaining_moves >= 1) {
            // Find the maximum among the first i elements
            int maxRemoved = nums[0];
            for (int j = 1; j < i; j++) {
                if (nums[j] > maxRemoved) {
                    maxRemoved = nums[j];
                }
            }
            
            // After removing i elements and adding back one, we use i+1 moves
            // We still have k-(i+1) moves left
            int movesLeft = remaining_moves - 1;
            
            // If we have even number of moves left, we can do remove/add pairs
            // and end up with the same element on top
            if (movesLeft % 2 == 0) {
                if (maxRemoved > maxResult) {
                    maxResult = maxRemoved;
                }
            }
        }
    }
    
    return maxResult;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[100000];
    int count = 0;
    
    char* ptr = line;
    // Skip to first '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++; // skip '['
    
    // Parse numbers
    while (*ptr && *ptr != ']' && count < 100000) {
        // Skip whitespace and commas
        while (*ptr == ' ' || *ptr == ',') ptr++;
        
        if (*ptr == ']') break;
        
        // Parse number
        char* start = ptr;
        if (*ptr == '-') ptr++; // handle negative numbers
        while (*ptr >= '0' && *ptr <= '9') ptr++;
        
        char temp = *ptr;
        *ptr = '\0';
        nums[count++] = atoi(start);
        *ptr = temp;
    }
    
    // Read k
    fgets(line, sizeof(line), stdin);
    int k = atoi(line);
    
    printf("%d\n", solution(nums, count, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

487 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