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

Earliest Second to Mark Indices II

Difficulty: Hard

Problem Description

You are given two 1-indexed integer arrays, nums and changeIndices, having lengths n and m, respectively. Initially, all indices in nums are unmarked. Your task is to mark all indices in nums. In each second, s, in order from 1 to m (inclusive), you can perform one of the following operations:

  • Choose an index i in the range [1, n] and decrement nums[i] by 1.
  • Set nums[changeIndices[s]] to any non-negative value.
  • Choose an index i in the range [1, n], where nums[i] is equal to 0, and mark index i.
  • Do nothing. Return an integer denoting the earliest second in the range [1, m] when all indices in nums can be marked by choosing operations optimally, or -1 if it is impossible.

Key Insights

  • The ability to mark an index relies on managing the values in the nums array effectively.
  • You can use the changeIndices array strategically to set elements of nums to zero.
  • The sequence of operations must be optimized to ensure that all indices can be marked within the time constraints.
  • It's crucial to track both the decrement actions and the setting actions to find the earliest possible second to mark all indices.

Space and Time Complexity

Time Complexity: O(n + m)
Space Complexity: O(n)

Solution

The solution involves keeping track of the nums array and the changeIndices, using a greedy strategy to minimize the time needed to mark all indices. The approach involves:

  1. Using a priority queue to manage the indices of nums based on their values, allowing for efficient access to the smallest values to mark.
  2. Iterating through the changeIndices to either set values in nums to zero or decrement existing values.
  3. Keeping a count of how many indices can be marked and determining if all can be marked within the given time.

Code Solutions

import heapq

def earliestSecond(nums, changeIndices):
    n = len(nums)
    m = len(changeIndices)
    
    # Priority queue to keep track of indices that can be marked
    min_heap = []
    marked = 0
    
    second = 0
    for second in range(1, m + 1):
        idx = changeIndices[second - 1] - 1  # Convert to 0-indexed
        
        # Set nums[idx] to 0
        nums[idx] = 0
        
        # If nums[idx] was 0, we can mark it immediately
        if nums[idx] == 0:
            heapq.heappush(min_heap, idx)
        
        # Process marking
        while min_heap and marked < n:
            min_index = heapq.heappop(min_heap)
            if nums[min_index] == 0:
                marked += 1

        # Decrement all values that are greater than 0
        for i in range(n):
            if nums[i] > 0:
                nums[i] -= 1
        
        # After processing, check if we can mark all
        if marked == n:
            return second

    return -1 if marked < n else second
← Back to All Questions