Remove Stones to Minimize the Total - Practice Coding Problems

Remove Stones to Minimize the Total - Problem

Imagine you're a mining engineer tasked with optimizing stone removal operations! You have several stone piles and a limited number of operations to minimize the total stones remaining.

Given a 0-indexed integer array piles where piles[i] represents the number of stones in the i-th pile, and an integer k representing the number of operations you can perform.

In each operation, you must:

Choose any pile piles[i]
Remove exactly ⌊piles[i] / 2⌋ stones from it (floor division)

Strategy matters! You can apply operations to the same pile multiple times. Your goal is to find the minimum possible total number of stones remaining after exactly k operations.

For example: If a pile has 10 stones, one operation removes ⌊10/2⌋ = 5 stones, leaving 5 stones behind.

Input & Output

example_1.py — Basic Example

$ Input: piles = [5,4,9], k = 2

› Output: 12

💡 Note: Operation 1: Remove floor(9/2) = 4 from pile with 9 stones → [5,4,5]. Operation 2: Remove floor(5/2) = 2 from any pile with 5 stones → [3,4,5] or [5,4,3] or [5,2,5]. Total remaining: 3+4+5 = 12.

example_2.py — Single Pile

$ Input: piles = [4,3,6,7], k = 3

› Output: 12

💡 Note: Operation 1: Remove floor(7/2) = 3 from 7 → [4,3,6,4]. Operation 2: Remove floor(6/2) = 3 from 6 → [4,3,3,4]. Operation 3: Remove floor(4/2) = 2 from any 4 → [2,3,3,4]. Total: 2+3+3+4 = 12.

example_3.py — Edge Case

$ Input: piles = [1], k = 1

› Output: 1

💡 Note: Only one pile with 1 stone. Removing floor(1/2) = 0 stones leaves 1-0 = 1 stone remaining.

Visualization

Tap to expand

Understanding the Visualization

Identify Largest Pile

Use a max heap to always know which pile has the most stones

Apply Optimal Operation

Remove floor(largest/2) stones from the biggest pile

Update Priority

Put the reduced pile back and re-sort priorities

Repeat Process

Continue for k operations, always targeting the largest

Key Takeaway

🎯 Key Insight: The greedy strategy of always choosing the largest pile is optimal because removing stones from larger piles creates the maximum reduction in total stones remaining.

Time & Space Complexity

Time Complexity

⏱️

O(n^k)

For each of k operations, we try all n piles, leading to n^k combinations

✓ Linear Growth

Space Complexity

O(k)

Recursion depth is k for the call stack

✓ Linear Space

Constraints

1 ≤ piles.length ≤ 10⁵
1 ≤ piles[i] ≤ 10⁴
1 ≤ k ≤ 10⁵
Key insight: Always target the largest pile for maximum stone reduction

Asked in

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

The optimal solution uses a max heap (priority queue) with a greedy approach. Since removing stones from larger piles yields greater reduction, we always target the largest pile. The heap efficiently maintains the maximum element, giving us O(k log n) time complexity for k operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n^k)	O(k)	Try all possible ways to apply k operations and find minimum
Max Heap (Priority Queue) - Optimal	O(n + k log n)	O(n)	Use max heap to always remove stones from the largest pile

Brute Force (Try All Combinations) — Algorithm Steps

For each operation, try applying it to every possible pile
Recursively explore all combinations of k operations
Keep track of the minimum total stones found
Return the minimum across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original piles and k operations

Branch for Each Pile

For each operation, try applying it to every pile

Recursive Exploration

Continue branching until all k operations are used

Find Minimum

Compare all leaf node totals to find minimum

Code -

solution.c — C

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

int sum_array(int* arr, int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

int backtrack(int* currentPiles, int size, int operationsLeft) {
    if (operationsLeft == 0) {
        return sum_array(currentPiles, size);
    }
    
    int minTotal = INT_MAX;
    for (int i = 0; i < size; i++) {
        if (currentPiles[i] > 0) {
            int original = currentPiles[i];
            currentPiles[i] -= currentPiles[i] / 2;
            int result = backtrack(currentPiles, size, operationsLeft - 1);
            if (result < minTotal) {
                minTotal = result;
            }
            currentPiles[i] = original;
        }
    }
    
    return minTotal;
}

int minStoneSum(int* piles, int pilesSize, int k) {
    int* copy = malloc(pilesSize * sizeof(int));
    for (int i = 0; i < pilesSize; i++) {
        copy[i] = piles[i];
    }
    int result = backtrack(copy, pilesSize, k);
    free(copy);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^k)

For each of k operations, we try all n piles, leading to n^k combinations

✓ Linear Growth

Space Complexity

O(k)

Recursion depth is k for the call stack

✓ Linear Space

Constraints

1 ≤ piles.length ≤ 10⁵
1 ≤ piles[i] ≤ 10⁴
1 ≤ k ≤ 10⁵
Key insight: Always target the largest pile for maximum stone reduction

42.0K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler