Earliest Second to Mark Indices I

Earliest Second to Mark Indices I - Problem

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.
If nums[changeIndices[s]] is equal to 0, mark the index changeIndices[s].
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.

Input & Output

Example 1 — Basic Case

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

› Output: 8

💡 Note: We need to decrement nums[0] twice, nums[1] twice, and mark all indices. Index 3 appears first at position 5, so we need at least 8 seconds to complete all operations.

Example 2 — Impossible Case

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

› Output: -1

💡 Note: changeIndices only covers indices 1 and 2, but we need to mark indices 1,2,3,4. Since indices 3 and 4 never appear, it's impossible.

Example 3 — All Zeros

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

› Output: 3

💡 Note: nums[1] needs 1 decrement. All indices appear exactly once, so we need 3 seconds: decrement nums[1], mark index 2, mark index 3, then we can mark index 1.

Constraints

1 ≤ nums.length ≤ 5000
0 ≤ nums[i] ≤ 10⁹
1 ≤ changeIndices.length ≤ 5000
1 ≤ changeIndices[i] ≤ nums.length

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is to use binary search on the answer space. We binary search on the minimum time needed, and for each candidate time, check if it's feasible using a greedy approach. Best approach is Binary Search on Answer with Time: O(n log m), Space: O(n).

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Binary Search on Answer

⏱️ Time: O(n log m + m log m) Space: O(n)

Use binary search to find the minimum time, and for each candidate time, greedily check if it's possible to mark all indices.

Brute Force - Try Every Second

⏱️ Time: O(m²n) Space: O(n)

For each possible ending second, simulate the entire process to see if all indices can be marked within that time limit.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_QUEUE 100000
#define MAX_VISITED 100000

typedef struct {
    int x, y;
} Point;

typedef struct {
    Point points[MAX_QUEUE];
    int front, rear;
} Queue;

typedef struct {
    Point points[MAX_VISITED];
    int count;
} VisitedSet;

void initQueue(Queue* q) {
    q->front = q->rear = 0;
}

bool isQueueEmpty(Queue* q) {
    return q->front == q->rear;
}

void enqueue(Queue* q, Point p) {
    q->points[q->rear++] = p;
}

Point dequeue(Queue* q) {
    return q->points[q->front++];
}

void initVisited(VisitedSet* v) {
    v->count = 0;
}

bool isVisited(VisitedSet* v, Point p) {
    for (int i = 0; i < v->count; i++) {
        if (v->points[i].x == p.x && v->points[i].y == p.y) {
            return true;
        }
    }
    return false;
}

void addVisited(VisitedSet* v, Point p) {
    if (v->count < MAX_VISITED) {
        v->points[v->count++] = p;
    }
}

bool isBlocked(int** blocked, int blockedSize, Point p) {
    for (int i = 0; i < blockedSize; i++) {
        if (blocked[i][0] == p.x && blocked[i][1] == p.y) {
            return true;
        }
    }
    return false;
}

bool bfs(Point start, Point end, int** blocked, int blockedSize, int maxArea) {
    if (isBlocked(blocked, blockedSize, start)) return false;
    
    Queue q;
    VisitedSet visited;
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    
    initQueue(&q);
    initVisited(&visited);
    
    enqueue(&q, start);
    addVisited(&visited, start);
    
    while (!isQueueEmpty(&q) && visited.count <= maxArea) {
        Point curr = dequeue(&q);
        
        if (curr.x == end.x && curr.y == end.y) return true;
        
        for (int i = 0; i < 4; i++) {
            Point next = {curr.x + directions[i][0], curr.y + directions[i][1]};
            
            if (next.x >= 0 && next.x < 1000000 && next.y >= 0 && next.y < 1000000) {
                if (!isBlocked(blocked, blockedSize, next) && !isVisited(&visited, next)) {
                    addVisited(&visited, next);
                    enqueue(&q, next);
                }
            }
        }
    }
    
    return visited.count > maxArea;
}

bool solution(int** blocked, int blockedSize, int* blockedColSize, int* source, int sourceSize, int* target, int targetSize) {
    if (blockedSize == 0) return true;
    
    int maxArea = blockedSize * (blockedSize - 1) / 2;
    Point sourcePoint = {source[0], source[1]};
    Point targetPoint = {target[0], target[1]};
    
    return bfs(sourcePoint, targetPoint, blocked, blockedSize, maxArea) && 
           bfs(targetPoint, sourcePoint, blocked, blockedSize, maxArea);
}

int main() {
    char line1[1000], line2[100], line3[100];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    fgets(line3, sizeof(line3), stdin);
    
    // Parse blocked array
    int** blocked = NULL;
    int blockedSize = 0;
    
    if (strncmp(line1, "[]", 2) != 0) {
        // Simple parsing - count pairs
        char* ptr = line1;
        while (*ptr) {
            if (*ptr == '[' && *(ptr+1) != ']') blockedSize++;
            ptr++;
        }
        
        if (blockedSize > 0) {
            blocked = malloc(blockedSize * sizeof(int*));
            for (int i = 0; i < blockedSize; i++) {
                blocked[i] = malloc(2 * sizeof(int));
            }
            
            // Parse coordinates
            ptr = line1;
            int idx = 0;
            while (*ptr && idx < blockedSize) {
                if (*ptr == '[' && *(ptr+1) != ']') {
                    ptr++; // skip [
                    int x = 0, y = 0;
                    // Parse x
                    while (*ptr && *ptr != ',') {
                        x = x * 10 + (*ptr - '0');
                        ptr++;
                    }
                    ptr++; // skip comma
                    // Parse y
                    while (*ptr && *ptr != ']') {
                        y = y * 10 + (*ptr - '0');
                        ptr++;
                    }
                    blocked[idx][0] = x;
                    blocked[idx][1] = y;
                    idx++;
                }
                ptr++;
            }
        }
    }
    
    // Parse source
    int source[2];
    sscanf(line2, "[%d,%d]", &source[0], &source[1]);
    
    // Parse target  
    int target[2];
    sscanf(line3, "[%d,%d]", &target[0], &target[1]);
    
    int* blockedColSize = malloc(blockedSize * sizeof(int));
    for (int i = 0; i < blockedSize; i++) {
        blockedColSize[i] = 2;
    }
    
    bool result = solution(blocked, blockedSize, blockedColSize, source, 2, target, 2);
    printf(result ? "true\n" : "false\n");
    
    // Cleanup
    for (int i = 0; i < blockedSize; i++) {
        free(blocked[i]);
    }
    free(blocked);
    free(blockedColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

12.4K Views

Medium Frequency

~35 min Avg. Time

445 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