Remove Stones to Minimize the Total

Remove Stones to Minimize the Total - Problem

You are given a 0-indexed integer array piles, where piles[i] represents the number of stones in the ith pile, and an integer k. You should apply the following operation exactly k times:

Choose any piles[i] and remove floor(piles[i] / 2) stones from it.

Notice that you can apply the operation on the same pile more than once.

Return the minimum possible total number of stones remaining after applying the k operations.

floor(x) is the largest integer that is smaller than or equal to x (i.e., rounds x down).

Input & Output

Example 1 — Basic Case

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

› Output: 12

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

Example 2 — Single Operation

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

› Output: 17

💡 Note: Remove floor(7/2) = 3 stones from the largest pile (7), leaving [4,3,6,4]. Total remaining = 4 + 3 + 6 + 4 = 17.

Example 3 — Multiple Operations on Same Pile

$ Input: piles = [20], k = 3

› Output: 3

💡 Note: Operation 1: 20 → 10 (remove 10). Operation 2: 10 → 5 (remove 5). Operation 3: 5 → 3 (remove 2). Final result = 3.

Constraints

1 ≤ piles.length ≤ 10⁵
1 ≤ piles[i] ≤ 10⁴
1 ≤ k ≤ 10⁵

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 M Microsoft 32 f Facebook 28

The key insight is to always remove stones from the largest pile to maximize reduction. Best approach uses a max heap for O(log n) operations. Time: O(n + k log n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Combinations

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

Generate all possible ways to apply k operations across the piles and find the combination that minimizes the total remaining stones. This involves recursive exploration of all choices.

Greedy with Sorting

⏱️ Time: O(k * n log n) Space: O(1)

Sort the array after each operation and always remove stones from the largest pile. This greedy approach ensures maximum stone reduction at each step.

Max Heap (Optimal)

⏱️ Time: O(n + k log n) Space: O(n)

Use a priority queue (max heap) to maintain the largest pile at the top. For each operation, extract the maximum, apply the operation, and reinsert. This avoids repeated sorting.

Brute Force - Try All Combinations — Algorithm Steps

For each operation, try applying it to every pile
Recursively explore all k operations
Track the minimum total stones across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original piles

Explore All Paths

Try applying operation on each pile recursively

Find Minimum

Return the path with minimum total stones

Code -

solution.c — C

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

int solve(int* currentPiles, int n, int operationsLeft) {
    if (operationsLeft == 0) {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += currentPiles[i];
        }
        return sum;
    }
    
    int minResult = INT_MAX;
    for (int i = 0; i < n; i++) {
        if (currentPiles[i] > 0) {
            // Apply operation on pile i
            int removed = currentPiles[i] / 2;
            currentPiles[i] -= removed;
            int result = solve(currentPiles, n, operationsLeft - 1);
            if (result < minResult) {
                minResult = result;
            }
            // Backtrack
            currentPiles[i] += removed;
        }
    }
    
    return minResult;
}

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

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int piles[100];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            piles[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(piles, n, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^k)

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

⚡ Linearithmic

Space Complexity

O(k)

Recursion depth of k for the call stack

⚡ Linearithmic Space

89.5K Views

Medium Frequency

~15 min Avg. Time

2.8K 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler