Last Stone Weight II - Practice Coding Problems

Last Stone Weight II - Problem

Last Stone Weight II is a fascinating optimization problem that challenges you to think strategically about stone smashing!

Imagine you're playing a destructive game with stones of different weights. In each turn, you pick any two stones and smash them together. Here's what happens:

• If both stones have the same weight → Both stones are completely destroyed! 💥
• If they have different weights → The lighter stone is destroyed, and the heavier stone survives but loses weight equal to the lighter stone

For example, if you smash stones of weight 7 and 3, the stone of weight 3 disappears, and you're left with a stone of weight 7 - 3 = 4.

Your goal is to find the smallest possible weight of the final remaining stone after all possible smashing is done. If no stones remain, return 0.

The key insight: This isn't just about randomly smashing stones – there's an optimal strategy hidden within!

Input & Output

example_1.py — Basic Case

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

› Output: 0

💡 Note: We can arrange stones optimally: Combine 2+4=6 and 7+1=8, then combine 6 and 8 to get |8-6|=2. But better: combine stones to get two groups [7,1] and [2,4] with sums 8 and 6, difference is 2. Actually optimal is [7+1] vs [4+2] = 8 vs 6 = difference 2. Wait, even better: we can achieve perfect balance with subset [7] = 7 and remaining [2,4,1] = 7, so difference is 0!

example_2.py — Odd Sum

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

› Output: 1

💡 Note: Total sum = 151. We need to find subset closest to 151/2 = 75.5. The best we can do is find a subset with sum 75, leaving remainder with sum 76. Difference = |76-75| = 1.

example_3.py — Single Stone

$ Input: [1]

› Output: 1

💡 Note: With only one stone, no smashing is possible. The final weight is the stone's original weight: 1.

Visualization

Tap to expand

Understanding the Visualization

Reframe the problem

Instead of simulating stone smashing, think about dividing stones into two groups

Find balanced partition

The goal is to make the two groups have sums as close as possible

Use DP for subset sum

Dynamic programming efficiently finds which subset sums are achievable

Calculate final difference

The minimum remaining weight is |total - 2 × best_sum|

Key Takeaway

🎯 Key Insight: Transform the stone smashing simulation into a balanced partition problem - much more efficient to solve!

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate all 2^n possible subsets of stones

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth for generating subsets

⚡ Linearithmic Space

Constraints

1 ≤ stones.length ≤ 30
1 ≤ stones[i] ≤ 100
Key insight: This is equivalent to partitioning stones into two groups with minimum difference

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28

The key insight is that this problem is equivalent to partitioning stones into two groups with minimum sum difference. Use dynamic programming to find all achievable subset sums, then find the sum closest to half the total. The answer is total - 2 × closest_sum.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Partitions)	O(2^n)	O(n)	Generate all possible ways to partition stones into two groups
Dynamic Programming (Subset Sum)	O(n × sum)	O(sum)	Use DP to find all possible subset sums, then find closest to total/2

Brute Force (Try All Partitions) — Algorithm Steps

Generate all possible subsets of stones (2^n possibilities)
For each subset, calculate sum of stones in subset and sum of remaining stones
Calculate absolute difference between the two sums
Keep track of minimum difference seen so far
Return the minimum difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with empty sets

Initialize two empty groups for stones

Try both choices

For each stone, try putting it in group 1 or group 2

Calculate differences

When all stones are assigned, calculate |sum1 - sum2|

Track minimum

Keep the smallest difference found across all partitions

Code -

solution.c — C

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

int generateSubsets(int* stones, int size, int index, int currentSum, int totalSum) {
    if (index == size) {
        int otherSum = totalSum - currentSum;
        return abs(currentSum - otherSum);
    }
    
    // Include current stone in subset
    int include = generateSubsets(stones, size, index + 1, currentSum + stones[index], totalSum);
    // Exclude current stone from subset
    int exclude = generateSubsets(stones, size, index + 1, currentSum, totalSum);
    
    return (include < exclude) ? include : exclude;
}

int lastStoneWeightII(int* stones, int stonesSize) {
    int total = 0;
    for (int i = 0; i < stonesSize; i++) {
        total += stones[i];
    }
    return generateSubsets(stones, stonesSize, 0, 0, total);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate all 2^n possible subsets of stones

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth for generating subsets

⚡ Linearithmic Space

Constraints

1 ≤ stones.length ≤ 30
1 ≤ stones[i] ≤ 100
Key insight: This is equivalent to partitioning stones into two groups with minimum difference

42.4K Views

Medium-High Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Partitions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler