Last Stone Weight II

Last Stone Weight II - Problem

You are given an array of integers stones where stones[i] is the weight of the i-th stone.

We are playing a game with the stones. On each turn, we choose any two stones and smash them together. Suppose the stones have weights x and y with x ≤ y. The result of this smash is:

If x == y, both stones are destroyed
If x != y, the stone of weight x is destroyed, and the stone of weight y has new weight y - x

At the end of the game, there is at most one stone left. Return the smallest possible weight of the left stone. If there are no stones left, return 0.

Input & Output

Example 1 — Balanced Partition

$ Input: stones = [2,7,4,1]

› Output: 0

💡 Note: We can partition stones into {7} and {2,4,1}. Both groups have weight 7, so when all stones are smashed optimally, the final weight is |7-7| = 0.

Example 2 — Unbalanced Result

$ Input: stones = [31,26,33,21,40]

› Output: 5

💡 Note: Total weight is 151. We need to partition stones into two groups with minimum difference. Using dynamic programming to find the best subset sum ≤ 75, we can achieve a partition where one group has weight 73 and the other has weight 78, giving minimum final weight of |78-73| = 5.

Example 3 — Single Stone

$ Input: stones = [1]

› Output: 1

💡 Note: Only one stone remains untouched, so the answer is 1.

Constraints

1 ≤ stones.length ≤ 30
1 ≤ stones[i] ≤ 100

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 8

The key insight is that this stone smashing game is equivalent to partitioning stones into two groups with minimal weight difference. The optimal approach uses dynamic programming to find all possible subset sums, then selects the partition closest to half the total weight. Time: O(n × sum), Space: O(sum).

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(2ⁿ) Space: O(n)

Try every possible pair of stones to smash, recursively explore all outcomes, and return the minimum final weight across all possibilities.

Dynamic Programming - Subset Sum

⏱️ Time: O(n × sum) Space: O(sum)

The key insight is that this problem is equivalent to partitioning stones into two groups such that their weight difference is minimized. We can use subset sum DP to find all possible sums.

Brute Force Simulation — Algorithm Steps

Try smashing every pair of stones
Recursively solve the remaining subproblem
Return minimum result across all choices

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with all stones

Try All Pairs

For each pair, smash and recurse

Find Minimum

Return smallest final weight

Code -

solution.c — C

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

int backtrack(int* arr, int size) {
    if (size <= 1) {
        return size == 0 ? 0 : arr[0];
    }
    
    int minResult = INT_MAX;
    for (int i = 0; i < size; i++) {
        for (int j = i + 1; j < size; j++) {
            int newArr[100];
            int newSize = 0;
            for (int k = 0; k < size; k++) {
                if (k != i && k != j) {
                    newArr[newSize++] = arr[k];
                }
            }
            int diff = abs(arr[i] - arr[j]);
            if (diff > 0) {
                newArr[newSize++] = diff;
            }
            int result = backtrack(newArr, newSize);
            if (result < minResult) {
                minResult = result;
            }
        }
    }
    
    return minResult;
}

int solution(int* stones, int size) {
    return backtrack(stones, size);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int stones[100];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        stones[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(stones, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Each stone can be paired with any other, creating exponential branching

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth proportional to number of stones

✓ Linear Space

89.0K Views

Medium Frequency

~15 min Avg. Time

1.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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler