Maximize the Topmost Element After K Moves

Maximize the Topmost Element After K Moves - Problem

Array Greedy Medium

Maximize the Topmost Element After K Moves

You have a pile of integers represented as an array nums, where nums[0] is the topmost element. Your goal is to maximize the value of the topmost element after performing exactly k moves.

In each move, you can choose one of two operations:

Remove the topmost element from the pile (if not empty)
Add back any previously removed element to the top of the pile

The challenge is to strategically use these k moves to get the maximum possible value at the top. If it's impossible to have a non-empty pile after k moves, return -1.

Example: With pile [5, 2, 2, 4, 0, 6] and k = 4 moves, you could remove the first 3 elements (getting 5, 2, 2), then add back the maximum (5) to achieve a topmost value of 5.

Input & Output

example_1.py — Basic Case

$ Input: nums = [5,2,2,4,0,6], k = 4

› Output: 5

💡 Note: One optimal strategy: Remove elements 5,2,2 (3 moves), then add back 5 (1 move). The top element is now 5, which is the maximum possible.

example_2.py — Remove Exactly k

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

› Output: -1

💡 Note: With only one element and one move, we must remove the element, leaving an empty pile. Return -1.

example_3.py — Keep Current Top

$ Input: nums = [73,63,62,16,95], k = 2

› Output: 73

💡 Note: Remove top element 73 (1 move), then add it back (1 move). The pile remains [73,63,62,16,95] with top element 73.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 2 × 10⁵
All elements are non-negative integers

Visualization

Tap to expand

Understanding the Visualization

Analyze the Pile

Look at the pile [5,2,2,4,0,6] with k=4 moves

Consider Scenarios

Remove 0 elements (impossible with k=4), remove 1-3 elements + put back max, or remove 4 elements

Execute Best Strategy

Remove 5,2,2 (3 moves) then put back 5 (1 move)

Achieve Optimal Result

Top element is now 5, which is the maximum possible

Key Takeaway

🎯 Key Insight: Instead of exploring exponential combinations, recognize that optimal strategies follow predictable patterns - either remove some elements and put back the maximum, or remove exactly k elements to reveal a deeper element.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a greedy strategy that recognizes there are only k+1 meaningful scenarios to consider: either remove exactly i elements (0 ≤ i ≤ k) and put back the maximum, or remove exactly k elements to reveal the element at position k. This approach achieves O(n) time complexity by avoiding the exponential exploration of all possible move sequences.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Simulate All Move Sequences)	O(2^k)	O(k)	Try all possible sequences of k moves using recursion
Greedy Strategy (Optimal)	O(n)	O(1)	Analyze k+1 strategic scenarios to find the optimal move sequence

Brute Force (Simulate All Move Sequences) — Algorithm Steps

Use recursion with current pile state and remaining moves
At each step, try removing top element (if possible)
Also try adding back each previously removed element
Track maximum topmost value across all valid end states
Return -1 if no valid end state has non-empty pile

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original pile and k moves remaining

Branch on Moves

For each state, try all possible remove/add operations

Recursive Exploration

Recursively explore each branch until moves are exhausted

Track Maximum

Keep track of maximum topmost value across all valid end states

Code -

solution.c — C

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

int backtrack(int* pile, int pileSize, int* removed, int removedSize, int movesLeft) {
    if (movesLeft == 0) {
        return pileSize > 0 ? pile[0] : -1;
    }
    
    int maxVal = -1;
    
    // Try removing top element
    if (pileSize > 0) {
        int top = pile[0];
        int* newPile = (int*)malloc((pileSize-1) * sizeof(int));
        memcpy(newPile, pile + 1, (pileSize-1) * sizeof(int));
        int* newRemoved = (int*)malloc((removedSize+1) * sizeof(int));
        memcpy(newRemoved, removed, removedSize * sizeof(int));
        newRemoved[removedSize] = top;
        
        int val = backtrack(newPile, pileSize-1, newRemoved, removedSize+1, movesLeft-1);
        if (val > maxVal) maxVal = val;
        
        free(newPile);
        free(newRemoved);
    }
    
    // Try adding back any removed element
    for (int i = 0; i < removedSize; i++) {
        int element = removed[i];
        int* newPile = (int*)malloc((pileSize+1) * sizeof(int));
        newPile[0] = element;
        memcpy(newPile + 1, pile, pileSize * sizeof(int));
        
        int* newRemoved = (int*)malloc(removedSize * sizeof(int));
        memcpy(newRemoved, removed, i * sizeof(int));
        memcpy(newRemoved + i, removed + i + 1, (removedSize - i - 1) * sizeof(int));
        
        int val = backtrack(newPile, pileSize+1, newRemoved, removedSize-1, movesLeft-1);
        if (val > maxVal) maxVal = val;
        
        free(newPile);
        free(newRemoved);
    }
    
    return maxVal;
}

int maximumTop(int* nums, int numsSize, int k) {
    return backtrack(nums, numsSize, NULL, 0, k);
}

Time & Space Complexity

Time Complexity

⏱️

O(2^k)

Each of k moves has at most 2 choices (remove or add), leading to exponential branching

✓ Linear Growth

Space Complexity

O(k)

Recursion depth is k, plus space for tracking removed elements

✓ Linear Space

28.4K Views

Medium Frequency

~18 min Avg. Time

856 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 (Simulate All Move Sequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler