We use cookies (including Google cookies) to personalize ads and analyze traffic. By continuing to use our site, you accept our Privacy Policy.

SimplyLeet
TagsDisclaimersPrivacyTermsContactAbout Us

Last Stone Weight

Difficulty: Easy

Problem Description

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 the heaviest two stones and smash them together. Suppose the heaviest two stones have weights x and y with x <= y. The result of this smash is:

  • If x == y, both stones are destroyed, and
  • 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 weight of the last remaining stone. If there are no stones left, return 0.

Key Insights

  • The problem involves repeatedly selecting and modifying the heaviest stones.
  • A max-heap (or priority queue) is ideal for efficiently retrieving the two heaviest stones.
  • The game continues until either no stones are left or one stone remains.

Space and Time Complexity

Time Complexity: O(n log n) - where n is the number of stones, due to the heap operations. Space Complexity: O(n) - for storing the stones in the heap.

Solution

To solve the problem, we can use a max-heap data structure to manage the stones' weights. The algorithm follows these steps:

  1. Insert all stone weights into a max-heap.
  2. While there are at least two stones in the heap:
    • Extract the two heaviest stones.
    • If they are of different weights, compute the new weight and insert it back into the heap.
  3. If one stone remains, return its weight; if none remain, return 0.

This approach ensures that we always handle the heaviest stones first.

Code Solutions

import heapq

def lastStoneWeight(stones):
    # Convert stones to a max-heap by negating the values
    stones = [-stone for stone in stones]
    heapq.heapify(stones)
    
    while len(stones) > 1:
        # Get the two heaviest stones
        first = -heapq.heappop(stones)
        second = -heapq.heappop(stones)
        
        if first != second:
            # Push the difference back to the heap
            heapq.heappush(stones, -(first - second))
    
    # If there is one stone left, return its weight; otherwise return 0
    return -stones[0] if stones else 0
← Back to All Questions