Earliest Second to Mark Indices I - Practice Coding Problems

Earliest Second to Mark Indices I - Problem

You're given two arrays: nums and changeIndices. Your goal is to mark all indices in the nums array by strategically choosing operations over time.

The Rules:

Each second s (from 1 to m), you can perform one of these operations:
🔽 Decrement: Choose any index i and reduce nums[i] by 1
✅ Mark: If nums[changeIndices[s]] == 0, mark index changeIndices[s]
⏸️ Do nothing: Skip the second

The catch? You can only mark an index when its value reaches exactly 0, and only when changeIndices[s] points to that index.

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

Example: If nums = [2,2,0] and changeIndices = [2,2,2,2,3,2,1,1], you need to reduce nums[1] and nums[2] to 0, then mark them when changeIndices allows.

Input & Output

example_1.py — Basic Case

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

› Output: 8

💡 Note: We need to reduce nums[0] and nums[1] to 0, then mark all indices. The optimal strategy uses all 8 seconds: decrement operations followed by marking when changeIndices allows.

example_2.py — Quick Success

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

› Output: 6

💡 Note: Each index needs 1 decrement + 1 mark operation. With 6 seconds and good changeIndices coverage, we can complete all operations by second 6.

example_3.py — Impossible Case

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

› Output: -1

💡 Note: Index 1 (0-based index 0) never appears in changeIndices, so it can never be marked. Therefore, it's impossible to mark all indices.

Constraints

1 ≤ n, m ≤ 5000
0 ≤ nums[i] ≤ 10⁹
1 ≤ changeIndices[i] ≤ n
All arrays are 1-indexed in the problem statement

Visualization

Tap to expand

Understanding the Visualization

Setup Production

Each product needs specific processing time (nums[i] decrements)

Conveyor Belt

changeIndices tells us when each product can be shipped

Optimize Schedule

Binary search finds minimum time needed for all products

Greedy Verification

Check if we can fit all operations within the time limit

Key Takeaway

🎯 Key Insight: Binary search on time + greedy verification gives us O(m log m) complexity, much better than brute force simulation.

Asked in

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

The optimal solution uses binary search on the answer combined with greedy verification. Since if we can mark all indices by time t, we can also do it by time t+1, we can binary search for the minimum feasible time. For verification, we use a greedy strategy: find the last occurrence of each index, ensure all indices appear, then check if we have enough time for all required operations.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Greedy Verification	O(m log m)	O(n)	Binary search on the answer, then greedily verify if it's achievable
Brute Force Simulation	O(m * 3^m)	O(n)	Try each second from 1 to m and simulate the entire process

Binary Search + Greedy Verification — Algorithm Steps

Binary search on time from 1 to m
For each mid time, check if it's possible to mark all indices
Use greedy strategy: mark indices as late as possible when they're ready
Count total operations needed and compare with available time
Adjust search range based on feasibility

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search Setup

Search space: 1 to m seconds

Check Mid Point

Can we mark all indices by time mid?

Greedy Verification

Use greedy strategy to verify feasibility

Update Search Range

Narrow down based on result

Code -

solution.c — C

typedef struct {
    int lastTime;
    int decrements;
} Operation;

int compareOps(const void* a, const void* b) {
    return ((Operation*)a)->lastTime - ((Operation*)b)->lastTime;
}

bool canMarkAll(int* nums, int numsSize, int* changeIndices, int maxTime) {
    int lastOcc[1001];
    bool hasOcc[1001];
    memset(hasOcc, false, sizeof(hasOcc));
    
    for (int s = 0; s < maxTime; s++) {
        int idx = changeIndices[s] - 1;
        lastOcc[idx] = s;
        hasOcc[idx] = true;
    }
    
    int count = 0;
    for (int i = 0; i < numsSize; i++) {
        if (hasOcc[i]) count++;
    }
    if (count < numsSize) return false;
    
    Operation* operations = (Operation*)malloc(numsSize * sizeof(Operation));
    int opCount = 0;
    
    for (int idx = 0; idx < numsSize; idx++) {
        if (hasOcc[idx]) {
            operations[opCount].lastTime = lastOcc[idx];
            operations[opCount].decrements = nums[idx];
            opCount++;
        }
    }
    
    qsort(operations, opCount, sizeof(Operation), compareOps);
    
    int totalOps = 0;
    bool result = true;
    for (int i = 0; i < opCount; i++) {
        int availableTime = operations[i].lastTime - totalOps;
        if (availableTime < operations[i].decrements) {
            result = false;
            break;
        }
        totalOps += operations[i].decrements + 1;
    }
    
    free(operations);
    return result && totalOps <= maxTime;
}

int earliestSecondToMarkIndices(int* nums, int numsSize, int* changeIndices, int changeIndicesSize) {
    int left = 1, right = changeIndicesSize, result = -1;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (canMarkAll(nums, numsSize, changeIndices, mid)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m log m)

Binary search O(log m) times, each verification takes O(m)

⚡ Linearithmic

Space Complexity

O(n)

Space for tracking last occurrence and operations needed

⚡ Linearithmic Space

20.9K Views

Medium Frequency

~35 min Avg. Time

892 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

Binary Search + Greedy Verification — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler