Earliest Second to Mark Indices II - Practice Coding Problems

Earliest Second to Mark Indices II - Problem

Earliest Second to Mark Indices II is a challenging optimization problem that simulates a time-based marking system.

You are given two arrays: nums (1-indexed, length n) containing positive integers, and changeIndices (1-indexed, length m) containing indices that reference positions in nums.

Goal: Mark all indices in nums in the minimum number of seconds.

Rules for each second s (from 1 to m):
1. Decrement: Choose any index i and reduce nums[i] by 1
2. Reset: Set nums[changeIndices[s]] to any non-negative value
3. Mark: Mark index i if nums[i] == 0
4. Do nothing

An index can only be marked when its value reaches 0. The challenge is to optimally use reset operations (which can instantly zero out values) and decrement operations to mark everything as quickly as possible.

Return: The earliest second when all indices can be marked, or -1 if impossible.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2, 2, 0], changeIndices = [2, 2, 2, 2, 3, 2, 2, 2]

› Output: 8

💡 Note: We can mark all indices by second 8. Use reset operations on indices 2 and 3 at their last available times, then decrement and mark index 1 (which has no reset opportunity).

example_2.py — Reset Required

$ Input: nums = [1, 3], changeIndices = [1, 1, 1, 2, 1, 1, 1]

› Output: 6

💡 Note: Reset index 2 at second 4, mark it at second 5. For index 1, decrement once and mark, which takes 2 more operations. Total minimum time is 6 seconds.

example_3.py — Impossible Case

$ Input: nums = [0, 1, 1, 2], changeIndices = [1, 1, 2]

› Output: -1

💡 Note: Index 4 (with value 2) never appears in changeIndices, so we need 3 operations (2 decrements + 1 mark). But we only have 3 seconds total, and we also need to handle other indices. Impossible.

Constraints

1 ≤ n == nums.length ≤ 5000
0 ≤ nums[i] ≤ 10⁹
1 ≤ m == changeIndices.length ≤ 5000
1 ≤ changeIndices[i] ≤ n
Time limit: 2000ms for optimal solution

Visualization

Tap to expand

Understanding the Visualization

Identify Reset Opportunities

Find the latest time each index can be reset based on changeIndices

Schedule Reset Operations

Place reset+mark pairs at their latest possible times

Fill Remaining Time

Use remaining time slots for decrement operations

Verify Feasibility

Check if all operations fit within the time limit

Key Takeaway

🎯 Key Insight: By delaying reset operations until their latest possible moment, we maximize our scheduling flexibility and minimize the total time needed to mark all indices.

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach uses binary search on the answer combined with greedy simulation. Key insights: (1) Binary search the minimum time needed from 1 to m, (2) For each candidate time, use greedy strategy to delay reset operations until their latest possible moment, (3) Calculate if all required operations can fit within the time limit. Time complexity is O(m log m) making it efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(4^m * n)	O(n)	Try every possible second and simulate all action sequences
Binary Search + Greedy Simulation	O(m log m)	O(n + m)	Binary search on answer with greedy simulation to check feasibility

Brute Force Simulation — Algorithm Steps

For each second t from 1 to m
Try all possible action sequences of length t
For each sequence, simulate the operations
Check if all indices can be marked by second t
Return the minimum t that works

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Simulation

Begin at second 1 with original nums array

Branch Operations

For each second, try all 4 possible operations

Recursive Exploration

Recursively explore each branch to see if it leads to success

Check Completion

At each step, check if all indices are marked

Code -

solution.c — C

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

bool backtrack(int second, int* currentNums, bool* marked, int* changeIndices, 
               int maxSeconds, int n, int m) {
    if (second > maxSeconds) {
        for (int i = 0; i < n; i++) {
            if (!marked[i]) return false;
        }
        return true;
    }
    
    bool allMarked = true;
    for (int i = 0; i < n; i++) {
        if (!marked[i]) {
            allMarked = false;
            break;
        }
    }
    if (allMarked) return true;
    
    // Try decrement
    for (int i = 0; i < n; i++) {
        if (currentNums[i] > 0) {
            currentNums[i]--;
            int* newNums = malloc(n * sizeof(int));
            bool* newMarked = malloc(n * sizeof(bool));
            memcpy(newNums, currentNums, n * sizeof(int));
            memcpy(newMarked, marked, n * sizeof(bool));
            if (backtrack(second + 1, newNums, newMarked, changeIndices, maxSeconds, n, m)) {
                free(newNums);
                free(newMarked);
                return true;
            }
            free(newNums);
            free(newMarked);
            currentNums[i]++;
        }
    }
    
    // Try reset
    if (second <= m) {
        int idx = changeIndices[second - 1] - 1;
        int oldVal = currentNums[idx];
        currentNums[idx] = 0;
        int* newNums = malloc(n * sizeof(int));
        bool* newMarked = malloc(n * sizeof(bool));
        memcpy(newNums, currentNums, n * sizeof(int));
        memcpy(newMarked, marked, n * sizeof(bool));
        if (backtrack(second + 1, newNums, newMarked, changeIndices, maxSeconds, n, m)) {
            free(newNums);
            free(newMarked);
            return true;
        }
        free(newNums);
        free(newMarked);
        currentNums[idx] = oldVal;
    }
    
    // Try mark
    for (int i = 0; i < n; i++) {
        if (currentNums[i] == 0 && !marked[i]) {
            marked[i] = true;
            int* newNums = malloc(n * sizeof(int));
            bool* newMarked = malloc(n * sizeof(bool));
            memcpy(newNums, currentNums, n * sizeof(int));
            memcpy(newMarked, marked, n * sizeof(bool));
            if (backtrack(second + 1, newNums, newMarked, changeIndices, maxSeconds, n, m)) {
                free(newNums);
                free(newMarked);
                return true;
            }
            free(newNums);
            free(newMarked);
            marked[i] = false;
        }
    }
    
    return false;
}

int earliestSecondToMarkIndices(int* nums, int numsSize, int* changeIndices, int changeIndicesSize) {
    for (int t = 1; t <= changeIndicesSize; t++) {
        int* currentNums = malloc(numsSize * sizeof(int));
        bool* marked = malloc(numsSize * sizeof(bool));
        memcpy(currentNums, nums, numsSize * sizeof(int));
        memset(marked, false, numsSize * sizeof(bool));
        
        if (backtrack(1, currentNums, marked, changeIndices, t, numsSize, changeIndicesSize)) {
            free(currentNums);
            free(marked);
            return t;
        }
        free(currentNums);
        free(marked);
    }
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^m * n)

4 possible operations per second, m seconds to simulate, n indices to track

✓ Linear Growth

Space Complexity

O(n)

Space to store the current state of nums array

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~35 min Avg. Time

847 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